Add i32x4.dot_i16x8_s (#2420)

This experimental instruction is specified in
https://github.com/WebAssembly/simd/pull/127 and is being implemented
to enable further investigation of its performance impact.

27 files changed, 845 insertions, 709 deletions

diff --git a/build-js.sh b/build-js.sh
index 5fce27497..c1bbad19c 100755
--- a/build-js.sh
+++ b/build-js.sh
@@ -526,6 +526,7 @@ export_function "_BinaryenMinSVecI32x4"
 export_function "_BinaryenMinUVecI32x4"
 export_function "_BinaryenMaxSVecI32x4"
 export_function "_BinaryenMaxUVecI32x4"
+export_function "_BinaryenDotSVecI16x8ToVecI32x4"
 export_function "_BinaryenNegVecI64x2"
 export_function "_BinaryenAnyTrueVecI64x2"
 export_function "_BinaryenAllTrueVecI64x2"
diff --git a/scripts/gen-s-parser.py b/scripts/gen-s-parser.py
index 0b841f220..53b04e563 100755
--- a/scripts/gen-s-parser.py
+++ b/scripts/gen-s-parser.py
@@ -405,6 +405,7 @@ instructions = [
     ("i32x4.min_u",          "makeBinary(s, BinaryOp::MinUVecI32x4)"),
     ("i32x4.max_s",          "makeBinary(s, BinaryOp::MaxSVecI32x4)"),
     ("i32x4.max_u",          "makeBinary(s, BinaryOp::MaxUVecI32x4)"),
+    ("i32x4.dot_i16x8_s",    "makeBinary(s, BinaryOp::DotSVecI16x8ToVecI32x4)"),
     ("i64x2.neg",            "makeUnary(s, UnaryOp::NegVecI64x2)"),
     ("i64x2.any_true",       "makeUnary(s, UnaryOp::AnyTrueVecI64x2)"),
     ("i64x2.all_true",       "makeUnary(s, UnaryOp::AllTrueVecI64x2)"),
diff --git a/src/binaryen-c.cpp b/src/binaryen-c.cpp
index 2b9b9d2ae..4e5ad22f1 100644
--- a/src/binaryen-c.cpp
+++ b/src/binaryen-c.cpp
@@ -842,6 +842,9 @@ BinaryenOp BinaryenMinSVecI32x4(void) { return MinSVecI32x4; }
 BinaryenOp BinaryenMinUVecI32x4(void) { return MinUVecI32x4; }
 BinaryenOp BinaryenMaxSVecI32x4(void) { return MaxSVecI32x4; }
 BinaryenOp BinaryenMaxUVecI32x4(void) { return MaxUVecI32x4; }
+BinaryenOp BinaryenDotSVecI16x8ToVecI32x4(void) {
+  return DotSVecI16x8ToVecI32x4;
+}
 BinaryenOp BinaryenNegVecI64x2(void) { return NegVecI64x2; }
 BinaryenOp BinaryenAnyTrueVecI64x2(void) { return AnyTrueVecI64x2; }
 BinaryenOp BinaryenAllTrueVecI64x2(void) { return AllTrueVecI64x2; }
diff --git a/src/binaryen-c.h b/src/binaryen-c.h
index 936cfb0f6..dd5acf325 100644
--- a/src/binaryen-c.h
+++ b/src/binaryen-c.h
@@ -504,6 +504,7 @@ BINARYEN_API BinaryenOp BinaryenMinSVecI32x4(void);
 BINARYEN_API BinaryenOp BinaryenMinUVecI32x4(void);
 BINARYEN_API BinaryenOp BinaryenMaxSVecI32x4(void);
 BINARYEN_API BinaryenOp BinaryenMaxUVecI32x4(void);
+BINARYEN_API BinaryenOp BinaryenDotSVecI16x8ToVecI32x4(void);
 BINARYEN_API BinaryenOp BinaryenNegVecI64x2(void);
 BINARYEN_API BinaryenOp BinaryenAnyTrueVecI64x2(void);
 BINARYEN_API BinaryenOp BinaryenAllTrueVecI64x2(void);
diff --git a/src/gen-s-parser.inc b/src/gen-s-parser.inc
index 9a8d9b88c..5e6e37f5a 100644
--- a/src/gen-s-parser.inc
+++ b/src/gen-s-parser.inc
@@ -1409,6 +1409,9 @@ switch (op[0]) {
                   default: goto parse_error;
                 }
               }
+              case 'd':
+                if (strcmp(op, "i32x4.dot_i16x8_s") == 0) { return makeBinary(s, BinaryOp::DotSVecI16x8ToVecI32x4); }
+                goto parse_error;
               case 'e': {
                 switch (op[7]) {
                   case 'q':
diff --git a/src/ir/cost.h b/src/ir/cost.h
index 26c120675..60eb84b08 100644
--- a/src/ir/cost.h
+++ b/src/ir/cost.h
@@ -648,6 +648,9 @@ struct CostAnalyzer : public Visitor<CostAnalyzer, Index> {
       case MaxUVecI32x4:
         ret = 1;
         break;
+      case DotSVecI16x8ToVecI32x4:
+        ret = 1;
+        break;
       case AddVecI64x2:
         ret = 1;
         break;
diff --git a/src/js/binaryen.js-post.js b/src/js/binaryen.js-post.js
index f2d679900..37d2432cb 100644
--- a/src/js/binaryen.js-post.js
+++ b/src/js/binaryen.js-post.js
@@ -357,6 +357,7 @@ Module['MinSVecI16x8'] = Module['_BinaryenMinSVecI16x8']();
 Module['MinUVecI16x8'] = Module['_BinaryenMinUVecI16x8']();
 Module['MaxSVecI16x8'] = Module['_BinaryenMaxSVecI16x8']();
 Module['MaxUVecI16x8'] = Module['_BinaryenMaxUVecI16x8']();
+Module['DotSVecI16x8ToVecI32x4'] = Module['_BinaryenDotSVecI16x8ToVecI32x4']();
 Module['NegVecI32x4'] = Module['_BinaryenNegVecI32x4']();
 Module['AnyTrueVecI32x4'] = Module['_BinaryenAnyTrueVecI32x4']();
 Module['AllTrueVecI32x4'] = Module['_BinaryenAllTrueVecI32x4']();
@@ -1676,6 +1677,9 @@ function wrapModule(module, self) {
     'max_u': function(left, right) {
       return Module['_BinaryenBinary'](module, Module['MaxUVecI32x4'], left, right);
     },
+    'dot_i16x8_s': function(left, right) {
+      return Module['_BinaryenBinary'](module, Module['DotSVecI16x8ToVecI32x4'], left, right);
+    },
     'trunc_sat_f32x4_s': function(value) {
       return Module['_BinaryenUnary'](module, Module['TruncSatSVecF32x4ToVecI32x4'], value);
     },
diff --git a/src/literal.h b/src/literal.h
index 007a2cde8..1106d1c27 100644
--- a/src/literal.h
+++ b/src/literal.h
@@ -364,6 +364,7 @@ public:
   Literal minUI32x4(const Literal& other) const;
   Literal maxSI32x4(const Literal& other) const;
   Literal maxUI32x4(const Literal& other) const;
+  Literal dotSI16x8toI32x4(const Literal& other) const;
   Literal negI64x2() const;
   Literal anyTrueI64x2() const;
   Literal allTrueI64x2() const;
diff --git a/src/passes/Print.cpp b/src/passes/Print.cpp
index e383974d6..bfd12dc94 100644
--- a/src/passes/Print.cpp
+++ b/src/passes/Print.cpp
@@ -1222,6 +1222,9 @@ struct PrintExpressionContents
       case MaxUVecI32x4:
         o << "i32x4.max_u";
         break;
+      case DotSVecI16x8ToVecI32x4:
+        o << "i32x4.dot_i16x8_s";
+        break;
       case AddVecI64x2:
         o << "i64x2.add";
         break;
diff --git a/src/tools/fuzzing.h b/src/tools/fuzzing.h
index c6cce4427..c66795c11 100644
--- a/src/tools/fuzzing.h
+++ b/src/tools/fuzzing.h
@@ -2169,6 +2169,7 @@ private:
                                  MinUVecI32x4,
                                  MaxSVecI32x4,
                                  MaxUVecI32x4,
+                                 DotSVecI16x8ToVecI32x4,
                                  AddVecI64x2,
                                  SubVecI64x2,
                                  AddVecF32x4,
diff --git a/src/wasm-binary.h b/src/wasm-binary.h
index 2a457f5a7..7014fd875 100644
--- a/src/wasm-binary.h
+++ b/src/wasm-binary.h
@@ -831,6 +831,7 @@ enum ASTNodes {
   I32x4MinU = 0x81,
   I32x4MaxS = 0x82,
   I32x4MaxU = 0x83,
+  I32x4DotSVecI16x8 = 0xd9,
   I64x2Neg = 0x84,
   I64x2AnyTrue = 0x85,
   I64x2AllTrue = 0x86,
diff --git a/src/wasm-interpreter.h b/src/wasm-interpreter.h
index f8cf3ae42..dc2696716 100644
--- a/src/wasm-interpreter.h
+++ b/src/wasm-interpreter.h
@@ -801,6 +801,8 @@ public:
         return left.maxSI32x4(right);
       case MaxUVecI32x4:
         return left.maxUI32x4(right);
+      case DotSVecI16x8ToVecI32x4:
+        return left.dotSI16x8toI32x4(right);
       case AddVecI64x2:
         return left.addI64x2(right);
       case SubVecI64x2:
diff --git a/src/wasm.h b/src/wasm.h
index ca1114182..77eeea5d3 100644
--- a/src/wasm.h
+++ b/src/wasm.h
@@ -383,6 +383,7 @@ enum BinaryOp {
   MinUVecI32x4,
   MaxSVecI32x4,
   MaxUVecI32x4,
+  DotSVecI16x8ToVecI32x4,
   AddVecI64x2,
   SubVecI64x2,
   AddVecF32x4,
diff --git a/src/wasm/literal.cpp b/src/wasm/literal.cpp
index f4ddf69cc..41d98dea3 100644
--- a/src/wasm/literal.cpp
+++ b/src/wasm/literal.cpp
@@ -1829,6 +1829,17 @@ Literal Literal::maxF64x2(const Literal& other) const {
   return binary<2, &Literal::getLanesF64x2, &Literal::max>(*this, other);
 }
 
+Literal Literal::dotSI16x8toI32x4(const Literal& other) const {
+  LaneArray<8> lhs = getLanesSI16x8();
+  LaneArray<8> rhs = other.getLanesSI16x8();
+  LaneArray<4> result;
+  for (size_t i = 0; i < 4; ++i) {
+    result[i] = Literal(lhs[i * 2].geti32() * rhs[i * 2].geti32() +
+                        lhs[i * 2 + 1].geti32() * rhs[i * 2 + 1].geti32());
+  }
+  return Literal(result);
+}
+
 Literal Literal::bitselectV128(const Literal& left,
                                const Literal& right) const {
   return andV128(left).orV128(notV128().andV128(right));
diff --git a/src/wasm/wasm-binary.cpp b/src/wasm/wasm-binary.cpp
index cb67d1556..8d6721c9c 100644
--- a/src/wasm/wasm-binary.cpp
+++ b/src/wasm/wasm-binary.cpp
@@ -3939,6 +3939,10 @@ bool WasmBinaryBuilder::maybeVisitSIMDBinary(Expression*& out, uint32_t code) {
       curr = allocator.alloc<Binary>();
       curr->op = MaxUVecI32x4;
       break;
+    case BinaryConsts::I32x4DotSVecI16x8:
+      curr = allocator.alloc<Binary>();
+      curr->op = DotSVecI16x8ToVecI32x4;
+      break;
     case BinaryConsts::I64x2Add:
       curr = allocator.alloc<Binary>();
       curr->op = AddVecI64x2;
diff --git a/src/wasm/wasm-stack.cpp b/src/wasm/wasm-stack.cpp
index d4af126b7..c1d4f1222 100644
--- a/src/wasm/wasm-stack.cpp
+++ b/src/wasm/wasm-stack.cpp
@@ -1459,6 +1459,10 @@ void BinaryInstWriter::visitBinary(Binary* curr) {
     case MaxUVecI32x4:
       o << int8_t(BinaryConsts::SIMDPrefix) << U32LEB(BinaryConsts::I32x4MaxU);
       break;
+    case DotSVecI16x8ToVecI32x4:
+      o << int8_t(BinaryConsts::SIMDPrefix)
+        << U32LEB(BinaryConsts::I32x4DotSVecI16x8);
+      break;
     case AddVecI64x2:
       o << int8_t(BinaryConsts::SIMDPrefix) << U32LEB(BinaryConsts::I64x2Add);
       break;
diff --git a/src/wasm/wasm-validator.cpp b/src/wasm/wasm-validator.cpp
index ed54173ed..82cd6d6f0 100644
--- a/src/wasm/wasm-validator.cpp
+++ b/src/wasm/wasm-validator.cpp
@@ -1361,6 +1361,7 @@ void FunctionValidator::visitBinary(Binary* curr) {
     case MinUVecI32x4:
     case MaxSVecI32x4:
     case MaxUVecI32x4:
+    case DotSVecI16x8ToVecI32x4:
     case AddVecI64x2:
     case SubVecI64x2:
     case AddVecF32x4:
diff --git a/test/binaryen.js/kitchen-sink.js b/test/binaryen.js/kitchen-sink.js
index 4c00c223a..9b964581f 100644
--- a/test/binaryen.js/kitchen-sink.js
+++ b/test/binaryen.js/kitchen-sink.js
@@ -347,6 +347,7 @@ function test_core() {
     module.i32x4.min_u(module.v128.const(v128_bytes), module.v128.const(v128_bytes)),
     module.i32x4.max_s(module.v128.const(v128_bytes), module.v128.const(v128_bytes)),
     module.i32x4.max_u(module.v128.const(v128_bytes), module.v128.const(v128_bytes)),
+    module.i32x4.dot_i16x8_s(module.v128.const(v128_bytes), module.v128.const(v128_bytes)),
     module.i64x2.add(module.v128.const(v128_bytes), module.v128.const(v128_bytes)),
     module.i64x2.sub(module.v128.const(v128_bytes), module.v128.const(v128_bytes)),
     module.f32x4.add(module.v128.const(v128_bytes), module.v128.const(v128_bytes)),
diff --git a/test/binaryen.js/kitchen-sink.js.txt b/test/binaryen.js/kitchen-sink.js.txt
index d52413646..148ac7888 100644
--- a/test/binaryen.js/kitchen-sink.js.txt
+++ b/test/binaryen.js/kitchen-sink.js.txt
@@ -1168,6 +1168,12 @@ getExpressionInfo(f64.const)={"id":14,"type":4,"value":9.5}
        )
       )
       (drop
+       (i32x4.dot_i16x8_s
+        (v128.const i32x4 0x04030201 0x08070605 0x0c0b0a09 0x100f0e0d)
+        (v128.const i32x4 0x04030201 0x08070605 0x0c0b0a09 0x100f0e0d)
+       )
+      )
+      (drop
        (i64x2.add
         (v128.const i32x4 0x04030201 0x08070605 0x0c0b0a09 0x100f0e0d)
         (v128.const i32x4 0x04030201 0x08070605 0x0c0b0a09 0x100f0e0d)
@@ -2846,6 +2852,12 @@ getExpressionInfo(f64.const)={"id":14,"type":4,"value":9.5}
        )
       )
       (drop
+       (i32x4.dot_i16x8_s
+        (v128.const i32x4 0x04030201 0x08070605 0x0c0b0a09 0x100f0e0d)
+        (v128.const i32x4 0x04030201 0x08070605 0x0c0b0a09 0x100f0e0d)
+       )
+      )
+      (drop
        (i64x2.add
         (v128.const i32x4 0x04030201 0x08070605 0x0c0b0a09 0x100f0e0d)
         (v128.const i32x4 0x04030201 0x08070605 0x0c0b0a09 0x100f0e0d)
@@ -5207,182 +5219,179 @@ int main() {
     uint8_t t223[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
     expressions[571] = BinaryenConst(the_module, BinaryenLiteralVec128(t223));
   }
-  expressions[572] = BinaryenSIMDExtract(the_module, 0, expressions[571], 1);
   {
     uint8_t t224[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[573] = BinaryenConst(the_module, BinaryenLiteralVec128(t224));
+    expressions[572] = BinaryenConst(the_module, BinaryenLiteralVec128(t224));
   }
-  expressions[574] = BinaryenSIMDExtract(the_module, 1, expressions[573], 1);
+  expressions[573] = BinaryenBinary(the_module, 170, expressions[571], expressions[572]);
   {
     uint8_t t225[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[575] = BinaryenConst(the_module, BinaryenLiteralVec128(t225));
+    expressions[574] = BinaryenConst(the_module, BinaryenLiteralVec128(t225));
   }
-  expressions[576] = BinaryenSIMDExtract(the_module, 2, expressions[575], 1);
+  expressions[575] = BinaryenSIMDExtract(the_module, 0, expressions[574], 1);
   {
     uint8_t t226[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[577] = BinaryenConst(the_module, BinaryenLiteralVec128(t226));
+    expressions[576] = BinaryenConst(the_module, BinaryenLiteralVec128(t226));
   }
-  expressions[578] = BinaryenSIMDExtract(the_module, 3, expressions[577], 1);
+  expressions[577] = BinaryenSIMDExtract(the_module, 1, expressions[576], 1);
   {
     uint8_t t227[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[579] = BinaryenConst(the_module, BinaryenLiteralVec128(t227));
+    expressions[578] = BinaryenConst(the_module, BinaryenLiteralVec128(t227));
   }
-  expressions[580] = BinaryenSIMDExtract(the_module, 4, expressions[579], 1);
+  expressions[579] = BinaryenSIMDExtract(the_module, 2, expressions[578], 1);
   {
     uint8_t t228[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[581] = BinaryenConst(the_module, BinaryenLiteralVec128(t228));
+    expressions[580] = BinaryenConst(the_module, BinaryenLiteralVec128(t228));
   }
-  expressions[582] = BinaryenSIMDExtract(the_module, 5, expressions[581], 1);
+  expressions[581] = BinaryenSIMDExtract(the_module, 3, expressions[580], 1);
   {
     uint8_t t229[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[583] = BinaryenConst(the_module, BinaryenLiteralVec128(t229));
+    expressions[582] = BinaryenConst(the_module, BinaryenLiteralVec128(t229));
   }
-  expressions[584] = BinaryenSIMDExtract(the_module, 6, expressions[583], 1);
+  expressions[583] = BinaryenSIMDExtract(the_module, 4, expressions[582], 1);
   {
     uint8_t t230[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[585] = BinaryenConst(the_module, BinaryenLiteralVec128(t230));
+    expressions[584] = BinaryenConst(the_module, BinaryenLiteralVec128(t230));
   }
-  expressions[586] = BinaryenSIMDExtract(the_module, 7, expressions[585], 1);
+  expressions[585] = BinaryenSIMDExtract(the_module, 5, expressions[584], 1);
   {
     uint8_t t231[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[587] = BinaryenConst(the_module, BinaryenLiteralVec128(t231));
+    expressions[586] = BinaryenConst(the_module, BinaryenLiteralVec128(t231));
   }
-  expressions[588] = BinaryenConst(the_module, BinaryenLiteralInt32(42));
-  expressions[589] = BinaryenSIMDReplace(the_module, 1, expressions[587], 1, expressions[588]);
+  expressions[587] = BinaryenSIMDExtract(the_module, 6, expressions[586], 1);
   {
     uint8_t t232[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[590] = BinaryenConst(the_module, BinaryenLiteralVec128(t232));
+    expressions[588] = BinaryenConst(the_module, BinaryenLiteralVec128(t232));
   }
-  expressions[591] = BinaryenConst(the_module, BinaryenLiteralInt32(42));
-  expressions[592] = BinaryenSIMDReplace(the_module, 0, expressions[590], 1, expressions[591]);
+  expressions[589] = BinaryenSIMDExtract(the_module, 7, expressions[588], 1);
   {
     uint8_t t233[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[593] = BinaryenConst(the_module, BinaryenLiteralVec128(t233));
+    expressions[590] = BinaryenConst(the_module, BinaryenLiteralVec128(t233));
   }
-  expressions[594] = BinaryenConst(the_module, BinaryenLiteralInt32(42));
-  expressions[595] = BinaryenSIMDReplace(the_module, 2, expressions[593], 1, expressions[594]);
+  expressions[591] = BinaryenConst(the_module, BinaryenLiteralInt32(42));
+  expressions[592] = BinaryenSIMDReplace(the_module, 1, expressions[590], 1, expressions[591]);
   {
     uint8_t t234[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[596] = BinaryenConst(the_module, BinaryenLiteralVec128(t234));
+    expressions[593] = BinaryenConst(the_module, BinaryenLiteralVec128(t234));
   }
-  expressions[597] = BinaryenConst(the_module, BinaryenLiteralInt64(184683593770));
-  expressions[598] = BinaryenSIMDReplace(the_module, 3, expressions[596], 1, expressions[597]);
+  expressions[594] = BinaryenConst(the_module, BinaryenLiteralInt32(42));
+  expressions[595] = BinaryenSIMDReplace(the_module, 0, expressions[593], 1, expressions[594]);
   {
     uint8_t t235[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[599] = BinaryenConst(the_module, BinaryenLiteralVec128(t235));
+    expressions[596] = BinaryenConst(the_module, BinaryenLiteralVec128(t235));
   }
-  expressions[600] = BinaryenConst(the_module, BinaryenLiteralFloat32(42));
-  expressions[601] = BinaryenSIMDReplace(the_module, 4, expressions[599], 1, expressions[600]);
+  expressions[597] = BinaryenConst(the_module, BinaryenLiteralInt32(42));
+  expressions[598] = BinaryenSIMDReplace(the_module, 2, expressions[596], 1, expressions[597]);
   {
     uint8_t t236[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[602] = BinaryenConst(the_module, BinaryenLiteralVec128(t236));
+    expressions[599] = BinaryenConst(the_module, BinaryenLiteralVec128(t236));
   }
-  expressions[603] = BinaryenConst(the_module, BinaryenLiteralFloat64(42));
-  expressions[604] = BinaryenSIMDReplace(the_module, 5, expressions[602], 1, expressions[603]);
+  expressions[600] = BinaryenConst(the_module, BinaryenLiteralInt64(184683593770));
+  expressions[601] = BinaryenSIMDReplace(the_module, 3, expressions[599], 1, expressions[600]);
   {
     uint8_t t237[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[605] = BinaryenConst(the_module, BinaryenLiteralVec128(t237));
+    expressions[602] = BinaryenConst(the_module, BinaryenLiteralVec128(t237));
   }
-  expressions[606] = BinaryenConst(the_module, BinaryenLiteralInt32(1));
-  expressions[607] = BinaryenSIMDShift(the_module, 0, expressions[605], expressions[606]);
+  expressions[603] = BinaryenConst(the_module, BinaryenLiteralFloat32(42));
+  expressions[604] = BinaryenSIMDReplace(the_module, 4, expressions[602], 1, expressions[603]);
   {
     uint8_t t238[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[608] = BinaryenConst(the_module, BinaryenLiteralVec128(t238));
+    expressions[605] = BinaryenConst(the_module, BinaryenLiteralVec128(t238));
   }
-  expressions[609] = BinaryenConst(the_module, BinaryenLiteralInt32(1));
-  expressions[610] = BinaryenSIMDShift(the_module, 1, expressions[608], expressions[609]);
+  expressions[606] = BinaryenConst(the_module, BinaryenLiteralFloat64(42));
+  expressions[607] = BinaryenSIMDReplace(the_module, 5, expressions[605], 1, expressions[606]);
   {
     uint8_t t239[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[611] = BinaryenConst(the_module, BinaryenLiteralVec128(t239));
+    expressions[608] = BinaryenConst(the_module, BinaryenLiteralVec128(t239));
   }
-  expressions[612] = BinaryenConst(the_module, BinaryenLiteralInt32(1));
-  expressions[613] = BinaryenSIMDShift(the_module, 2, expressions[611], expressions[612]);
+  expressions[609] = BinaryenConst(the_module, BinaryenLiteralInt32(1));
+  expressions[610] = BinaryenSIMDShift(the_module, 0, expressions[608], expressions[609]);
   {
     uint8_t t240[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[614] = BinaryenConst(the_module, BinaryenLiteralVec128(t240));
+    expressions[611] = BinaryenConst(the_module, BinaryenLiteralVec128(t240));
   }
-  expressions[615] = BinaryenConst(the_module, BinaryenLiteralInt32(1));
-  expressions[616] = BinaryenSIMDShift(the_module, 3, expressions[614], expressions[615]);
+  expressions[612] = BinaryenConst(the_module, BinaryenLiteralInt32(1));
+  expressions[613] = BinaryenSIMDShift(the_module, 1, expressions[611], expressions[612]);
   {
     uint8_t t241[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[617] = BinaryenConst(the_module, BinaryenLiteralVec128(t241));
+    expressions[614] = BinaryenConst(the_module, BinaryenLiteralVec128(t241));
   }
-  expressions[618] = BinaryenConst(the_module, BinaryenLiteralInt32(1));
-  expressions[619] = BinaryenSIMDShift(the_module, 4, expressions[617], expressions[618]);
+  expressions[615] = BinaryenConst(the_module, BinaryenLiteralInt32(1));
+  expressions[616] = BinaryenSIMDShift(the_module, 2, expressions[614], expressions[615]);
   {
     uint8_t t242[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[620] = BinaryenConst(the_module, BinaryenLiteralVec128(t242));
+    expressions[617] = BinaryenConst(the_module, BinaryenLiteralVec128(t242));
   }
-  expressions[621] = BinaryenConst(the_module, BinaryenLiteralInt32(1));
-  expressions[622] = BinaryenSIMDShift(the_module, 5, expressions[620], expressions[621]);
+  expressions[618] = BinaryenConst(the_module, BinaryenLiteralInt32(1));
+  expressions[619] = BinaryenSIMDShift(the_module, 3, expressions[617], expressions[618]);
   {
     uint8_t t243[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[623] = BinaryenConst(the_module, BinaryenLiteralVec128(t243));
+    expressions[620] = BinaryenConst(the_module, BinaryenLiteralVec128(t243));
   }
-  expressions[624] = BinaryenConst(the_module, BinaryenLiteralInt32(1));
-  expressions[625] = BinaryenSIMDShift(the_module, 6, expressions[623], expressions[624]);
+  expressions[621] = BinaryenConst(the_module, BinaryenLiteralInt32(1));
+  expressions[622] = BinaryenSIMDShift(the_module, 4, expressions[620], expressions[621]);
   {
     uint8_t t244[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[626] = BinaryenConst(the_module, BinaryenLiteralVec128(t244));
+    expressions[623] = BinaryenConst(the_module, BinaryenLiteralVec128(t244));
   }
-  expressions[627] = BinaryenConst(the_module, BinaryenLiteralInt32(1));
-  expressions[628] = BinaryenSIMDShift(the_module, 7, expressions[626], expressions[627]);
+  expressions[624] = BinaryenConst(the_module, BinaryenLiteralInt32(1));
+  expressions[625] = BinaryenSIMDShift(the_module, 5, expressions[623], expressions[624]);
   {
     uint8_t t245[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[629] = BinaryenConst(the_module, BinaryenLiteralVec128(t245));
+    expressions[626] = BinaryenConst(the_module, BinaryenLiteralVec128(t245));
   }
-  expressions[630] = BinaryenConst(the_module, BinaryenLiteralInt32(1));
-  expressions[631] = BinaryenSIMDShift(the_module, 8, expressions[629], expressions[630]);
+  expressions[627] = BinaryenConst(the_module, BinaryenLiteralInt32(1));
+  expressions[628] = BinaryenSIMDShift(the_module, 6, expressions[626], expressions[627]);
   {
     uint8_t t246[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[632] = BinaryenConst(the_module, BinaryenLiteralVec128(t246));
+    expressions[629] = BinaryenConst(the_module, BinaryenLiteralVec128(t246));
   }
-  expressions[633] = BinaryenConst(the_module, BinaryenLiteralInt32(1));
-  expressions[634] = BinaryenSIMDShift(the_module, 9, expressions[632], expressions[633]);
+  expressions[630] = BinaryenConst(the_module, BinaryenLiteralInt32(1));
+  expressions[631] = BinaryenSIMDShift(the_module, 7, expressions[629], expressions[630]);
   {
     uint8_t t247[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[635] = BinaryenConst(the_module, BinaryenLiteralVec128(t247));
+    expressions[632] = BinaryenConst(the_module, BinaryenLiteralVec128(t247));
   }
-  expressions[636] = BinaryenConst(the_module, BinaryenLiteralInt32(1));
-  expressions[637] = BinaryenSIMDShift(the_module, 10, expressions[635], expressions[636]);
+  expressions[633] = BinaryenConst(the_module, BinaryenLiteralInt32(1));
+  expressions[634] = BinaryenSIMDShift(the_module, 8, expressions[632], expressions[633]);
   {
     uint8_t t248[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[638] = BinaryenConst(the_module, BinaryenLiteralVec128(t248));
+    expressions[635] = BinaryenConst(the_module, BinaryenLiteralVec128(t248));
   }
-  expressions[639] = BinaryenConst(the_module, BinaryenLiteralInt32(1));
-  expressions[640] = BinaryenSIMDShift(the_module, 11, expressions[638], expressions[639]);
-  expressions[641] = BinaryenConst(the_module, BinaryenLiteralInt32(128));
-  expressions[642] = BinaryenSIMDLoad(the_module, 0, 0, 1, expressions[641]);
-  expressions[643] = BinaryenConst(the_module, BinaryenLiteralInt32(128));
-  expressions[644] = BinaryenSIMDLoad(the_module, 1, 16, 1, expressions[643]);
-  expressions[645] = BinaryenConst(the_module, BinaryenLiteralInt32(128));
-  expressions[646] = BinaryenSIMDLoad(the_module, 2, 16, 4, expressions[645]);
-  expressions[647] = BinaryenConst(the_module, BinaryenLiteralInt32(128));
-  expressions[648] = BinaryenSIMDLoad(the_module, 3, 0, 4, expressions[647]);
-  expressions[649] = BinaryenConst(the_module, BinaryenLiteralInt32(128));
-  expressions[650] = BinaryenSIMDLoad(the_module, 4, 0, 8, expressions[649]);
-  expressions[651] = BinaryenConst(the_module, BinaryenLiteralInt32(128));
-  expressions[652] = BinaryenSIMDLoad(the_module, 5, 0, 8, expressions[651]);
-  expressions[653] = BinaryenConst(the_module, BinaryenLiteralInt32(128));
-  expressions[654] = BinaryenSIMDLoad(the_module, 6, 0, 8, expressions[653]);
-  expressions[655] = BinaryenConst(the_module, BinaryenLiteralInt32(128));
-  expressions[656] = BinaryenSIMDLoad(the_module, 7, 0, 8, expressions[655]);
-  expressions[657] = BinaryenConst(the_module, BinaryenLiteralInt32(128));
-  expressions[658] = BinaryenSIMDLoad(the_module, 8, 0, 8, expressions[657]);
-  expressions[659] = BinaryenConst(the_module, BinaryenLiteralInt32(128));
-  expressions[660] = BinaryenSIMDLoad(the_module, 9, 0, 8, expressions[659]);
+  expressions[636] = BinaryenConst(the_module, BinaryenLiteralInt32(1));
+  expressions[637] = BinaryenSIMDShift(the_module, 9, expressions[635], expressions[636]);
   {
     uint8_t t249[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[661] = BinaryenConst(the_module, BinaryenLiteralVec128(t249));
+    expressions[638] = BinaryenConst(the_module, BinaryenLiteralVec128(t249));
   }
+  expressions[639] = BinaryenConst(the_module, BinaryenLiteralInt32(1));
+  expressions[640] = BinaryenSIMDShift(the_module, 10, expressions[638], expressions[639]);
   {
     uint8_t t250[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[662] = BinaryenConst(the_module, BinaryenLiteralVec128(t250));
-  }
-  {
-    uint8_t mask[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[663] = BinaryenSIMDShuffle(the_module, expressions[661], expressions[662], mask);
-  }
+    expressions[641] = BinaryenConst(the_module, BinaryenLiteralVec128(t250));
+  }
+  expressions[642] = BinaryenConst(the_module, BinaryenLiteralInt32(1));
+  expressions[643] = BinaryenSIMDShift(the_module, 11, expressions[641], expressions[642]);
+  expressions[644] = BinaryenConst(the_module, BinaryenLiteralInt32(128));
+  expressions[645] = BinaryenSIMDLoad(the_module, 0, 0, 1, expressions[644]);
+  expressions[646] = BinaryenConst(the_module, BinaryenLiteralInt32(128));
+  expressions[647] = BinaryenSIMDLoad(the_module, 1, 16, 1, expressions[646]);
+  expressions[648] = BinaryenConst(the_module, BinaryenLiteralInt32(128));
+  expressions[649] = BinaryenSIMDLoad(the_module, 2, 16, 4, expressions[648]);
+  expressions[650] = BinaryenConst(the_module, BinaryenLiteralInt32(128));
+  expressions[651] = BinaryenSIMDLoad(the_module, 3, 0, 4, expressions[650]);
+  expressions[652] = BinaryenConst(the_module, BinaryenLiteralInt32(128));
+  expressions[653] = BinaryenSIMDLoad(the_module, 4, 0, 8, expressions[652]);
+  expressions[654] = BinaryenConst(the_module, BinaryenLiteralInt32(128));
+  expressions[655] = BinaryenSIMDLoad(the_module, 5, 0, 8, expressions[654]);
+  expressions[656] = BinaryenConst(the_module, BinaryenLiteralInt32(128));
+  expressions[657] = BinaryenSIMDLoad(the_module, 6, 0, 8, expressions[656]);
+  expressions[658] = BinaryenConst(the_module, BinaryenLiteralInt32(128));
+  expressions[659] = BinaryenSIMDLoad(the_module, 7, 0, 8, expressions[658]);
+  expressions[660] = BinaryenConst(the_module, BinaryenLiteralInt32(128));
+  expressions[661] = BinaryenSIMDLoad(the_module, 8, 0, 8, expressions[660]);
+  expressions[662] = BinaryenConst(the_module, BinaryenLiteralInt32(128));
+  expressions[663] = BinaryenSIMDLoad(the_module, 9, 0, 8, expressions[662]);
   {
     uint8_t t251[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
     expressions[664] = BinaryenConst(the_module, BinaryenLiteralVec128(t251));
@@ -5392,10 +5401,13 @@ int main() {
     expressions[665] = BinaryenConst(the_module, BinaryenLiteralVec128(t252));
   }
   {
+    uint8_t mask[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
+    expressions[666] = BinaryenSIMDShuffle(the_module, expressions[664], expressions[665], mask);
+  }
+  {
     uint8_t t253[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[666] = BinaryenConst(the_module, BinaryenLiteralVec128(t253));
+    expressions[667] = BinaryenConst(the_module, BinaryenLiteralVec128(t253));
   }
-  expressions[667] = BinaryenSIMDTernary(the_module, 0, expressions[664], expressions[665], expressions[666]);
   {
     uint8_t t254[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
     expressions[668] = BinaryenConst(the_module, BinaryenLiteralVec128(t254));
@@ -5404,11 +5416,11 @@ int main() {
     uint8_t t255[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
     expressions[669] = BinaryenConst(the_module, BinaryenLiteralVec128(t255));
   }
+  expressions[670] = BinaryenSIMDTernary(the_module, 0, expressions[667], expressions[668], expressions[669]);
   {
     uint8_t t256[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[670] = BinaryenConst(the_module, BinaryenLiteralVec128(t256));
+    expressions[671] = BinaryenConst(the_module, BinaryenLiteralVec128(t256));
   }
-  expressions[671] = BinaryenSIMDTernary(the_module, 1, expressions[668], expressions[669], expressions[670]);
   {
     uint8_t t257[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
     expressions[672] = BinaryenConst(the_module, BinaryenLiteralVec128(t257));
@@ -5417,11 +5429,11 @@ int main() {
     uint8_t t258[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
     expressions[673] = BinaryenConst(the_module, BinaryenLiteralVec128(t258));
   }
+  expressions[674] = BinaryenSIMDTernary(the_module, 1, expressions[671], expressions[672], expressions[673]);
   {
     uint8_t t259[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[674] = BinaryenConst(the_module, BinaryenLiteralVec128(t259));
+    expressions[675] = BinaryenConst(the_module, BinaryenLiteralVec128(t259));
   }
-  expressions[675] = BinaryenSIMDTernary(the_module, 2, expressions[672], expressions[673], expressions[674]);
   {
     uint8_t t260[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
     expressions[676] = BinaryenConst(the_module, BinaryenLiteralVec128(t260));
@@ -5430,11 +5442,11 @@ int main() {
     uint8_t t261[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
     expressions[677] = BinaryenConst(the_module, BinaryenLiteralVec128(t261));
   }
+  expressions[678] = BinaryenSIMDTernary(the_module, 2, expressions[675], expressions[676], expressions[677]);
   {
     uint8_t t262[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[678] = BinaryenConst(the_module, BinaryenLiteralVec128(t262));
+    expressions[679] = BinaryenConst(the_module, BinaryenLiteralVec128(t262));
   }
-  expressions[679] = BinaryenSIMDTernary(the_module, 3, expressions[676], expressions[677], expressions[678]);
   {
     uint8_t t263[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
     expressions[680] = BinaryenConst(the_module, BinaryenLiteralVec128(t263));
@@ -5443,163 +5455,172 @@ int main() {
     uint8_t t264[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
     expressions[681] = BinaryenConst(the_module, BinaryenLiteralVec128(t264));
   }
+  expressions[682] = BinaryenSIMDTernary(the_module, 3, expressions[679], expressions[680], expressions[681]);
   {
     uint8_t t265[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[682] = BinaryenConst(the_module, BinaryenLiteralVec128(t265));
-  }
-  expressions[683] = BinaryenSIMDTernary(the_module, 4, expressions[680], expressions[681], expressions[682]);
-  expressions[684] = BinaryenConst(the_module, BinaryenLiteralInt32(1024));
-  expressions[685] = BinaryenConst(the_module, BinaryenLiteralInt32(0));
-  expressions[686] = BinaryenConst(the_module, BinaryenLiteralInt32(12));
-  expressions[687] = BinaryenMemoryInit(the_module, 0, expressions[684], expressions[685], expressions[686]);
-  expressions[688] = BinaryenDataDrop(the_module, 0);
-  expressions[689] = BinaryenConst(the_module, BinaryenLiteralInt32(2048));
-  expressions[690] = BinaryenConst(the_module, BinaryenLiteralInt32(1024));
-  expressions[691] = BinaryenConst(the_module, BinaryenLiteralInt32(12));
-  expressions[692] = BinaryenMemoryCopy(the_module, expressions[689], expressions[690], expressions[691]);
-  expressions[693] = BinaryenConst(the_module, BinaryenLiteralInt32(0));
-  expressions[694] = BinaryenConst(the_module, BinaryenLiteralInt32(42));
-  expressions[695] = BinaryenConst(the_module, BinaryenLiteralInt32(1024));
-  expressions[696] = BinaryenMemoryFill(the_module, expressions[693], expressions[694], expressions[695]);
+    expressions[683] = BinaryenConst(the_module, BinaryenLiteralVec128(t265));
+  }
+  {
+    uint8_t t266[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
+    expressions[684] = BinaryenConst(the_module, BinaryenLiteralVec128(t266));
+  }
+  {
+    uint8_t t267[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
+    expressions[685] = BinaryenConst(the_module, BinaryenLiteralVec128(t267));
+  }
+  expressions[686] = BinaryenSIMDTernary(the_module, 4, expressions[683], expressions[684], expressions[685]);
+  expressions[687] = BinaryenConst(the_module, BinaryenLiteralInt32(1024));
+  expressions[688] = BinaryenConst(the_module, BinaryenLiteralInt32(0));
+  expressions[689] = BinaryenConst(the_module, BinaryenLiteralInt32(12));
+  expressions[690] = BinaryenMemoryInit(the_module, 0, expressions[687], expressions[688], expressions[689]);
+  expressions[691] = BinaryenDataDrop(the_module, 0);
+  expressions[692] = BinaryenConst(the_module, BinaryenLiteralInt32(2048));
+  expressions[693] = BinaryenConst(the_module, BinaryenLiteralInt32(1024));
+  expressions[694] = BinaryenConst(the_module, BinaryenLiteralInt32(12));
+  expressions[695] = BinaryenMemoryCopy(the_module, expressions[692], expressions[693], expressions[694]);
+  expressions[696] = BinaryenConst(the_module, BinaryenLiteralInt32(0));
+  expressions[697] = BinaryenConst(the_module, BinaryenLiteralInt32(42));
+  expressions[698] = BinaryenConst(the_module, BinaryenLiteralInt32(1024));
+  expressions[699] = BinaryenMemoryFill(the_module, expressions[696], expressions[697], expressions[698]);
   {
     BinaryenExpressionRef children[] = { 0 };
-    expressions[697] = BinaryenBlock(the_module, NULL, children, 0, 0);
-  }
-  expressions[698] = BinaryenIf(the_module, expressions[7], expressions[8], expressions[9]);
-  expressions[699] = BinaryenIf(the_module, expressions[10], expressions[11], expressions[0]);
-  expressions[700] = BinaryenConst(the_module, BinaryenLiteralInt32(0));
-  expressions[701] = BinaryenLoop(the_module, "in", expressions[700]);
-  expressions[702] = BinaryenConst(the_module, BinaryenLiteralInt32(0));
-  expressions[703] = BinaryenLoop(the_module, NULL, expressions[702]);
-  expressions[704] = BinaryenBreak(the_module, "the-value", expressions[12], expressions[13]);
-  expressions[705] = BinaryenConst(the_module, BinaryenLiteralInt32(2));
-  expressions[706] = BinaryenBreak(the_module, "the-nothing", expressions[705], expressions[0]);
-  expressions[707] = BinaryenConst(the_module, BinaryenLiteralInt32(3));
-  expressions[708] = BinaryenBreak(the_module, "the-value", expressions[0], expressions[707]);
-  expressions[709] = BinaryenBreak(the_module, "the-nothing", expressions[0], expressions[0]);
+    expressions[700] = BinaryenBlock(the_module, NULL, children, 0, 0);
+  }
+  expressions[701] = BinaryenIf(the_module, expressions[7], expressions[8], expressions[9]);
+  expressions[702] = BinaryenIf(the_module, expressions[10], expressions[11], expressions[0]);
+  expressions[703] = BinaryenConst(the_module, BinaryenLiteralInt32(0));
+  expressions[704] = BinaryenLoop(the_module, "in", expressions[703]);
+  expressions[705] = BinaryenConst(the_module, BinaryenLiteralInt32(0));
+  expressions[706] = BinaryenLoop(the_module, NULL, expressions[705]);
+  expressions[707] = BinaryenBreak(the_module, "the-value", expressions[12], expressions[13]);
+  expressions[708] = BinaryenConst(the_module, BinaryenLiteralInt32(2));
+  expressions[709] = BinaryenBreak(the_module, "the-nothing", expressions[708], expressions[0]);
+  expressions[710] = BinaryenConst(the_module, BinaryenLiteralInt32(3));
+  expressions[711] = BinaryenBreak(the_module, "the-value", expressions[0], expressions[710]);
+  expressions[712] = BinaryenBreak(the_module, "the-nothing", expressions[0], expressions[0]);
   {
     const char* names[] = { "the-value" };
-    expressions[710] = BinaryenSwitch(the_module, names, 1, "the-value", expressions[14], expressions[15]);
+    expressions[713] = BinaryenSwitch(the_module, names, 1, "the-value", expressions[14], expressions[15]);
   }
-  expressions[711] = BinaryenConst(the_module, BinaryenLiteralInt32(2));
+  expressions[714] = BinaryenConst(the_module, BinaryenLiteralInt32(2));
   {
     const char* names[] = { "the-nothing" };
-    expressions[712] = BinaryenSwitch(the_module, names, 1, "the-nothing", expressions[711], expressions[0]);
-  }
-  expressions[713] = BinaryenConst(the_module, BinaryenLiteralInt32(13));
-  expressions[714] = BinaryenConst(the_module, BinaryenLiteralInt64(37));
-  expressions[715] = BinaryenConst(the_module, BinaryenLiteralFloat32(1.3));
-  expressions[716] = BinaryenConst(the_module, BinaryenLiteralFloat64(3.7));
-  {
-    BinaryenExpressionRef operands[] = { expressions[713], expressions[714], expressions[715], expressions[716] };
-    expressions[717] = BinaryenCall(the_module, "kitchen()sinker", operands, 4, 1);
-  }
-  expressions[718] = BinaryenUnary(the_module, 20, expressions[717]);
-  expressions[719] = BinaryenConst(the_module, BinaryenLiteralInt32(13));
-  expressions[720] = BinaryenConst(the_module, BinaryenLiteralFloat64(3.7));
-  {
-    BinaryenExpressionRef operands[] = { expressions[719], expressions[720] };
-    expressions[721] = BinaryenCall(the_module, "an-imported", operands, 2, 3);
-  }
-  expressions[722] = BinaryenUnary(the_module, 25, expressions[721]);
-  expressions[723] = BinaryenUnary(the_module, 20, expressions[722]);
-  expressions[724] = BinaryenConst(the_module, BinaryenLiteralInt32(2449));
-  expressions[725] = BinaryenConst(the_module, BinaryenLiteralInt32(13));
-  expressions[726] = BinaryenConst(the_module, BinaryenLiteralInt64(37));
-  expressions[727] = BinaryenConst(the_module, BinaryenLiteralFloat32(1.3));
-  expressions[728] = BinaryenConst(the_module, BinaryenLiteralFloat64(3.7));
-  {
-    BinaryenExpressionRef operands[] = { expressions[725], expressions[726], expressions[727], expressions[728] };
-    expressions[729] = BinaryenCallIndirect(the_module, expressions[724], operands, 4, "iiIfF");
-  }
-  expressions[730] = BinaryenUnary(the_module, 20, expressions[729]);
-  expressions[731] = BinaryenLocalGet(the_module, 0, 1);
-  expressions[732] = BinaryenDrop(the_module, expressions[731]);
-  expressions[733] = BinaryenConst(the_module, BinaryenLiteralInt32(101));
-  expressions[734] = BinaryenLocalSet(the_module, 0, expressions[733]);
-  expressions[735] = BinaryenConst(the_module, BinaryenLiteralInt32(102));
-  expressions[736] = BinaryenLocalTee(the_module, 0, expressions[735]);
-  expressions[737] = BinaryenDrop(the_module, expressions[736]);
-  expressions[738] = BinaryenConst(the_module, BinaryenLiteralInt32(1));
-  expressions[739] = BinaryenLoad(the_module, 4, 1, 0, 0, 1, expressions[738]);
-  expressions[740] = BinaryenConst(the_module, BinaryenLiteralInt32(8));
-  expressions[741] = BinaryenLoad(the_module, 2, 1, 2, 1, 2, expressions[740]);
-  expressions[742] = BinaryenConst(the_module, BinaryenLiteralInt32(2));
-  expressions[743] = BinaryenLoad(the_module, 4, 1, 0, 0, 3, expressions[742]);
-  expressions[744] = BinaryenConst(the_module, BinaryenLiteralInt32(9));
-  expressions[745] = BinaryenLoad(the_module, 8, 1, 2, 8, 4, expressions[744]);
-  expressions[746] = BinaryenStore(the_module, 4, 0, 0, expressions[19], expressions[20], 1);
-  expressions[747] = BinaryenStore(the_module, 8, 2, 4, expressions[21], expressions[22], 2);
-  expressions[748] = BinaryenSelect(the_module, expressions[16], expressions[17], expressions[18]);
-  expressions[749] = BinaryenConst(the_module, BinaryenLiteralInt32(1337));
-  expressions[750] = BinaryenReturn(the_module, expressions[749]);
-  expressions[751] = BinaryenConst(the_module, BinaryenLiteralInt32(13));
-  expressions[752] = BinaryenConst(the_module, BinaryenLiteralInt64(37));
-  expressions[753] = BinaryenConst(the_module, BinaryenLiteralFloat32(1.3));
-  expressions[754] = BinaryenConst(the_module, BinaryenLiteralFloat64(3.7));
-  {
-    BinaryenExpressionRef operands[] = { expressions[751], expressions[752], expressions[753], expressions[754] };
-    expressions[755] = BinaryenReturnCall(the_module, "kitchen()sinker", operands, 4, 1);
-  }
-  expressions[756] = BinaryenConst(the_module, BinaryenLiteralInt32(2449));
-  expressions[757] = BinaryenConst(the_module, BinaryenLiteralInt32(13));
-  expressions[758] = BinaryenConst(the_module, BinaryenLiteralInt64(37));
-  expressions[759] = BinaryenConst(the_module, BinaryenLiteralFloat32(1.3));
-  expressions[760] = BinaryenConst(the_module, BinaryenLiteralFloat64(3.7));
-  {
-    BinaryenExpressionRef operands[] = { expressions[757], expressions[758], expressions[759], expressions[760] };
-    expressions[761] = BinaryenReturnCallIndirect(the_module, expressions[756], operands, 4, "iiIfF");
-  }
-  expressions[762] = BinaryenConst(the_module, BinaryenLiteralInt32(0));
-  {
-    BinaryenExpressionRef operands[] = { expressions[762] };
-    expressions[763] = BinaryenThrow(the_module, "a-event", operands, 1);
-  }
-  expressions[764] = BinaryenPop(the_module, 7);
-  expressions[765] = BinaryenLocalSet(the_module, 5, expressions[764]);
-  expressions[766] = BinaryenLocalGet(the_module, 5, 7);
-  expressions[767] = BinaryenBrOnExn(the_module, "try-block", "a-event", expressions[766]);
-  expressions[768] = BinaryenRethrow(the_module, expressions[767]);
-  {
-    BinaryenExpressionRef children[] = { expressions[768] };
-    expressions[769] = BinaryenBlock(the_module, "try-block", children, 1, 1);
-  }
-  expressions[770] = BinaryenDrop(the_module, expressions[769]);
-  {
-    BinaryenExpressionRef children[] = { expressions[765], expressions[770] };
-    expressions[771] = BinaryenBlock(the_module, NULL, children, 2, 0);
-  }
-  expressions[772] = BinaryenTry(the_module, expressions[763], expressions[771]);
-  expressions[773] = BinaryenConst(the_module, BinaryenLiteralInt32(0));
-  expressions[774] = BinaryenConst(the_module, BinaryenLiteralInt32(0));
-  expressions[775] = BinaryenAtomicLoad(the_module, 4, 0, 1, expressions[774]);
-  expressions[776] = BinaryenAtomicStore(the_module, 4, 0, expressions[773], expressions[775], 1);
+    expressions[715] = BinaryenSwitch(the_module, names, 1, "the-nothing", expressions[714], expressions[0]);
+  }
+  expressions[716] = BinaryenConst(the_module, BinaryenLiteralInt32(13));
+  expressions[717] = BinaryenConst(the_module, BinaryenLiteralInt64(37));
+  expressions[718] = BinaryenConst(the_module, BinaryenLiteralFloat32(1.3));
+  expressions[719] = BinaryenConst(the_module, BinaryenLiteralFloat64(3.7));
+  {
+    BinaryenExpressionRef operands[] = { expressions[716], expressions[717], expressions[718], expressions[719] };
+    expressions[720] = BinaryenCall(the_module, "kitchen()sinker", operands, 4, 1);
+  }
+  expressions[721] = BinaryenUnary(the_module, 20, expressions[720]);
+  expressions[722] = BinaryenConst(the_module, BinaryenLiteralInt32(13));
+  expressions[723] = BinaryenConst(the_module, BinaryenLiteralFloat64(3.7));
+  {
+    BinaryenExpressionRef operands[] = { expressions[722], expressions[723] };
+    expressions[724] = BinaryenCall(the_module, "an-imported", operands, 2, 3);
+  }
+  expressions[725] = BinaryenUnary(the_module, 25, expressions[724]);
+  expressions[726] = BinaryenUnary(the_module, 20, expressions[725]);
+  expressions[727] = BinaryenConst(the_module, BinaryenLiteralInt32(2449));
+  expressions[728] = BinaryenConst(the_module, BinaryenLiteralInt32(13));
+  expressions[729] = BinaryenConst(the_module, BinaryenLiteralInt64(37));
+  expressions[730] = BinaryenConst(the_module, BinaryenLiteralFloat32(1.3));
+  expressions[731] = BinaryenConst(the_module, BinaryenLiteralFloat64(3.7));
+  {
+    BinaryenExpressionRef operands[] = { expressions[728], expressions[729], expressions[730], expressions[731] };
+    expressions[732] = BinaryenCallIndirect(the_module, expressions[727], operands, 4, "iiIfF");
+  }
+  expressions[733] = BinaryenUnary(the_module, 20, expressions[732]);
+  expressions[734] = BinaryenLocalGet(the_module, 0, 1);
+  expressions[735] = BinaryenDrop(the_module, expressions[734]);
+  expressions[736] = BinaryenConst(the_module, BinaryenLiteralInt32(101));
+  expressions[737] = BinaryenLocalSet(the_module, 0, expressions[736]);
+  expressions[738] = BinaryenConst(the_module, BinaryenLiteralInt32(102));
+  expressions[739] = BinaryenLocalTee(the_module, 0, expressions[738]);
+  expressions[740] = BinaryenDrop(the_module, expressions[739]);
+  expressions[741] = BinaryenConst(the_module, BinaryenLiteralInt32(1));
+  expressions[742] = BinaryenLoad(the_module, 4, 1, 0, 0, 1, expressions[741]);
+  expressions[743] = BinaryenConst(the_module, BinaryenLiteralInt32(8));
+  expressions[744] = BinaryenLoad(the_module, 2, 1, 2, 1, 2, expressions[743]);
+  expressions[745] = BinaryenConst(the_module, BinaryenLiteralInt32(2));
+  expressions[746] = BinaryenLoad(the_module, 4, 1, 0, 0, 3, expressions[745]);
+  expressions[747] = BinaryenConst(the_module, BinaryenLiteralInt32(9));
+  expressions[748] = BinaryenLoad(the_module, 8, 1, 2, 8, 4, expressions[747]);
+  expressions[749] = BinaryenStore(the_module, 4, 0, 0, expressions[19], expressions[20], 1);
+  expressions[750] = BinaryenStore(the_module, 8, 2, 4, expressions[21], expressions[22], 2);
+  expressions[751] = BinaryenSelect(the_module, expressions[16], expressions[17], expressions[18]);
+  expressions[752] = BinaryenConst(the_module, BinaryenLiteralInt32(1337));
+  expressions[753] = BinaryenReturn(the_module, expressions[752]);
+  expressions[754] = BinaryenConst(the_module, BinaryenLiteralInt32(13));
+  expressions[755] = BinaryenConst(the_module, BinaryenLiteralInt64(37));
+  expressions[756] = BinaryenConst(the_module, BinaryenLiteralFloat32(1.3));
+  expressions[757] = BinaryenConst(the_module, BinaryenLiteralFloat64(3.7));
+  {
+    BinaryenExpressionRef operands[] = { expressions[754], expressions[755], expressions[756], expressions[757] };
+    expressions[758] = BinaryenReturnCall(the_module, "kitchen()sinker", operands, 4, 1);
+  }
+  expressions[759] = BinaryenConst(the_module, BinaryenLiteralInt32(2449));
+  expressions[760] = BinaryenConst(the_module, BinaryenLiteralInt32(13));
+  expressions[761] = BinaryenConst(the_module, BinaryenLiteralInt64(37));
+  expressions[762] = BinaryenConst(the_module, BinaryenLiteralFloat32(1.3));
+  expressions[763] = BinaryenConst(the_module, BinaryenLiteralFloat64(3.7));
+  {
+    BinaryenExpressionRef operands[] = { expressions[760], expressions[761], expressions[762], expressions[763] };
+    expressions[764] = BinaryenReturnCallIndirect(the_module, expressions[759], operands, 4, "iiIfF");
+  }
+  expressions[765] = BinaryenConst(the_module, BinaryenLiteralInt32(0));
+  {
+    BinaryenExpressionRef operands[] = { expressions[765] };
+    expressions[766] = BinaryenThrow(the_module, "a-event", operands, 1);
+  }
+  expressions[767] = BinaryenPop(the_module, 7);
+  expressions[768] = BinaryenLocalSet(the_module, 5, expressions[767]);
+  expressions[769] = BinaryenLocalGet(the_module, 5, 7);
+  expressions[770] = BinaryenBrOnExn(the_module, "try-block", "a-event", expressions[769]);
+  expressions[771] = BinaryenRethrow(the_module, expressions[770]);
+  {
+    BinaryenExpressionRef children[] = { expressions[771] };
+    expressions[772] = BinaryenBlock(the_module, "try-block", children, 1, 1);
+  }
+  expressions[773] = BinaryenDrop(the_module, expressions[772]);
+  {
+    BinaryenExpressionRef children[] = { expressions[768], expressions[773] };
+    expressions[774] = BinaryenBlock(the_module, NULL, children, 2, 0);
+  }
+  expressions[775] = BinaryenTry(the_module, expressions[766], expressions[774]);
+  expressions[776] = BinaryenConst(the_module, BinaryenLiteralInt32(0));
   expressions[777] = BinaryenConst(the_module, BinaryenLiteralInt32(0));
-  expressions[778] = BinaryenConst(the_module, BinaryenLiteralInt32(0));
-  expressions[779] = BinaryenConst(the_module, BinaryenLiteralInt64(0));
-  expressions[780] = BinaryenAtomicWait(the_module, expressions[777], expressions[778], expressions[779], 1);
-  expressions[781] = BinaryenDrop(the_module, expressions[780]);
-  expressions[782] = BinaryenConst(the_module, BinaryenLiteralInt32(0));
-  expressions[783] = BinaryenConst(the_module, BinaryenLiteralInt32(0));
-  expressions[784] = BinaryenAtomicNotify(the_module, expressions[782], expressions[783]);
-  expressions[785] = BinaryenDrop(the_module, expressions[784]);
-  expressions[786] = BinaryenAtomicFence(the_module);
-  expressions[787] = BinaryenPop(the_module, 1);
-  expressions[788] = BinaryenPush(the_module, expressions[787]);
-  expressions[789] = BinaryenPop(the_module, 2);
-  expressions[790] = BinaryenPush(the_module, expressions[789]);
-  expressions[791] = BinaryenPop(the_module, 3);
-  expressions[792] = BinaryenPush(the_module, expressions[791]);
-  expressions[793] = BinaryenPop(the_module, 4);
-  expressions[794] = BinaryenPush(the_module, expressions[793]);
-  expressions[795] = BinaryenPop(the_module, 5);
-  expressions[796] = BinaryenPush(the_module, expressions[795]);
-  expressions[797] = BinaryenPop(the_module, 6);
-  expressions[798] = BinaryenPush(the_module, expressions[797]);
-  expressions[799] = BinaryenPop(the_module, 7);
-  expressions[800] = BinaryenPush(the_module, expressions[799]);
-  expressions[801] = BinaryenNop(the_module);
-  expressions[802] = BinaryenUnreachable(the_module);
+  expressions[778] = BinaryenAtomicLoad(the_module, 4, 0, 1, expressions[777]);
+  expressions[779] = BinaryenAtomicStore(the_module, 4, 0, expressions[776], expressions[778], 1);
+  expressions[780] = BinaryenConst(the_module, BinaryenLiteralInt32(0));
+  expressions[781] = BinaryenConst(the_module, BinaryenLiteralInt32(0));
+  expressions[782] = BinaryenConst(the_module, BinaryenLiteralInt64(0));
+  expressions[783] = BinaryenAtomicWait(the_module, expressions[780], expressions[781], expressions[782], 1);
+  expressions[784] = BinaryenDrop(the_module, expressions[783]);
+  expressions[785] = BinaryenConst(the_module, BinaryenLiteralInt32(0));
+  expressions[786] = BinaryenConst(the_module, BinaryenLiteralInt32(0));
+  expressions[787] = BinaryenAtomicNotify(the_module, expressions[785], expressions[786]);
+  expressions[788] = BinaryenDrop(the_module, expressions[787]);
+  expressions[789] = BinaryenAtomicFence(the_module);
+  expressions[790] = BinaryenPop(the_module, 1);
+  expressions[791] = BinaryenPush(the_module, expressions[790]);
+  expressions[792] = BinaryenPop(the_module, 2);
+  expressions[793] = BinaryenPush(the_module, expressions[792]);
+  expressions[794] = BinaryenPop(the_module, 3);
+  expressions[795] = BinaryenPush(the_module, expressions[794]);
+  expressions[796] = BinaryenPop(the_module, 4);
+  expressions[797] = BinaryenPush(the_module, expressions[796]);
+  expressions[798] = BinaryenPop(the_module, 5);
+  expressions[799] = BinaryenPush(the_module, expressions[798]);
+  expressions[800] = BinaryenPop(the_module, 6);
+  expressions[801] = BinaryenPush(the_module, expressions[800]);
+  expressions[802] = BinaryenPop(the_module, 7);
+  expressions[803] = BinaryenPush(the_module, expressions[802]);
+  expressions[804] = BinaryenNop(the_module);
+  expressions[805] = BinaryenUnreachable(the_module);
   BinaryenExpressionGetId(expressions[30]);
   BinaryenExpressionGetType(expressions[30]);
   BinaryenUnaryGetOp(expressions[30]);
@@ -5610,26 +5631,26 @@ getExpressionInfo={"id":15,"type":3,"op":6}
  (f32.const -33.61199951171875)
 )
 
-  expressions[803] = BinaryenConst(the_module, BinaryenLiteralInt32(5));
-  BinaryenExpressionGetId(expressions[803]);
-  BinaryenExpressionGetType(expressions[803]);
-  BinaryenConstGetValueI32(expressions[803]);
+  expressions[806] = BinaryenConst(the_module, BinaryenLiteralInt32(5));
+  BinaryenExpressionGetId(expressions[806]);
+  BinaryenExpressionGetType(expressions[806]);
+  BinaryenConstGetValueI32(expressions[806]);
 getExpressionInfo(i32.const)={"id":14,"type":1,"value":5}
-  expressions[804] = BinaryenConst(the_module, BinaryenLiteralInt64(30064771078));
-  BinaryenExpressionGetId(expressions[804]);
-  BinaryenExpressionGetType(expressions[804]);
-  BinaryenConstGetValueI64Low(expressions[804]);
-  BinaryenConstGetValueI64High(expressions[804]);
+  expressions[807] = BinaryenConst(the_module, BinaryenLiteralInt64(30064771078));
+  BinaryenExpressionGetId(expressions[807]);
+  BinaryenExpressionGetType(expressions[807]);
+  BinaryenConstGetValueI64Low(expressions[807]);
+  BinaryenConstGetValueI64High(expressions[807]);
 getExpressionInfo(i64.const)={"id":14,"type":2,"value":{"low":6,"high":7}}
-  expressions[805] = BinaryenConst(the_module, BinaryenLiteralFloat32(8.5));
-  BinaryenExpressionGetId(expressions[805]);
-  BinaryenExpressionGetType(expressions[805]);
-  BinaryenConstGetValueF32(expressions[805]);
+  expressions[808] = BinaryenConst(the_module, BinaryenLiteralFloat32(8.5));
+  BinaryenExpressionGetId(expressions[808]);
+  BinaryenExpressionGetType(expressions[808]);
+  BinaryenConstGetValueF32(expressions[808]);
 getExpressionInfo(f32.const)={"id":14,"type":3,"value":8.5}
-  expressions[806] = BinaryenConst(the_module, BinaryenLiteralFloat64(9.5));
-  BinaryenExpressionGetId(expressions[806]);
-  BinaryenExpressionGetType(expressions[806]);
-  BinaryenConstGetValueF64(expressions[806]);
+  expressions[809] = BinaryenConst(the_module, BinaryenLiteralFloat64(9.5));
+  BinaryenExpressionGetId(expressions[809]);
+  BinaryenExpressionGetType(expressions[809]);
+  BinaryenConstGetValueF64(expressions[809]);
 getExpressionInfo(f64.const)={"id":14,"type":4,"value":9.5}
   {
     BinaryenExpressionRef children[] = { expressions[24], expressions[26], expressions[28], expressions[30], expressions[32], 
@@ -5667,39 +5688,39 @@ getExpressionInfo(f64.const)={"id":14,"type":4,"value":9.5}
        expressions[513], expressions[516], expressions[519], expressions[522], expressions[525], expressions[528], 
        expressions[531], expressions[534], expressions[537], expressions[540], expressions[543], expressions[546], 
        expressions[549], expressions[552], expressions[555], expressions[558], expressions[561], expressions[564], 
-       expressions[567], expressions[570], expressions[572], expressions[574], expressions[576], expressions[578], 
-       expressions[580], expressions[582], expressions[584], expressions[586], expressions[589], expressions[592], 
+       expressions[567], expressions[570], expressions[573], expressions[575], expressions[577], expressions[579], 
+       expressions[581], expressions[583], expressions[585], expressions[587], expressions[589], expressions[592], 
        expressions[595], expressions[598], expressions[601], expressions[604], expressions[607], expressions[610], 
        expressions[613], expressions[616], expressions[619], expressions[622], expressions[625], expressions[628], 
-       expressions[631], expressions[634], expressions[637], expressions[640], expressions[642], expressions[644], 
-       expressions[646], expressions[648], expressions[650], expressions[652], expressions[654], expressions[656], 
-       expressions[658], expressions[660], expressions[663], expressions[667], expressions[671], expressions[675], 
-       expressions[679], expressions[683], expressions[687], expressions[688], expressions[692], expressions[696], 
-       expressions[697], expressions[698], expressions[699], expressions[701], expressions[703], expressions[704], 
-       expressions[706], expressions[708], expressions[709], expressions[710], expressions[712], expressions[718], 
-       expressions[723], expressions[730], expressions[732], expressions[734], expressions[737], expressions[739], 
-       expressions[741], expressions[743], expressions[745], expressions[746], expressions[747], expressions[748], 
-       expressions[750], expressions[755], expressions[761], expressions[772], expressions[776], expressions[781], 
-       expressions[785], expressions[786], expressions[788], expressions[790], expressions[792], expressions[794], 
-       expressions[796], expressions[798], expressions[800], expressions[801], expressions[802] };
-    expressions[807] = BinaryenBlock(the_module, "the-value", children, 298, 0);
+       expressions[631], expressions[634], expressions[637], expressions[640], expressions[643], expressions[645], 
+       expressions[647], expressions[649], expressions[651], expressions[653], expressions[655], expressions[657], 
+       expressions[659], expressions[661], expressions[663], expressions[666], expressions[670], expressions[674], 
+       expressions[678], expressions[682], expressions[686], expressions[690], expressions[691], expressions[695], 
+       expressions[699], expressions[700], expressions[701], expressions[702], expressions[704], expressions[706], 
+       expressions[707], expressions[709], expressions[711], expressions[712], expressions[713], expressions[715], 
+       expressions[721], expressions[726], expressions[733], expressions[735], expressions[737], expressions[740], 
+       expressions[742], expressions[744], expressions[746], expressions[748], expressions[749], expressions[750], 
+       expressions[751], expressions[753], expressions[758], expressions[764], expressions[775], expressions[779], 
+       expressions[784], expressions[788], expressions[789], expressions[791], expressions[793], expressions[795], 
+       expressions[797], expressions[799], expressions[801], expressions[803], expressions[804], expressions[805] };
+    expressions[810] = BinaryenBlock(the_module, "the-value", children, 299, 0);
   }
-  expressions[808] = BinaryenDrop(the_module, expressions[807]);
+  expressions[811] = BinaryenDrop(the_module, expressions[810]);
   {
-    BinaryenExpressionRef children[] = { expressions[808] };
-    expressions[809] = BinaryenBlock(the_module, "the-nothing", children, 1, 0);
+    BinaryenExpressionRef children[] = { expressions[811] };
+    expressions[812] = BinaryenBlock(the_module, "the-nothing", children, 1, 0);
   }
-  expressions[810] = BinaryenConst(the_module, BinaryenLiteralInt32(42));
+  expressions[813] = BinaryenConst(the_module, BinaryenLiteralInt32(42));
   {
-    BinaryenExpressionRef children[] = { expressions[809], expressions[810] };
-    expressions[811] = BinaryenBlock(the_module, "the-body", children, 2, 0);
+    BinaryenExpressionRef children[] = { expressions[812], expressions[813] };
+    expressions[814] = BinaryenBlock(the_module, "the-body", children, 2, 0);
   }
   {
     BinaryenType varTypes[] = { 1, 7 };
-    functions[0] = BinaryenAddFunction(the_module, "kitchen()sinker", functionTypes[1], varTypes, 2, expressions[811]);
+    functions[0] = BinaryenAddFunction(the_module, "kitchen()sinker", functionTypes[1], varTypes, 2, expressions[814]);
   }
-  expressions[812] = BinaryenConst(the_module, BinaryenLiteralInt32(1));
-  globals[0] = BinaryenAddGlobal(the_module, "a-global", 1, 0, expressions[812]);
+  expressions[815] = BinaryenConst(the_module, BinaryenLiteralInt32(1));
+  globals[0] = BinaryenAddGlobal(the_module, "a-global", 1, 0, expressions[815]);
   {
     BinaryenType paramTypes[] = { 1, 4 };
     functionTypes[2] = BinaryenAddFunctionType(the_module, "fiF", 3, paramTypes, 2);
@@ -5725,18 +5746,18 @@ getExpressionInfo(f64.const)={"id":14,"type":4,"value":9.5}
   BinaryenFunctionGetVar(functions[0], 0);
   BinaryenFunctionGetVar(functions[0], 1);
   BinaryenFunctionGetBody(functions[0]);
-  expressions[813] = BinaryenConst(the_module, BinaryenLiteralInt32(0));
+  expressions[816] = BinaryenConst(the_module, BinaryenLiteralInt32(0));
   {
     const char* funcNames[] = { "kitchen()sinker" };
-    BinaryenSetFunctionTable(the_module, 1, 4294967295, funcNames, 1, expressions[813]);
+    BinaryenSetFunctionTable(the_module, 1, 4294967295, funcNames, 1, expressions[816]);
   }
-  expressions[814] = BinaryenConst(the_module, BinaryenLiteralInt32(10));
+  expressions[817] = BinaryenConst(the_module, BinaryenLiteralInt32(10));
   {
     const char segment0[] = { 104, 101, 108, 108, 111, 44, 32, 119, 111, 114, 108, 100 };
     const char segment1[] = { 73, 32, 97, 109, 32, 112, 97, 115, 115, 105, 118, 101 };
     const char* segments[] = { segment0, segment1 };
     int8_t segmentPassive[] = { 0, 1 };
-    BinaryenExpressionRef segmentOffsets[] = { expressions[814], expressions[0] };
+    BinaryenExpressionRef segmentOffsets[] = { expressions[817], expressions[0] };
     BinaryenIndex segmentSizes[] = { 12, 12 };
     BinaryenSetMemory(the_module, 1, 256, "mem", segments, segmentPassive, segmentOffsets, segmentSizes, 2, 1);
   }
@@ -5744,10 +5765,10 @@ getExpressionInfo(f64.const)={"id":14,"type":4,"value":9.5}
     BinaryenType paramTypes[] = { 0 };
     functionTypes[3] = BinaryenAddFunctionType(the_module, "v", 0, paramTypes, 0);
   }
-  expressions[815] = BinaryenNop(the_module);
+  expressions[818] = BinaryenNop(the_module);
   {
     BinaryenType varTypes[] = { 0 };
-    functions[1] = BinaryenAddFunction(the_module, "starter", functionTypes[3], varTypes, 0, expressions[815]);
+    functions[1] = BinaryenAddFunction(the_module, "starter", functionTypes[3], varTypes, 0, expressions[818]);
   }
   BinaryenSetStart(the_module, functions[1]);
   {
@@ -6855,6 +6876,12 @@ getExpressionInfo(f64.const)={"id":14,"type":4,"value":9.5}
        )
       )
       (drop
+       (i32x4.dot_i16x8_s
+        (v128.const i32x4 0x04030201 0x08070605 0x0c0b0a09 0x100f0e0d)
+        (v128.const i32x4 0x04030201 0x08070605 0x0c0b0a09 0x100f0e0d)
+       )
+      )
+      (drop
        (i64x2.add
         (v128.const i32x4 0x04030201 0x08070605 0x0c0b0a09 0x100f0e0d)
         (v128.const i32x4 0x04030201 0x08070605 0x0c0b0a09 0x100f0e0d)
@@ -8535,6 +8562,12 @@ getExpressionInfo(f64.const)={"id":14,"type":4,"value":9.5}
        )
       )
       (drop
+       (i32x4.dot_i16x8_s
+        (v128.const i32x4 0x04030201 0x08070605 0x0c0b0a09 0x100f0e0d)
+        (v128.const i32x4 0x04030201 0x08070605 0x0c0b0a09 0x100f0e0d)
+       )
+      )
+      (drop
        (i64x2.add
         (v128.const i32x4 0x04030201 0x08070605 0x0c0b0a09 0x100f0e0d)
         (v128.const i32x4 0x04030201 0x08070605 0x0c0b0a09 0x100f0e0d)
diff --git a/test/example/c-api-kitchen-sink.c b/test/example/c-api-kitchen-sink.c
index a4a4c860d..f7bc12b8d 100644
--- a/test/example/c-api-kitchen-sink.c
+++ b/test/example/c-api-kitchen-sink.c
@@ -454,6 +454,7 @@ void test_core() {
     makeBinary(module, BinaryenMinUVecI32x4(), 5),
     makeBinary(module, BinaryenMaxSVecI32x4(), 5),
     makeBinary(module, BinaryenMaxUVecI32x4(), 5),
+    makeBinary(module, BinaryenDotSVecI16x8ToVecI32x4(), 5),
     makeBinary(module, BinaryenDivVecF32x4(), 5),
     makeBinary(module, BinaryenMinVecF32x4(), 5),
     makeBinary(module, BinaryenMaxVecF32x4(), 5),
diff --git a/test/example/c-api-kitchen-sink.txt b/test/example/c-api-kitchen-sink.txt
index c5cfd85ba..6689185ae 100644
--- a/test/example/c-api-kitchen-sink.txt
+++ b/test/example/c-api-kitchen-sink.txt
@@ -1145,6 +1145,12 @@ BinaryenFeatureAll: 511
        )
       )
       (drop
+       (i32x4.dot_i16x8_s
+        (v128.const i32x4 0x04030201 0x08070605 0x0c0b0a09 0x100f0e0d)
+        (v128.const i32x4 0x04030201 0x08070605 0x0c0b0a09 0x100f0e0d)
+       )
+      )
+      (drop
        (f32x4.div
         (v128.const i32x4 0x04030201 0x08070605 0x0c0b0a09 0x100f0e0d)
         (v128.const i32x4 0x04030201 0x08070605 0x0c0b0a09 0x100f0e0d)
@@ -3321,7 +3327,7 @@ int main() {
     uint8_t t179[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
     expressions[524] = BinaryenConst(the_module, BinaryenLiteralVec128(t179));
   }
-  expressions[525] = BinaryenBinary(the_module, 151, expressions[524], expressions[523]);
+  expressions[525] = BinaryenBinary(the_module, 152, expressions[524], expressions[523]);
   {
     uint8_t t180[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
     expressions[526] = BinaryenConst(the_module, BinaryenLiteralVec128(t180));
@@ -3330,7 +3336,7 @@ int main() {
     uint8_t t181[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
     expressions[527] = BinaryenConst(the_module, BinaryenLiteralVec128(t181));
   }
-  expressions[528] = BinaryenBinary(the_module, 152, expressions[527], expressions[526]);
+  expressions[528] = BinaryenBinary(the_module, 153, expressions[527], expressions[526]);
   {
     uint8_t t182[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
     expressions[529] = BinaryenConst(the_module, BinaryenLiteralVec128(t182));
@@ -3339,7 +3345,7 @@ int main() {
     uint8_t t183[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
     expressions[530] = BinaryenConst(the_module, BinaryenLiteralVec128(t183));
   }
-  expressions[531] = BinaryenBinary(the_module, 153, expressions[530], expressions[529]);
+  expressions[531] = BinaryenBinary(the_module, 154, expressions[530], expressions[529]);
   {
     uint8_t t184[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
     expressions[532] = BinaryenConst(the_module, BinaryenLiteralVec128(t184));
@@ -3348,7 +3354,7 @@ int main() {
     uint8_t t185[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
     expressions[533] = BinaryenConst(the_module, BinaryenLiteralVec128(t185));
   }
-  expressions[534] = BinaryenBinary(the_module, 154, expressions[533], expressions[532]);
+  expressions[534] = BinaryenBinary(the_module, 155, expressions[533], expressions[532]);
   {
     uint8_t t186[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
     expressions[535] = BinaryenConst(the_module, BinaryenLiteralVec128(t186));
@@ -3357,7 +3363,7 @@ int main() {
     uint8_t t187[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
     expressions[536] = BinaryenConst(the_module, BinaryenLiteralVec128(t187));
   }
-  expressions[537] = BinaryenBinary(the_module, 155, expressions[536], expressions[535]);
+  expressions[537] = BinaryenBinary(the_module, 156, expressions[536], expressions[535]);
   {
     uint8_t t188[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
     expressions[538] = BinaryenConst(the_module, BinaryenLiteralVec128(t188));
@@ -3402,7 +3408,7 @@ int main() {
     uint8_t t197[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
     expressions[551] = BinaryenConst(the_module, BinaryenLiteralVec128(t197));
   }
-  expressions[552] = BinaryenBinary(the_module, 156, expressions[551], expressions[550]);
+  expressions[552] = BinaryenBinary(the_module, 151, expressions[551], expressions[550]);
   {
     uint8_t t198[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
     expressions[553] = BinaryenConst(the_module, BinaryenLiteralVec128(t198));
@@ -3524,182 +3530,179 @@ int main() {
     uint8_t t224[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
     expressions[592] = BinaryenConst(the_module, BinaryenLiteralVec128(t224));
   }
-  expressions[593] = BinaryenSIMDExtract(the_module, 0, expressions[592], 0);
   {
     uint8_t t225[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[594] = BinaryenConst(the_module, BinaryenLiteralVec128(t225));
+    expressions[593] = BinaryenConst(the_module, BinaryenLiteralVec128(t225));
   }
-  expressions[595] = BinaryenSIMDExtract(the_module, 1, expressions[594], 0);
+  expressions[594] = BinaryenBinary(the_module, 170, expressions[593], expressions[592]);
   {
     uint8_t t226[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[596] = BinaryenConst(the_module, BinaryenLiteralVec128(t226));
+    expressions[595] = BinaryenConst(the_module, BinaryenLiteralVec128(t226));
   }
-  expressions[597] = BinaryenSIMDExtract(the_module, 2, expressions[596], 0);
+  expressions[596] = BinaryenSIMDExtract(the_module, 0, expressions[595], 0);
   {
     uint8_t t227[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[598] = BinaryenConst(the_module, BinaryenLiteralVec128(t227));
+    expressions[597] = BinaryenConst(the_module, BinaryenLiteralVec128(t227));
   }
-  expressions[599] = BinaryenSIMDExtract(the_module, 3, expressions[598], 0);
+  expressions[598] = BinaryenSIMDExtract(the_module, 1, expressions[597], 0);
   {
     uint8_t t228[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[600] = BinaryenConst(the_module, BinaryenLiteralVec128(t228));
+    expressions[599] = BinaryenConst(the_module, BinaryenLiteralVec128(t228));
   }
-  expressions[601] = BinaryenSIMDExtract(the_module, 4, expressions[600], 0);
+  expressions[600] = BinaryenSIMDExtract(the_module, 2, expressions[599], 0);
   {
     uint8_t t229[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[602] = BinaryenConst(the_module, BinaryenLiteralVec128(t229));
+    expressions[601] = BinaryenConst(the_module, BinaryenLiteralVec128(t229));
   }
-  expressions[603] = BinaryenSIMDExtract(the_module, 5, expressions[602], 0);
+  expressions[602] = BinaryenSIMDExtract(the_module, 3, expressions[601], 0);
   {
     uint8_t t230[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[604] = BinaryenConst(the_module, BinaryenLiteralVec128(t230));
+    expressions[603] = BinaryenConst(the_module, BinaryenLiteralVec128(t230));
   }
-  expressions[605] = BinaryenSIMDExtract(the_module, 6, expressions[604], 0);
+  expressions[604] = BinaryenSIMDExtract(the_module, 4, expressions[603], 0);
   {
     uint8_t t231[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[606] = BinaryenConst(the_module, BinaryenLiteralVec128(t231));
+    expressions[605] = BinaryenConst(the_module, BinaryenLiteralVec128(t231));
   }
-  expressions[607] = BinaryenSIMDExtract(the_module, 7, expressions[606], 0);
-  expressions[608] = BinaryenConst(the_module, BinaryenLiteralInt32(42));
+  expressions[606] = BinaryenSIMDExtract(the_module, 5, expressions[605], 0);
   {
     uint8_t t232[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[609] = BinaryenConst(the_module, BinaryenLiteralVec128(t232));
+    expressions[607] = BinaryenConst(the_module, BinaryenLiteralVec128(t232));
   }
-  expressions[610] = BinaryenSIMDReplace(the_module, 0, expressions[609], 0, expressions[608]);
-  expressions[611] = BinaryenConst(the_module, BinaryenLiteralInt32(42));
+  expressions[608] = BinaryenSIMDExtract(the_module, 6, expressions[607], 0);
   {
     uint8_t t233[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[612] = BinaryenConst(the_module, BinaryenLiteralVec128(t233));
+    expressions[609] = BinaryenConst(the_module, BinaryenLiteralVec128(t233));
   }
-  expressions[613] = BinaryenSIMDReplace(the_module, 1, expressions[612], 0, expressions[611]);
-  expressions[614] = BinaryenConst(the_module, BinaryenLiteralInt32(42));
+  expressions[610] = BinaryenSIMDExtract(the_module, 7, expressions[609], 0);
+  expressions[611] = BinaryenConst(the_module, BinaryenLiteralInt32(42));
   {
     uint8_t t234[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[615] = BinaryenConst(the_module, BinaryenLiteralVec128(t234));
+    expressions[612] = BinaryenConst(the_module, BinaryenLiteralVec128(t234));
   }
-  expressions[616] = BinaryenSIMDReplace(the_module, 2, expressions[615], 0, expressions[614]);
-  expressions[617] = BinaryenConst(the_module, BinaryenLiteralInt64(42));
+  expressions[613] = BinaryenSIMDReplace(the_module, 0, expressions[612], 0, expressions[611]);
+  expressions[614] = BinaryenConst(the_module, BinaryenLiteralInt32(42));
   {
     uint8_t t235[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[618] = BinaryenConst(the_module, BinaryenLiteralVec128(t235));
+    expressions[615] = BinaryenConst(the_module, BinaryenLiteralVec128(t235));
   }
-  expressions[619] = BinaryenSIMDReplace(the_module, 3, expressions[618], 0, expressions[617]);
-  expressions[620] = BinaryenConst(the_module, BinaryenLiteralFloat32(42));
+  expressions[616] = BinaryenSIMDReplace(the_module, 1, expressions[615], 0, expressions[614]);
+  expressions[617] = BinaryenConst(the_module, BinaryenLiteralInt32(42));
   {
     uint8_t t236[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[621] = BinaryenConst(the_module, BinaryenLiteralVec128(t236));
+    expressions[618] = BinaryenConst(the_module, BinaryenLiteralVec128(t236));
   }
-  expressions[622] = BinaryenSIMDReplace(the_module, 4, expressions[621], 0, expressions[620]);
-  expressions[623] = BinaryenConst(the_module, BinaryenLiteralFloat64(42));
+  expressions[619] = BinaryenSIMDReplace(the_module, 2, expressions[618], 0, expressions[617]);
+  expressions[620] = BinaryenConst(the_module, BinaryenLiteralInt64(42));
   {
     uint8_t t237[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[624] = BinaryenConst(the_module, BinaryenLiteralVec128(t237));
+    expressions[621] = BinaryenConst(the_module, BinaryenLiteralVec128(t237));
   }
-  expressions[625] = BinaryenSIMDReplace(the_module, 5, expressions[624], 0, expressions[623]);
+  expressions[622] = BinaryenSIMDReplace(the_module, 3, expressions[621], 0, expressions[620]);
+  expressions[623] = BinaryenConst(the_module, BinaryenLiteralFloat32(42));
   {
     uint8_t t238[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[626] = BinaryenConst(the_module, BinaryenLiteralVec128(t238));
+    expressions[624] = BinaryenConst(the_module, BinaryenLiteralVec128(t238));
   }
-  expressions[627] = BinaryenConst(the_module, BinaryenLiteralInt32(1));
-  expressions[628] = BinaryenSIMDShift(the_module, 0, expressions[626], expressions[627]);
+  expressions[625] = BinaryenSIMDReplace(the_module, 4, expressions[624], 0, expressions[623]);
+  expressions[626] = BinaryenConst(the_module, BinaryenLiteralFloat64(42));
   {
     uint8_t t239[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[629] = BinaryenConst(the_module, BinaryenLiteralVec128(t239));
+    expressions[627] = BinaryenConst(the_module, BinaryenLiteralVec128(t239));
   }
-  expressions[630] = BinaryenConst(the_module, BinaryenLiteralInt32(1));
-  expressions[631] = BinaryenSIMDShift(the_module, 1, expressions[629], expressions[630]);
+  expressions[628] = BinaryenSIMDReplace(the_module, 5, expressions[627], 0, expressions[626]);
   {
     uint8_t t240[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[632] = BinaryenConst(the_module, BinaryenLiteralVec128(t240));
+    expressions[629] = BinaryenConst(the_module, BinaryenLiteralVec128(t240));
   }
-  expressions[633] = BinaryenConst(the_module, BinaryenLiteralInt32(1));
-  expressions[634] = BinaryenSIMDShift(the_module, 2, expressions[632], expressions[633]);
+  expressions[630] = BinaryenConst(the_module, BinaryenLiteralInt32(1));
+  expressions[631] = BinaryenSIMDShift(the_module, 0, expressions[629], expressions[630]);
   {
     uint8_t t241[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[635] = BinaryenConst(the_module, BinaryenLiteralVec128(t241));
+    expressions[632] = BinaryenConst(the_module, BinaryenLiteralVec128(t241));
   }
-  expressions[636] = BinaryenConst(the_module, BinaryenLiteralInt32(1));
-  expressions[637] = BinaryenSIMDShift(the_module, 3, expressions[635], expressions[636]);
+  expressions[633] = BinaryenConst(the_module, BinaryenLiteralInt32(1));
+  expressions[634] = BinaryenSIMDShift(the_module, 1, expressions[632], expressions[633]);
   {
     uint8_t t242[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[638] = BinaryenConst(the_module, BinaryenLiteralVec128(t242));
+    expressions[635] = BinaryenConst(the_module, BinaryenLiteralVec128(t242));
   }
-  expressions[639] = BinaryenConst(the_module, BinaryenLiteralInt32(1));
-  expressions[640] = BinaryenSIMDShift(the_module, 4, expressions[638], expressions[639]);
+  expressions[636] = BinaryenConst(the_module, BinaryenLiteralInt32(1));
+  expressions[637] = BinaryenSIMDShift(the_module, 2, expressions[635], expressions[636]);
   {
     uint8_t t243[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[641] = BinaryenConst(the_module, BinaryenLiteralVec128(t243));
+    expressions[638] = BinaryenConst(the_module, BinaryenLiteralVec128(t243));
   }
-  expressions[642] = BinaryenConst(the_module, BinaryenLiteralInt32(1));
-  expressions[643] = BinaryenSIMDShift(the_module, 5, expressions[641], expressions[642]);
+  expressions[639] = BinaryenConst(the_module, BinaryenLiteralInt32(1));
+  expressions[640] = BinaryenSIMDShift(the_module, 3, expressions[638], expressions[639]);
   {
     uint8_t t244[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[644] = BinaryenConst(the_module, BinaryenLiteralVec128(t244));
+    expressions[641] = BinaryenConst(the_module, BinaryenLiteralVec128(t244));
   }
-  expressions[645] = BinaryenConst(the_module, BinaryenLiteralInt32(1));
-  expressions[646] = BinaryenSIMDShift(the_module, 6, expressions[644], expressions[645]);
+  expressions[642] = BinaryenConst(the_module, BinaryenLiteralInt32(1));
+  expressions[643] = BinaryenSIMDShift(the_module, 4, expressions[641], expressions[642]);
   {
     uint8_t t245[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[647] = BinaryenConst(the_module, BinaryenLiteralVec128(t245));
+    expressions[644] = BinaryenConst(the_module, BinaryenLiteralVec128(t245));
   }
-  expressions[648] = BinaryenConst(the_module, BinaryenLiteralInt32(1));
-  expressions[649] = BinaryenSIMDShift(the_module, 7, expressions[647], expressions[648]);
+  expressions[645] = BinaryenConst(the_module, BinaryenLiteralInt32(1));
+  expressions[646] = BinaryenSIMDShift(the_module, 5, expressions[644], expressions[645]);
   {
     uint8_t t246[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[650] = BinaryenConst(the_module, BinaryenLiteralVec128(t246));
+    expressions[647] = BinaryenConst(the_module, BinaryenLiteralVec128(t246));
   }
-  expressions[651] = BinaryenConst(the_module, BinaryenLiteralInt32(1));
-  expressions[652] = BinaryenSIMDShift(the_module, 8, expressions[650], expressions[651]);
+  expressions[648] = BinaryenConst(the_module, BinaryenLiteralInt32(1));
+  expressions[649] = BinaryenSIMDShift(the_module, 6, expressions[647], expressions[648]);
   {
     uint8_t t247[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[653] = BinaryenConst(the_module, BinaryenLiteralVec128(t247));
+    expressions[650] = BinaryenConst(the_module, BinaryenLiteralVec128(t247));
   }
-  expressions[654] = BinaryenConst(the_module, BinaryenLiteralInt32(1));
-  expressions[655] = BinaryenSIMDShift(the_module, 9, expressions[653], expressions[654]);
+  expressions[651] = BinaryenConst(the_module, BinaryenLiteralInt32(1));
+  expressions[652] = BinaryenSIMDShift(the_module, 7, expressions[650], expressions[651]);
   {
     uint8_t t248[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[656] = BinaryenConst(the_module, BinaryenLiteralVec128(t248));
+    expressions[653] = BinaryenConst(the_module, BinaryenLiteralVec128(t248));
   }
-  expressions[657] = BinaryenConst(the_module, BinaryenLiteralInt32(1));
-  expressions[658] = BinaryenSIMDShift(the_module, 10, expressions[656], expressions[657]);
+  expressions[654] = BinaryenConst(the_module, BinaryenLiteralInt32(1));
+  expressions[655] = BinaryenSIMDShift(the_module, 8, expressions[653], expressions[654]);
   {
     uint8_t t249[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[659] = BinaryenConst(the_module, BinaryenLiteralVec128(t249));
+    expressions[656] = BinaryenConst(the_module, BinaryenLiteralVec128(t249));
   }
-  expressions[660] = BinaryenConst(the_module, BinaryenLiteralInt32(1));
-  expressions[661] = BinaryenSIMDShift(the_module, 11, expressions[659], expressions[660]);
-  expressions[662] = BinaryenConst(the_module, BinaryenLiteralInt32(128));
-  expressions[663] = BinaryenSIMDLoad(the_module, 0, 0, 1, expressions[662]);
-  expressions[664] = BinaryenConst(the_module, BinaryenLiteralInt32(128));
-  expressions[665] = BinaryenSIMDLoad(the_module, 1, 16, 1, expressions[664]);
-  expressions[666] = BinaryenConst(the_module, BinaryenLiteralInt32(128));
-  expressions[667] = BinaryenSIMDLoad(the_module, 2, 16, 4, expressions[666]);
-  expressions[668] = BinaryenConst(the_module, BinaryenLiteralInt32(128));
-  expressions[669] = BinaryenSIMDLoad(the_module, 3, 0, 4, expressions[668]);
-  expressions[670] = BinaryenConst(the_module, BinaryenLiteralInt32(128));
-  expressions[671] = BinaryenSIMDLoad(the_module, 4, 0, 8, expressions[670]);
-  expressions[672] = BinaryenConst(the_module, BinaryenLiteralInt32(128));
-  expressions[673] = BinaryenSIMDLoad(the_module, 5, 0, 8, expressions[672]);
-  expressions[674] = BinaryenConst(the_module, BinaryenLiteralInt32(128));
-  expressions[675] = BinaryenSIMDLoad(the_module, 6, 0, 8, expressions[674]);
-  expressions[676] = BinaryenConst(the_module, BinaryenLiteralInt32(128));
-  expressions[677] = BinaryenSIMDLoad(the_module, 7, 0, 8, expressions[676]);
-  expressions[678] = BinaryenConst(the_module, BinaryenLiteralInt32(128));
-  expressions[679] = BinaryenSIMDLoad(the_module, 8, 0, 8, expressions[678]);
-  expressions[680] = BinaryenConst(the_module, BinaryenLiteralInt32(128));
-  expressions[681] = BinaryenSIMDLoad(the_module, 9, 0, 8, expressions[680]);
+  expressions[657] = BinaryenConst(the_module, BinaryenLiteralInt32(1));
+  expressions[658] = BinaryenSIMDShift(the_module, 9, expressions[656], expressions[657]);
   {
     uint8_t t250[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[682] = BinaryenConst(the_module, BinaryenLiteralVec128(t250));
+    expressions[659] = BinaryenConst(the_module, BinaryenLiteralVec128(t250));
   }
+  expressions[660] = BinaryenConst(the_module, BinaryenLiteralInt32(1));
+  expressions[661] = BinaryenSIMDShift(the_module, 10, expressions[659], expressions[660]);
   {
     uint8_t t251[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[683] = BinaryenConst(the_module, BinaryenLiteralVec128(t251));
-  }
-  {
-    uint8_t mask[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
-    expressions[684] = BinaryenSIMDShuffle(the_module, expressions[682], expressions[683], mask);
-  }
+    expressions[662] = BinaryenConst(the_module, BinaryenLiteralVec128(t251));
+  }
+  expressions[663] = BinaryenConst(the_module, BinaryenLiteralInt32(1));
+  expressions[664] = BinaryenSIMDShift(the_module, 11, expressions[662], expressions[663]);
+  expressions[665] = BinaryenConst(the_module, BinaryenLiteralInt32(128));
+  expressions[666] = BinaryenSIMDLoad(the_module, 0, 0, 1, expressions[665]);
+  expressions[667] = BinaryenConst(the_module, BinaryenLiteralInt32(128));
+  expressions[668] = BinaryenSIMDLoad(the_module, 1, 16, 1, expressions[667]);
+  expressions[669] = BinaryenConst(the_module, BinaryenLiteralInt32(128));
+  expressions[670] = BinaryenSIMDLoad(the_module, 2, 16, 4, expressions[669]);
+  expressions[671] = BinaryenConst(the_module, BinaryenLiteralInt32(128));
+  expressions[672] = BinaryenSIMDLoad(the_module, 3, 0, 4, expressions[671]);
+  expressions[673] = BinaryenConst(the_module, BinaryenLiteralInt32(128));
+  expressions[674] = BinaryenSIMDLoad(the_module, 4, 0, 8, expressions[673]);
+  expressions[675] = BinaryenConst(the_module, BinaryenLiteralInt32(128));
+  expressions[676] = BinaryenSIMDLoad(the_module, 5, 0, 8, expressions[675]);
+  expressions[677] = BinaryenConst(the_module, BinaryenLiteralInt32(128));
+  expressions[678] = BinaryenSIMDLoad(the_module, 6, 0, 8, expressions[677]);
+  expressions[679] = BinaryenConst(the_module, BinaryenLiteralInt32(128));
+  expressions[680] = BinaryenSIMDLoad(the_module, 7, 0, 8, expressions[679]);
+  expressions[681] = BinaryenConst(the_module, BinaryenLiteralInt32(128));
+  expressions[682] = BinaryenSIMDLoad(the_module, 8, 0, 8, expressions[681]);
+  expressions[683] = BinaryenConst(the_module, BinaryenLiteralInt32(128));
+  expressions[684] = BinaryenSIMDLoad(the_module, 9, 0, 8, expressions[683]);
   {
     uint8_t t252[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
     expressions[685] = BinaryenConst(the_module, BinaryenLiteralVec128(t252));
@@ -3709,10 +3712,13 @@ int main() {
     expressions[686] = BinaryenConst(the_module, BinaryenLiteralVec128(t253));
   }
   {
+    uint8_t mask[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+    expressions[687] = BinaryenSIMDShuffle(the_module, expressions[685], expressions[686], mask);
+  }
+  {
     uint8_t t254[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[687] = BinaryenConst(the_module, BinaryenLiteralVec128(t254));
+    expressions[688] = BinaryenConst(the_module, BinaryenLiteralVec128(t254));
   }
-  expressions[688] = BinaryenSIMDTernary(the_module, 0, expressions[685], expressions[686], expressions[687]);
   {
     uint8_t t255[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
     expressions[689] = BinaryenConst(the_module, BinaryenLiteralVec128(t255));
@@ -3721,11 +3727,11 @@ int main() {
     uint8_t t256[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
     expressions[690] = BinaryenConst(the_module, BinaryenLiteralVec128(t256));
   }
+  expressions[691] = BinaryenSIMDTernary(the_module, 0, expressions[688], expressions[689], expressions[690]);
   {
     uint8_t t257[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[691] = BinaryenConst(the_module, BinaryenLiteralVec128(t257));
+    expressions[692] = BinaryenConst(the_module, BinaryenLiteralVec128(t257));
   }
-  expressions[692] = BinaryenSIMDTernary(the_module, 1, expressions[689], expressions[690], expressions[691]);
   {
     uint8_t t258[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
     expressions[693] = BinaryenConst(the_module, BinaryenLiteralVec128(t258));
@@ -3734,11 +3740,11 @@ int main() {
     uint8_t t259[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
     expressions[694] = BinaryenConst(the_module, BinaryenLiteralVec128(t259));
   }
+  expressions[695] = BinaryenSIMDTernary(the_module, 1, expressions[692], expressions[693], expressions[694]);
   {
     uint8_t t260[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[695] = BinaryenConst(the_module, BinaryenLiteralVec128(t260));
+    expressions[696] = BinaryenConst(the_module, BinaryenLiteralVec128(t260));
   }
-  expressions[696] = BinaryenSIMDTernary(the_module, 2, expressions[693], expressions[694], expressions[695]);
   {
     uint8_t t261[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
     expressions[697] = BinaryenConst(the_module, BinaryenLiteralVec128(t261));
@@ -3747,11 +3753,11 @@ int main() {
     uint8_t t262[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
     expressions[698] = BinaryenConst(the_module, BinaryenLiteralVec128(t262));
   }
+  expressions[699] = BinaryenSIMDTernary(the_module, 2, expressions[696], expressions[697], expressions[698]);
   {
     uint8_t t263[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[699] = BinaryenConst(the_module, BinaryenLiteralVec128(t263));
+    expressions[700] = BinaryenConst(the_module, BinaryenLiteralVec128(t263));
   }
-  expressions[700] = BinaryenSIMDTernary(the_module, 3, expressions[697], expressions[698], expressions[699]);
   {
     uint8_t t264[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
     expressions[701] = BinaryenConst(the_module, BinaryenLiteralVec128(t264));
@@ -3760,117 +3766,126 @@ int main() {
     uint8_t t265[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
     expressions[702] = BinaryenConst(the_module, BinaryenLiteralVec128(t265));
   }
+  expressions[703] = BinaryenSIMDTernary(the_module, 3, expressions[700], expressions[701], expressions[702]);
   {
     uint8_t t266[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[703] = BinaryenConst(the_module, BinaryenLiteralVec128(t266));
-  }
-  expressions[704] = BinaryenSIMDTernary(the_module, 4, expressions[701], expressions[702], expressions[703]);
-  expressions[705] = BinaryenConst(the_module, BinaryenLiteralInt32(1024));
-  expressions[706] = BinaryenConst(the_module, BinaryenLiteralInt32(0));
-  expressions[707] = BinaryenConst(the_module, BinaryenLiteralInt32(12));
-  expressions[708] = BinaryenMemoryInit(the_module, 0, expressions[705], expressions[706], expressions[707]);
-  expressions[709] = BinaryenDataDrop(the_module, 0);
-  expressions[710] = BinaryenConst(the_module, BinaryenLiteralInt32(2048));
-  expressions[711] = BinaryenConst(the_module, BinaryenLiteralInt32(1024));
-  expressions[712] = BinaryenConst(the_module, BinaryenLiteralInt32(12));
-  expressions[713] = BinaryenMemoryCopy(the_module, expressions[710], expressions[711], expressions[712]);
-  expressions[714] = BinaryenConst(the_module, BinaryenLiteralInt32(0));
-  expressions[715] = BinaryenConst(the_module, BinaryenLiteralInt32(42));
-  expressions[716] = BinaryenConst(the_module, BinaryenLiteralInt32(1024));
-  expressions[717] = BinaryenMemoryFill(the_module, expressions[714], expressions[715], expressions[716]);
+    expressions[704] = BinaryenConst(the_module, BinaryenLiteralVec128(t266));
+  }
+  {
+    uint8_t t267[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
+    expressions[705] = BinaryenConst(the_module, BinaryenLiteralVec128(t267));
+  }
+  {
+    uint8_t t268[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
+    expressions[706] = BinaryenConst(the_module, BinaryenLiteralVec128(t268));
+  }
+  expressions[707] = BinaryenSIMDTernary(the_module, 4, expressions[704], expressions[705], expressions[706]);
+  expressions[708] = BinaryenConst(the_module, BinaryenLiteralInt32(1024));
+  expressions[709] = BinaryenConst(the_module, BinaryenLiteralInt32(0));
+  expressions[710] = BinaryenConst(the_module, BinaryenLiteralInt32(12));
+  expressions[711] = BinaryenMemoryInit(the_module, 0, expressions[708], expressions[709], expressions[710]);
+  expressions[712] = BinaryenDataDrop(the_module, 0);
+  expressions[713] = BinaryenConst(the_module, BinaryenLiteralInt32(2048));
+  expressions[714] = BinaryenConst(the_module, BinaryenLiteralInt32(1024));
+  expressions[715] = BinaryenConst(the_module, BinaryenLiteralInt32(12));
+  expressions[716] = BinaryenMemoryCopy(the_module, expressions[713], expressions[714], expressions[715]);
+  expressions[717] = BinaryenConst(the_module, BinaryenLiteralInt32(0));
+  expressions[718] = BinaryenConst(the_module, BinaryenLiteralInt32(42));
+  expressions[719] = BinaryenConst(the_module, BinaryenLiteralInt32(1024));
+  expressions[720] = BinaryenMemoryFill(the_module, expressions[717], expressions[718], expressions[719]);
   {
     BinaryenExpressionRef children[] = { 0 };
-    expressions[718] = BinaryenBlock(the_module, NULL, children, 0, BinaryenTypeAuto());
-  }
-  expressions[719] = BinaryenIf(the_module, expressions[18], expressions[19], expressions[20]);
-  expressions[720] = BinaryenIf(the_module, expressions[21], expressions[22], expressions[0]);
-  expressions[721] = BinaryenConst(the_module, BinaryenLiteralInt32(0));
-  expressions[722] = BinaryenLoop(the_module, "in", expressions[721]);
-  expressions[723] = BinaryenConst(the_module, BinaryenLiteralInt32(0));
-  expressions[724] = BinaryenLoop(the_module, NULL, expressions[723]);
-  expressions[725] = BinaryenBreak(the_module, "the-value", expressions[23], expressions[24]);
-  expressions[726] = BinaryenConst(the_module, BinaryenLiteralInt32(2));
-  expressions[727] = BinaryenBreak(the_module, "the-nothing", expressions[726], expressions[0]);
-  expressions[728] = BinaryenConst(the_module, BinaryenLiteralInt32(3));
-  expressions[729] = BinaryenBreak(the_module, "the-value", expressions[0], expressions[728]);
-  expressions[730] = BinaryenBreak(the_module, "the-nothing", expressions[0], expressions[0]);
+    expressions[721] = BinaryenBlock(the_module, NULL, children, 0, BinaryenTypeAuto());
+  }
+  expressions[722] = BinaryenIf(the_module, expressions[18], expressions[19], expressions[20]);
+  expressions[723] = BinaryenIf(the_module, expressions[21], expressions[22], expressions[0]);
+  expressions[724] = BinaryenConst(the_module, BinaryenLiteralInt32(0));
+  expressions[725] = BinaryenLoop(the_module, "in", expressions[724]);
+  expressions[726] = BinaryenConst(the_module, BinaryenLiteralInt32(0));
+  expressions[727] = BinaryenLoop(the_module, NULL, expressions[726]);
+  expressions[728] = BinaryenBreak(the_module, "the-value", expressions[23], expressions[24]);
+  expressions[729] = BinaryenConst(the_module, BinaryenLiteralInt32(2));
+  expressions[730] = BinaryenBreak(the_module, "the-nothing", expressions[729], expressions[0]);
+  expressions[731] = BinaryenConst(the_module, BinaryenLiteralInt32(3));
+  expressions[732] = BinaryenBreak(the_module, "the-value", expressions[0], expressions[731]);
+  expressions[733] = BinaryenBreak(the_module, "the-nothing", expressions[0], expressions[0]);
   {
     const char* names[] = { "the-value" };
-    expressions[731] = BinaryenSwitch(the_module, names, 1, "the-value", expressions[25], expressions[26]);
+    expressions[734] = BinaryenSwitch(the_module, names, 1, "the-value", expressions[25], expressions[26]);
   }
-  expressions[732] = BinaryenConst(the_module, BinaryenLiteralInt32(2));
+  expressions[735] = BinaryenConst(the_module, BinaryenLiteralInt32(2));
   {
     const char* names[] = { "the-nothing" };
-    expressions[733] = BinaryenSwitch(the_module, names, 1, "the-nothing", expressions[732], expressions[0]);
+    expressions[736] = BinaryenSwitch(the_module, names, 1, "the-nothing", expressions[735], expressions[0]);
   }
   {
     BinaryenExpressionRef operands[] = { expressions[10], expressions[11], expressions[12], expressions[13] };
-    expressions[734] = BinaryenCall(the_module, "kitchen()sinker", operands, 4, 1);
+    expressions[737] = BinaryenCall(the_module, "kitchen()sinker", operands, 4, 1);
   }
-  expressions[735] = BinaryenUnary(the_module, 20, expressions[734]);
+  expressions[738] = BinaryenUnary(the_module, 20, expressions[737]);
   {
     BinaryenExpressionRef operands[] = { expressions[8], expressions[9] };
-    expressions[736] = BinaryenCall(the_module, "an-imported", operands, 2, 3);
+    expressions[739] = BinaryenCall(the_module, "an-imported", operands, 2, 3);
   }
-  expressions[737] = BinaryenUnary(the_module, 25, expressions[736]);
-  expressions[738] = BinaryenUnary(the_module, 20, expressions[737]);
-  expressions[739] = BinaryenConst(the_module, BinaryenLiteralInt32(2449));
+  expressions[740] = BinaryenUnary(the_module, 25, expressions[739]);
+  expressions[741] = BinaryenUnary(the_module, 20, expressions[740]);
+  expressions[742] = BinaryenConst(the_module, BinaryenLiteralInt32(2449));
   {
     BinaryenExpressionRef operands[] = { expressions[14], expressions[15], expressions[16], expressions[17] };
-    expressions[740] = BinaryenCallIndirect(the_module, expressions[739], operands, 4, "iiIfF");
-  }
-  expressions[741] = BinaryenUnary(the_module, 20, expressions[740]);
-  expressions[742] = BinaryenLocalGet(the_module, 0, 1);
-  expressions[743] = BinaryenDrop(the_module, expressions[742]);
-  expressions[744] = BinaryenConst(the_module, BinaryenLiteralInt32(101));
-  expressions[745] = BinaryenLocalSet(the_module, 0, expressions[744]);
-  expressions[746] = BinaryenConst(the_module, BinaryenLiteralInt32(102));
-  expressions[747] = BinaryenLocalTee(the_module, 0, expressions[746]);
-  expressions[748] = BinaryenDrop(the_module, expressions[747]);
-  expressions[749] = BinaryenConst(the_module, BinaryenLiteralInt32(1));
-  expressions[750] = BinaryenLoad(the_module, 4, 0, 0, 0, 1, expressions[749]);
-  expressions[751] = BinaryenConst(the_module, BinaryenLiteralInt32(8));
-  expressions[752] = BinaryenLoad(the_module, 2, 1, 2, 1, 2, expressions[751]);
-  expressions[753] = BinaryenConst(the_module, BinaryenLiteralInt32(2));
-  expressions[754] = BinaryenLoad(the_module, 4, 0, 0, 0, 3, expressions[753]);
-  expressions[755] = BinaryenConst(the_module, BinaryenLiteralInt32(9));
-  expressions[756] = BinaryenLoad(the_module, 8, 0, 2, 8, 4, expressions[755]);
-  expressions[757] = BinaryenStore(the_module, 4, 0, 0, expressions[30], expressions[31], 1);
-  expressions[758] = BinaryenStore(the_module, 8, 2, 4, expressions[32], expressions[33], 2);
-  expressions[759] = BinaryenSelect(the_module, expressions[27], expressions[28], expressions[29]);
-  expressions[760] = BinaryenConst(the_module, BinaryenLiteralInt32(1337));
-  expressions[761] = BinaryenReturn(the_module, expressions[760]);
+    expressions[743] = BinaryenCallIndirect(the_module, expressions[742], operands, 4, "iiIfF");
+  }
+  expressions[744] = BinaryenUnary(the_module, 20, expressions[743]);
+  expressions[745] = BinaryenLocalGet(the_module, 0, 1);
+  expressions[746] = BinaryenDrop(the_module, expressions[745]);
+  expressions[747] = BinaryenConst(the_module, BinaryenLiteralInt32(101));
+  expressions[748] = BinaryenLocalSet(the_module, 0, expressions[747]);
+  expressions[749] = BinaryenConst(the_module, BinaryenLiteralInt32(102));
+  expressions[750] = BinaryenLocalTee(the_module, 0, expressions[749]);
+  expressions[751] = BinaryenDrop(the_module, expressions[750]);
+  expressions[752] = BinaryenConst(the_module, BinaryenLiteralInt32(1));
+  expressions[753] = BinaryenLoad(the_module, 4, 0, 0, 0, 1, expressions[752]);
+  expressions[754] = BinaryenConst(the_module, BinaryenLiteralInt32(8));
+  expressions[755] = BinaryenLoad(the_module, 2, 1, 2, 1, 2, expressions[754]);
+  expressions[756] = BinaryenConst(the_module, BinaryenLiteralInt32(2));
+  expressions[757] = BinaryenLoad(the_module, 4, 0, 0, 0, 3, expressions[756]);
+  expressions[758] = BinaryenConst(the_module, BinaryenLiteralInt32(9));
+  expressions[759] = BinaryenLoad(the_module, 8, 0, 2, 8, 4, expressions[758]);
+  expressions[760] = BinaryenStore(the_module, 4, 0, 0, expressions[30], expressions[31], 1);
+  expressions[761] = BinaryenStore(the_module, 8, 2, 4, expressions[32], expressions[33], 2);
+  expressions[762] = BinaryenSelect(the_module, expressions[27], expressions[28], expressions[29]);
+  expressions[763] = BinaryenConst(the_module, BinaryenLiteralInt32(1337));
+  expressions[764] = BinaryenReturn(the_module, expressions[763]);
   {
     BinaryenExpressionRef operands[] = { expressions[10], expressions[11], expressions[12], expressions[13] };
-    expressions[762] = BinaryenReturnCall(the_module, "kitchen()sinker", operands, 4, 1);
+    expressions[765] = BinaryenReturnCall(the_module, "kitchen()sinker", operands, 4, 1);
   }
-  expressions[763] = BinaryenConst(the_module, BinaryenLiteralInt32(2449));
+  expressions[766] = BinaryenConst(the_module, BinaryenLiteralInt32(2449));
   {
     BinaryenExpressionRef operands[] = { expressions[14], expressions[15], expressions[16], expressions[17] };
-    expressions[764] = BinaryenReturnCallIndirect(the_module, expressions[763], operands, 4, "iiIfF");
-  }
-  expressions[765] = BinaryenTry(the_module, expressions[35], expressions[43]);
-  expressions[766] = BinaryenAtomicLoad(the_module, 4, 0, 1, expressions[23]);
-  expressions[767] = BinaryenAtomicStore(the_module, 4, 0, expressions[23], expressions[766], 1);
-  expressions[768] = BinaryenAtomicWait(the_module, expressions[23], expressions[23], expressions[33], 1);
-  expressions[769] = BinaryenDrop(the_module, expressions[768]);
-  expressions[770] = BinaryenAtomicNotify(the_module, expressions[23], expressions[23]);
-  expressions[771] = BinaryenDrop(the_module, expressions[770]);
-  expressions[772] = BinaryenAtomicFence(the_module);
-  expressions[773] = BinaryenPop(the_module, 1);
-  expressions[774] = BinaryenPush(the_module, expressions[773]);
-  expressions[775] = BinaryenPop(the_module, 2);
-  expressions[776] = BinaryenPush(the_module, expressions[775]);
-  expressions[777] = BinaryenPop(the_module, 3);
-  expressions[778] = BinaryenPush(the_module, expressions[777]);
-  expressions[779] = BinaryenPop(the_module, 4);
-  expressions[780] = BinaryenPush(the_module, expressions[779]);
-  expressions[781] = BinaryenPop(the_module, 6);
-  expressions[782] = BinaryenPush(the_module, expressions[781]);
-  expressions[783] = BinaryenPop(the_module, 7);
-  expressions[784] = BinaryenPush(the_module, expressions[783]);
-  expressions[785] = BinaryenNop(the_module);
-  expressions[786] = BinaryenUnreachable(the_module);
+    expressions[767] = BinaryenReturnCallIndirect(the_module, expressions[766], operands, 4, "iiIfF");
+  }
+  expressions[768] = BinaryenTry(the_module, expressions[35], expressions[43]);
+  expressions[769] = BinaryenAtomicLoad(the_module, 4, 0, 1, expressions[23]);
+  expressions[770] = BinaryenAtomicStore(the_module, 4, 0, expressions[23], expressions[769], 1);
+  expressions[771] = BinaryenAtomicWait(the_module, expressions[23], expressions[23], expressions[33], 1);
+  expressions[772] = BinaryenDrop(the_module, expressions[771]);
+  expressions[773] = BinaryenAtomicNotify(the_module, expressions[23], expressions[23]);
+  expressions[774] = BinaryenDrop(the_module, expressions[773]);
+  expressions[775] = BinaryenAtomicFence(the_module);
+  expressions[776] = BinaryenPop(the_module, 1);
+  expressions[777] = BinaryenPush(the_module, expressions[776]);
+  expressions[778] = BinaryenPop(the_module, 2);
+  expressions[779] = BinaryenPush(the_module, expressions[778]);
+  expressions[780] = BinaryenPop(the_module, 3);
+  expressions[781] = BinaryenPush(the_module, expressions[780]);
+  expressions[782] = BinaryenPop(the_module, 4);
+  expressions[783] = BinaryenPush(the_module, expressions[782]);
+  expressions[784] = BinaryenPop(the_module, 6);
+  expressions[785] = BinaryenPush(the_module, expressions[784]);
+  expressions[786] = BinaryenPop(the_module, 7);
+  expressions[787] = BinaryenPush(the_module, expressions[786]);
+  expressions[788] = BinaryenNop(the_module);
+  expressions[789] = BinaryenUnreachable(the_module);
   BinaryenExpressionPrint(expressions[51]);
 (f32.neg
  (f32.const -33.61199951171875)
@@ -3911,41 +3926,41 @@ int main() {
        expressions[534], expressions[537], expressions[540], expressions[543], expressions[546], expressions[549], 
        expressions[552], expressions[555], expressions[558], expressions[561], expressions[564], expressions[567], 
        expressions[570], expressions[573], expressions[576], expressions[579], expressions[582], expressions[585], 
-       expressions[588], expressions[591], expressions[593], expressions[595], expressions[597], expressions[599], 
-       expressions[601], expressions[603], expressions[605], expressions[607], expressions[610], expressions[613], 
+       expressions[588], expressions[591], expressions[594], expressions[596], expressions[598], expressions[600], 
+       expressions[602], expressions[604], expressions[606], expressions[608], expressions[610], expressions[613], 
        expressions[616], expressions[619], expressions[622], expressions[625], expressions[628], expressions[631], 
        expressions[634], expressions[637], expressions[640], expressions[643], expressions[646], expressions[649], 
-       expressions[652], expressions[655], expressions[658], expressions[661], expressions[663], expressions[665], 
-       expressions[667], expressions[669], expressions[671], expressions[673], expressions[675], expressions[677], 
-       expressions[679], expressions[681], expressions[684], expressions[688], expressions[692], expressions[696], 
-       expressions[700], expressions[704], expressions[708], expressions[709], expressions[713], expressions[717], 
-       expressions[718], expressions[719], expressions[720], expressions[722], expressions[724], expressions[725], 
-       expressions[727], expressions[729], expressions[730], expressions[731], expressions[733], expressions[735], 
-       expressions[738], expressions[741], expressions[743], expressions[745], expressions[748], expressions[750], 
-       expressions[752], expressions[754], expressions[756], expressions[757], expressions[758], expressions[759], 
-       expressions[761], expressions[762], expressions[764], expressions[765], expressions[767], expressions[769], 
-       expressions[771], expressions[772], expressions[774], expressions[776], expressions[778], expressions[780], 
-       expressions[782], expressions[784], expressions[785], expressions[786] };
-    expressions[787] = BinaryenBlock(the_module, "the-value", children, 297, BinaryenTypeAuto());
+       expressions[652], expressions[655], expressions[658], expressions[661], expressions[664], expressions[666], 
+       expressions[668], expressions[670], expressions[672], expressions[674], expressions[676], expressions[678], 
+       expressions[680], expressions[682], expressions[684], expressions[687], expressions[691], expressions[695], 
+       expressions[699], expressions[703], expressions[707], expressions[711], expressions[712], expressions[716], 
+       expressions[720], expressions[721], expressions[722], expressions[723], expressions[725], expressions[727], 
+       expressions[728], expressions[730], expressions[732], expressions[733], expressions[734], expressions[736], 
+       expressions[738], expressions[741], expressions[744], expressions[746], expressions[748], expressions[751], 
+       expressions[753], expressions[755], expressions[757], expressions[759], expressions[760], expressions[761], 
+       expressions[762], expressions[764], expressions[765], expressions[767], expressions[768], expressions[770], 
+       expressions[772], expressions[774], expressions[775], expressions[777], expressions[779], expressions[781], 
+       expressions[783], expressions[785], expressions[787], expressions[788], expressions[789] };
+    expressions[790] = BinaryenBlock(the_module, "the-value", children, 298, BinaryenTypeAuto());
   }
-  expressions[788] = BinaryenDrop(the_module, expressions[787]);
+  expressions[791] = BinaryenDrop(the_module, expressions[790]);
   {
-    BinaryenExpressionRef children[] = { expressions[788] };
-    expressions[789] = BinaryenBlock(the_module, "the-nothing", children, 1, BinaryenTypeAuto());
+    BinaryenExpressionRef children[] = { expressions[791] };
+    expressions[792] = BinaryenBlock(the_module, "the-nothing", children, 1, BinaryenTypeAuto());
   }
-  expressions[790] = BinaryenConst(the_module, BinaryenLiteralInt32(42));
+  expressions[793] = BinaryenConst(the_module, BinaryenLiteralInt32(42));
   {
-    BinaryenExpressionRef children[] = { expressions[789], expressions[790] };
-    expressions[791] = BinaryenBlock(the_module, "the-body", children, 2, BinaryenTypeAuto());
+    BinaryenExpressionRef children[] = { expressions[792], expressions[793] };
+    expressions[794] = BinaryenBlock(the_module, "the-body", children, 2, BinaryenTypeAuto());
   }
   {
     BinaryenType varTypes[] = { 1, 7 };
-    functions[0] = BinaryenAddFunction(the_module, "kitchen()sinker", functionTypes[0], varTypes, 2, expressions[791]);
+    functions[0] = BinaryenAddFunction(the_module, "kitchen()sinker", functionTypes[0], varTypes, 2, expressions[794]);
   }
-  expressions[792] = BinaryenConst(the_module, BinaryenLiteralInt32(7));
-  globals[0] = BinaryenAddGlobal(the_module, "a-global", 1, 0, expressions[792]);
-  expressions[793] = BinaryenConst(the_module, BinaryenLiteralFloat32(7.5));
-  globals[1] = BinaryenAddGlobal(the_module, "a-mutable-global", 3, 1, expressions[793]);
+  expressions[795] = BinaryenConst(the_module, BinaryenLiteralInt32(7));
+  globals[0] = BinaryenAddGlobal(the_module, "a-global", 1, 0, expressions[795]);
+  expressions[796] = BinaryenConst(the_module, BinaryenLiteralFloat32(7.5));
+  globals[1] = BinaryenAddGlobal(the_module, "a-mutable-global", 3, 1, expressions[796]);
   {
     BinaryenType paramTypes[] = { 1, 4 };
     functionTypes[2] = BinaryenAddFunctionType(the_module, "fiF", 3, paramTypes, 2);
@@ -3953,18 +3968,18 @@ int main() {
   BinaryenAddFunctionImport(the_module, "an-imported", "module", "base", functionTypes[2]);
   exports[0] = BinaryenAddFunctionExport(the_module, "kitchen()sinker", "kitchen_sinker");
   BinaryenFunctionGetName(functions[0]);
-  expressions[794] = BinaryenConst(the_module, BinaryenLiteralInt32(0));
+  expressions[797] = BinaryenConst(the_module, BinaryenLiteralInt32(0));
   {
     const char* funcNames[] = { "kitchen()sinker" };
-    BinaryenSetFunctionTable(the_module, 1, 1, funcNames, 1, expressions[794]);
+    BinaryenSetFunctionTable(the_module, 1, 1, funcNames, 1, expressions[797]);
   }
-  expressions[795] = BinaryenConst(the_module, BinaryenLiteralInt32(10));
+  expressions[798] = BinaryenConst(the_module, BinaryenLiteralInt32(10));
   {
     const char segment0[] = { 104, 101, 108, 108, 111, 44, 32, 119, 111, 114, 108, 100 };
     const char segment1[] = { 73, 32, 97, 109, 32, 112, 97, 115, 115, 105, 118, 101 };
     const char* segments[] = { segment0, segment1 };
     int8_t segmentPassive[] = { 0, 1 };
-    BinaryenExpressionRef segmentOffsets[] = { expressions[795], expressions[0] };
+    BinaryenExpressionRef segmentOffsets[] = { expressions[798], expressions[0] };
     BinaryenIndex segmentSizes[] = { 12, 12 };
     BinaryenSetMemory(the_module, 1, 256, "mem", segments, segmentPassive, segmentOffsets, segmentSizes, 2, 1);
   }
@@ -3972,10 +3987,10 @@ int main() {
     BinaryenType paramTypes[] = { 0 };
     functionTypes[3] = BinaryenAddFunctionType(the_module, "v", 0, paramTypes, 0);
   }
-  expressions[796] = BinaryenNop(the_module);
+  expressions[799] = BinaryenNop(the_module);
   {
     BinaryenType varTypes[] = { 0 };
-    functions[1] = BinaryenAddFunction(the_module, "starter", functionTypes[3], varTypes, 0, expressions[796]);
+    functions[1] = BinaryenAddFunction(the_module, "starter", functionTypes[3], varTypes, 0, expressions[799]);
   }
   BinaryenSetStart(the_module, functions[1]);
   {
@@ -5110,6 +5125,12 @@ int main() {
        )
       )
       (drop
+       (i32x4.dot_i16x8_s
+        (v128.const i32x4 0x04030201 0x08070605 0x0c0b0a09 0x100f0e0d)
+        (v128.const i32x4 0x04030201 0x08070605 0x0c0b0a09 0x100f0e0d)
+       )
+      )
+      (drop
        (f32x4.div
         (v128.const i32x4 0x04030201 0x08070605 0x0c0b0a09 0x100f0e0d)
         (v128.const i32x4 0x04030201 0x08070605 0x0c0b0a09 0x100f0e0d)
diff --git a/test/example/c-api-kitchen-sink.txt.txt b/test/example/c-api-kitchen-sink.txt.txt
index dd6016d71..ada00077f 100644
--- a/test/example/c-api-kitchen-sink.txt.txt
+++ b/test/example/c-api-kitchen-sink.txt.txt
@@ -1124,6 +1124,12 @@
        )
       )
       (drop
+       (i32x4.dot_i16x8_s
+        (v128.const i32x4 0x04030201 0x08070605 0x0c0b0a09 0x100f0e0d)
+        (v128.const i32x4 0x04030201 0x08070605 0x0c0b0a09 0x100f0e0d)
+       )
+      )
+      (drop
        (f32x4.div
         (v128.const i32x4 0x04030201 0x08070605 0x0c0b0a09 0x100f0e0d)
         (v128.const i32x4 0x04030201 0x08070605 0x0c0b0a09 0x100f0e0d)
diff --git a/test/simd.wast b/test/simd.wast
index 334819538..1584674aa 100644
--- a/test/simd.wast
+++ b/test/simd.wast
@@ -697,6 +697,12 @@
    (local.get $1)
   )
  )
+ (func $i32x4.dot_i16x8_s (param $0 v128) (param $1 v128) (result v128)
+  (i32x4.dot_i16x8_s
+   (local.get $0)
+   (local.get $1)
+  )
+ )
  (func $i64x2.neg (param $0 v128) (result v128)
   (i64x2.neg
    (local.get $0)
diff --git a/test/simd.wast.from-wast b/test/simd.wast.from-wast
index 9cbf42d71..b5914a62d 100644
--- a/test/simd.wast.from-wast
+++ b/test/simd.wast.from-wast
@@ -713,336 +713,342 @@
    (local.get $1)
   )
  )
- (func $i64x2.neg (; 123 ;) (type $FUNCSIG$VV) (param $0 v128) (result v128)
+ (func $i32x4.dot_i16x8_s (; 123 ;) (type $FUNCSIG$VVV) (param $0 v128) (param $1 v128) (result v128)
+  (i32x4.dot_i16x8_s
+   (local.get $0)
+   (local.get $1)
+  )
+ )
+ (func $i64x2.neg (; 124 ;) (type $FUNCSIG$VV) (param $0 v128) (result v128)
   (i64x2.neg
    (local.get $0)
   )
  )
- (func $i64x2.any_true (; 124 ;) (type $FUNCSIG$iV) (param $0 v128) (result i32)
+ (func $i64x2.any_true (; 125 ;) (type $FUNCSIG$iV) (param $0 v128) (result i32)
   (i64x2.any_true
    (local.get $0)
   )
  )
- (func $i64x2.all_true (; 125 ;) (type $FUNCSIG$iV) (param $0 v128) (result i32)
+ (func $i64x2.all_true (; 126 ;) (type $FUNCSIG$iV) (param $0 v128) (result i32)
   (i64x2.all_true
    (local.get $0)
   )
  )
- (func $i64x2.shl (; 126 ;) (type $FUNCSIG$VVi) (param $0 v128) (param $1 i32) (result v128)
+ (func $i64x2.shl (; 127 ;) (type $FUNCSIG$VVi) (param $0 v128) (param $1 i32) (result v128)
   (i64x2.shl
    (local.get $0)
    (local.get $1)
   )
  )
- (func $i64x2.shr_s (; 127 ;) (type $FUNCSIG$VVi) (param $0 v128) (param $1 i32) (result v128)
+ (func $i64x2.shr_s (; 128 ;) (type $FUNCSIG$VVi) (param $0 v128) (param $1 i32) (result v128)
   (i64x2.shr_s
    (local.get $0)
    (local.get $1)
   )
  )
- (func $i64x2.shr_u (; 128 ;) (type $FUNCSIG$VVi) (param $0 v128) (param $1 i32) (result v128)
+ (func $i64x2.shr_u (; 129 ;) (type $FUNCSIG$VVi) (param $0 v128) (param $1 i32) (result v128)
   (i64x2.shr_u
    (local.get $0)
    (local.get $1)
   )
  )
- (func $i64x2.add (; 129 ;) (type $FUNCSIG$VVV) (param $0 v128) (param $1 v128) (result v128)
+ (func $i64x2.add (; 130 ;) (type $FUNCSIG$VVV) (param $0 v128) (param $1 v128) (result v128)
   (i64x2.add
    (local.get $0)
    (local.get $1)
   )
  )
- (func $i64x2.sub (; 130 ;) (type $FUNCSIG$VVV) (param $0 v128) (param $1 v128) (result v128)
+ (func $i64x2.sub (; 131 ;) (type $FUNCSIG$VVV) (param $0 v128) (param $1 v128) (result v128)
   (i64x2.sub
    (local.get $0)
    (local.get $1)
   )
  )
- (func $f32x4.add (; 131 ;) (type $FUNCSIG$VVV) (param $0 v128) (param $1 v128) (result v128)
+ (func $f32x4.add (; 132 ;) (type $FUNCSIG$VVV) (param $0 v128) (param $1 v128) (result v128)
   (f32x4.add
    (local.get $0)
    (local.get $1)
   )
  )
- (func $f32x4.sub (; 132 ;) (type $FUNCSIG$VVV) (param $0 v128) (param $1 v128) (result v128)
+ (func $f32x4.sub (; 133 ;) (type $FUNCSIG$VVV) (param $0 v128) (param $1 v128) (result v128)
   (f32x4.sub
    (local.get $0)
    (local.get $1)
   )
  )
- (func $f32x4.mul (; 133 ;) (type $FUNCSIG$VVV) (param $0 v128) (param $1 v128) (result v128)
+ (func $f32x4.mul (; 134 ;) (type $FUNCSIG$VVV) (param $0 v128) (param $1 v128) (result v128)
   (f32x4.mul
    (local.get $0)
    (local.get $1)
   )
  )
- (func $f32x4.div (; 134 ;) (type $FUNCSIG$VVV) (param $0 v128) (param $1 v128) (result v128)
+ (func $f32x4.div (; 135 ;) (type $FUNCSIG$VVV) (param $0 v128) (param $1 v128) (result v128)
   (f32x4.div
    (local.get $0)
    (local.get $1)
   )
  )
- (func $f32x4.min (; 135 ;) (type $FUNCSIG$VVV) (param $0 v128) (param $1 v128) (result v128)
+ (func $f32x4.min (; 136 ;) (type $FUNCSIG$VVV) (param $0 v128) (param $1 v128) (result v128)
   (f32x4.min
    (local.get $0)
    (local.get $1)
   )
  )
- (func $f32x4.max (; 136 ;) (type $FUNCSIG$VVV) (param $0 v128) (param $1 v128) (result v128)
+ (func $f32x4.max (; 137 ;) (type $FUNCSIG$VVV) (param $0 v128) (param $1 v128) (result v128)
   (f32x4.max
    (local.get $0)
    (local.get $1)
   )
  )
- (func $f32x4.abs (; 137 ;) (type $FUNCSIG$VV) (param $0 v128) (result v128)
+ (func $f32x4.abs (; 138 ;) (type $FUNCSIG$VV) (param $0 v128) (result v128)
   (f32x4.abs
    (local.get $0)
   )
  )
- (func $f32x4.neg (; 138 ;) (type $FUNCSIG$VV) (param $0 v128) (result v128)
+ (func $f32x4.neg (; 139 ;) (type $FUNCSIG$VV) (param $0 v128) (result v128)
   (f32x4.neg
    (local.get $0)
   )
  )
- (func $f32x4.sqrt (; 139 ;) (type $FUNCSIG$VV) (param $0 v128) (result v128)
+ (func $f32x4.sqrt (; 140 ;) (type $FUNCSIG$VV) (param $0 v128) (result v128)
   (f32x4.sqrt
    (local.get $0)
   )
  )
- (func $f32x4.qfma (; 140 ;) (type $FUNCSIG$VVVV) (param $0 v128) (param $1 v128) (param $2 v128) (result v128)
+ (func $f32x4.qfma (; 141 ;) (type $FUNCSIG$VVVV) (param $0 v128) (param $1 v128) (param $2 v128) (result v128)
   (f32x4.qfma
    (local.get $0)
    (local.get $1)
    (local.get $2)
   )
  )
- (func $f32x4.qfms (; 141 ;) (type $FUNCSIG$VVVV) (param $0 v128) (param $1 v128) (param $2 v128) (result v128)
+ (func $f32x4.qfms (; 142 ;) (type $FUNCSIG$VVVV) (param $0 v128) (param $1 v128) (param $2 v128) (result v128)
   (f32x4.qfms
    (local.get $0)
    (local.get $1)
    (local.get $2)
   )
  )
- (func $f64x2.add (; 142 ;) (type $FUNCSIG$VVV) (param $0 v128) (param $1 v128) (result v128)
+ (func $f64x2.add (; 143 ;) (type $FUNCSIG$VVV) (param $0 v128) (param $1 v128) (result v128)
   (f64x2.add
    (local.get $0)
    (local.get $1)
   )
  )
- (func $f64x2.sub (; 143 ;) (type $FUNCSIG$VVV) (param $0 v128) (param $1 v128) (result v128)
+ (func $f64x2.sub (; 144 ;) (type $FUNCSIG$VVV) (param $0 v128) (param $1 v128) (result v128)
   (f64x2.sub
    (local.get $0)
    (local.get $1)
   )
  )
- (func $f64x2.mul (; 144 ;) (type $FUNCSIG$VVV) (param $0 v128) (param $1 v128) (result v128)
+ (func $f64x2.mul (; 145 ;) (type $FUNCSIG$VVV) (param $0 v128) (param $1 v128) (result v128)
   (f64x2.mul
    (local.get $0)
    (local.get $1)
   )
  )
- (func $f64x2.div (; 145 ;) (type $FUNCSIG$VVV) (param $0 v128) (param $1 v128) (result v128)
+ (func $f64x2.div (; 146 ;) (type $FUNCSIG$VVV) (param $0 v128) (param $1 v128) (result v128)
   (f64x2.div
    (local.get $0)
    (local.get $1)
   )
  )
- (func $f64x2.min (; 146 ;) (type $FUNCSIG$VVV) (param $0 v128) (param $1 v128) (result v128)
+ (func $f64x2.min (; 147 ;) (type $FUNCSIG$VVV) (param $0 v128) (param $1 v128) (result v128)
   (f64x2.min
    (local.get $0)
    (local.get $1)
   )
  )
- (func $f64x2.max (; 147 ;) (type $FUNCSIG$VVV) (param $0 v128) (param $1 v128) (result v128)
+ (func $f64x2.max (; 148 ;) (type $FUNCSIG$VVV) (param $0 v128) (param $1 v128) (result v128)
   (f64x2.max
    (local.get $0)
    (local.get $1)
   )
  )
- (func $f64x2.abs (; 148 ;) (type $FUNCSIG$VV) (param $0 v128) (result v128)
+ (func $f64x2.abs (; 149 ;) (type $FUNCSIG$VV) (param $0 v128) (result v128)
   (f64x2.abs
    (local.get $0)
   )
  )
- (func $f64x2.neg (; 149 ;) (type $FUNCSIG$VV) (param $0 v128) (result v128)
+ (func $f64x2.neg (; 150 ;) (type $FUNCSIG$VV) (param $0 v128) (result v128)
   (f64x2.neg
    (local.get $0)
   )
  )
- (func $f64x2.sqrt (; 150 ;) (type $FUNCSIG$VV) (param $0 v128) (result v128)
+ (func $f64x2.sqrt (; 151 ;) (type $FUNCSIG$VV) (param $0 v128) (result v128)
   (f64x2.sqrt
    (local.get $0)
   )
  )
- (func $f64x2.qfma (; 151 ;) (type $FUNCSIG$VVVV) (param $0 v128) (param $1 v128) (param $2 v128) (result v128)
+ (func $f64x2.qfma (; 152 ;) (type $FUNCSIG$VVVV) (param $0 v128) (param $1 v128) (param $2 v128) (result v128)
   (f64x2.qfma
    (local.get $0)
    (local.get $1)
    (local.get $2)
   )
  )
- (func $f64x2.qfms (; 152 ;) (type $FUNCSIG$VVVV) (param $0 v128) (param $1 v128) (param $2 v128) (result v128)
+ (func $f64x2.qfms (; 153 ;) (type $FUNCSIG$VVVV) (param $0 v128) (param $1 v128) (param $2 v128) (result v128)
   (f64x2.qfms
    (local.get $0)
    (local.get $1)
    (local.get $2)
   )
  )
- (func $i32x4.trunc_sat_f32x4_s (; 153 ;) (type $FUNCSIG$VV) (param $0 v128) (result v128)
+ (func $i32x4.trunc_sat_f32x4_s (; 154 ;) (type $FUNCSIG$VV) (param $0 v128) (result v128)
   (i32x4.trunc_sat_f32x4_s
    (local.get $0)
   )
  )
- (func $i32x4.trunc_sat_f32x4_u (; 154 ;) (type $FUNCSIG$VV) (param $0 v128) (result v128)
+ (func $i32x4.trunc_sat_f32x4_u (; 155 ;) (type $FUNCSIG$VV) (param $0 v128) (result v128)
   (i32x4.trunc_sat_f32x4_u
    (local.get $0)
   )
  )
- (func $i64x2.trunc_sat_f64x2_s (; 155 ;) (type $FUNCSIG$VV) (param $0 v128) (result v128)
+ (func $i64x2.trunc_sat_f64x2_s (; 156 ;) (type $FUNCSIG$VV) (param $0 v128) (result v128)
   (i64x2.trunc_sat_f64x2_s
    (local.get $0)
   )
  )
- (func $i64x2.trunc_sat_f64x2_u (; 156 ;) (type $FUNCSIG$VV) (param $0 v128) (result v128)
+ (func $i64x2.trunc_sat_f64x2_u (; 157 ;) (type $FUNCSIG$VV) (param $0 v128) (result v128)
   (i64x2.trunc_sat_f64x2_u
    (local.get $0)
   )
  )
- (func $f32x4.convert_i32x4_s (; 157 ;) (type $FUNCSIG$VV) (param $0 v128) (result v128)
+ (func $f32x4.convert_i32x4_s (; 158 ;) (type $FUNCSIG$VV) (param $0 v128) (result v128)
   (f32x4.convert_i32x4_s
    (local.get $0)
   )
  )
- (func $f32x4.convert_i32x4_u (; 158 ;) (type $FUNCSIG$VV) (param $0 v128) (result v128)
+ (func $f32x4.convert_i32x4_u (; 159 ;) (type $FUNCSIG$VV) (param $0 v128) (result v128)
   (f32x4.convert_i32x4_u
    (local.get $0)
   )
  )
- (func $f64x2.convert_i64x2_s (; 159 ;) (type $FUNCSIG$VV) (param $0 v128) (result v128)
+ (func $f64x2.convert_i64x2_s (; 160 ;) (type $FUNCSIG$VV) (param $0 v128) (result v128)
   (f64x2.convert_i64x2_s
    (local.get $0)
   )
  )
- (func $f64x2.convert_i64x2_u (; 160 ;) (type $FUNCSIG$VV) (param $0 v128) (result v128)
+ (func $f64x2.convert_i64x2_u (; 161 ;) (type $FUNCSIG$VV) (param $0 v128) (result v128)
   (f64x2.convert_i64x2_u
    (local.get $0)
   )
  )
- (func $v8x16.load_splat (; 161 ;) (type $FUNCSIG$Vi) (param $0 i32) (result v128)
+ (func $v8x16.load_splat (; 162 ;) (type $FUNCSIG$Vi) (param $0 i32) (result v128)
   (v8x16.load_splat
    (local.get $0)
   )
  )
- (func $v16x8.load_splat (; 162 ;) (type $FUNCSIG$Vi) (param $0 i32) (result v128)
+ (func $v16x8.load_splat (; 163 ;) (type $FUNCSIG$Vi) (param $0 i32) (result v128)
   (v16x8.load_splat
    (local.get $0)
   )
  )
- (func $v32x4.load_splat (; 163 ;) (type $FUNCSIG$Vi) (param $0 i32) (result v128)
+ (func $v32x4.load_splat (; 164 ;) (type $FUNCSIG$Vi) (param $0 i32) (result v128)
   (v32x4.load_splat
    (local.get $0)
   )
  )
- (func $v64x2.load_splat (; 164 ;) (type $FUNCSIG$Vi) (param $0 i32) (result v128)
+ (func $v64x2.load_splat (; 165 ;) (type $FUNCSIG$Vi) (param $0 i32) (result v128)
   (v64x2.load_splat
    (local.get $0)
   )
  )
- (func $i8x16.narrow_i16x8_s (; 165 ;) (type $FUNCSIG$VVV) (param $0 v128) (param $1 v128) (result v128)
+ (func $i8x16.narrow_i16x8_s (; 166 ;) (type $FUNCSIG$VVV) (param $0 v128) (param $1 v128) (result v128)
   (i8x16.narrow_i16x8_s
    (local.get $0)
    (local.get $1)
   )
  )
- (func $i8x16.narrow_i16x8_u (; 166 ;) (type $FUNCSIG$VVV) (param $0 v128) (param $1 v128) (result v128)
+ (func $i8x16.narrow_i16x8_u (; 167 ;) (type $FUNCSIG$VVV) (param $0 v128) (param $1 v128) (result v128)
   (i8x16.narrow_i16x8_u
    (local.get $0)
    (local.get $1)
   )
  )
- (func $i16x8.narrow_i32x4_s (; 167 ;) (type $FUNCSIG$VVV) (param $0 v128) (param $1 v128) (result v128)
+ (func $i16x8.narrow_i32x4_s (; 168 ;) (type $FUNCSIG$VVV) (param $0 v128) (param $1 v128) (result v128)
   (i16x8.narrow_i32x4_s
    (local.get $0)
    (local.get $1)
   )
  )
- (func $i16x8.narrow_i32x4_u (; 168 ;) (type $FUNCSIG$VVV) (param $0 v128) (param $1 v128) (result v128)
+ (func $i16x8.narrow_i32x4_u (; 169 ;) (type $FUNCSIG$VVV) (param $0 v128) (param $1 v128) (result v128)
   (i16x8.narrow_i32x4_u
    (local.get $0)
    (local.get $1)
   )
  )
- (func $i16x8.widen_low_i8x16_s (; 169 ;) (type $FUNCSIG$VV) (param $0 v128) (result v128)
+ (func $i16x8.widen_low_i8x16_s (; 170 ;) (type $FUNCSIG$VV) (param $0 v128) (result v128)
   (i16x8.widen_low_i8x16_s
    (local.get $0)
   )
  )
- (func $i16x8.widen_high_i8x16_s (; 170 ;) (type $FUNCSIG$VV) (param $0 v128) (result v128)
+ (func $i16x8.widen_high_i8x16_s (; 171 ;) (type $FUNCSIG$VV) (param $0 v128) (result v128)
   (i16x8.widen_high_i8x16_s
    (local.get $0)
   )
  )
- (func $i16x8.widen_low_i8x16_u (; 171 ;) (type $FUNCSIG$VV) (param $0 v128) (result v128)
+ (func $i16x8.widen_low_i8x16_u (; 172 ;) (type $FUNCSIG$VV) (param $0 v128) (result v128)
   (i16x8.widen_low_i8x16_u
    (local.get $0)
   )
  )
- (func $i16x8.widen_high_i8x16_u (; 172 ;) (type $FUNCSIG$VV) (param $0 v128) (result v128)
+ (func $i16x8.widen_high_i8x16_u (; 173 ;) (type $FUNCSIG$VV) (param $0 v128) (result v128)
   (i16x8.widen_high_i8x16_u
    (local.get $0)
   )
  )
- (func $i32x4.widen_low_i16x8_s (; 173 ;) (type $FUNCSIG$VV) (param $0 v128) (result v128)
+ (func $i32x4.widen_low_i16x8_s (; 174 ;) (type $FUNCSIG$VV) (param $0 v128) (result v128)
   (i32x4.widen_low_i16x8_s
    (local.get $0)
   )
  )
- (func $i32x4.widen_high_i16x8_s (; 174 ;) (type $FUNCSIG$VV) (param $0 v128) (result v128)
+ (func $i32x4.widen_high_i16x8_s (; 175 ;) (type $FUNCSIG$VV) (param $0 v128) (result v128)
   (i32x4.widen_high_i16x8_s
    (local.get $0)
   )
  )
- (func $i32x4.widen_low_i16x8_u (; 175 ;) (type $FUNCSIG$VV) (param $0 v128) (result v128)
+ (func $i32x4.widen_low_i16x8_u (; 176 ;) (type $FUNCSIG$VV) (param $0 v128) (result v128)
   (i32x4.widen_low_i16x8_u
    (local.get $0)
   )
  )
- (func $i32x4.widen_high_i16x8_u (; 176 ;) (type $FUNCSIG$VV) (param $0 v128) (result v128)
+ (func $i32x4.widen_high_i16x8_u (; 177 ;) (type $FUNCSIG$VV) (param $0 v128) (result v128)
   (i32x4.widen_high_i16x8_u
    (local.get $0)
   )
  )
- (func $i16x8.load8x8_u (; 177 ;) (type $FUNCSIG$Vi) (param $0 i32) (result v128)
+ (func $i16x8.load8x8_u (; 178 ;) (type $FUNCSIG$Vi) (param $0 i32) (result v128)
   (i16x8.load8x8_u
    (local.get $0)
   )
  )
- (func $i16x8.load8x8_s (; 178 ;) (type $FUNCSIG$Vi) (param $0 i32) (result v128)
+ (func $i16x8.load8x8_s (; 179 ;) (type $FUNCSIG$Vi) (param $0 i32) (result v128)
   (i16x8.load8x8_s
    (local.get $0)
   )
  )
- (func $i32x4.load16x4_s (; 179 ;) (type $FUNCSIG$Vi) (param $0 i32) (result v128)
+ (func $i32x4.load16x4_s (; 180 ;) (type $FUNCSIG$Vi) (param $0 i32) (result v128)
   (i32x4.load16x4_s
    (local.get $0)
   )
  )
- (func $i32x4.load16x4_u (; 180 ;) (type $FUNCSIG$Vi) (param $0 i32) (result v128)
+ (func $i32x4.load16x4_u (; 181 ;) (type $FUNCSIG$Vi) (param $0 i32) (result v128)
   (i32x4.load16x4_u
    (local.get $0)
   )
  )
- (func $i64x2.load32x2_s (; 181 ;) (type $FUNCSIG$Vi) (param $0 i32) (result v128)
+ (func $i64x2.load32x2_s (; 182 ;) (type $FUNCSIG$Vi) (param $0 i32) (result v128)
   (i64x2.load32x2_s
    (local.get $0)
   )
  )
- (func $i64x2.load32x2_u (; 182 ;) (type $FUNCSIG$Vi) (param $0 i32) (result v128)
+ (func $i64x2.load32x2_u (; 183 ;) (type $FUNCSIG$Vi) (param $0 i32) (result v128)
   (i64x2.load32x2_u
    (local.get $0)
   )
  )
- (func $v8x16.swizzle (; 183 ;) (type $FUNCSIG$VVV) (param $0 v128) (param $1 v128) (result v128)
+ (func $v8x16.swizzle (; 184 ;) (type $FUNCSIG$VVV) (param $0 v128) (param $1 v128) (result v128)
   (v8x16.swizzle
    (local.get $0)
    (local.get $1)
diff --git a/test/simd.wast.fromBinary b/test/simd.wast.fromBinary
index 5b17cdf1b..6aa5637c3 100644
--- a/test/simd.wast.fromBinary
+++ b/test/simd.wast.fromBinary
@@ -713,336 +713,342 @@
    (local.get $1)
   )
  )
- (func $i64x2.neg (; 123 ;) (type $14) (param $0 v128) (result v128)
+ (func $i32x4.dot_i16x8_s (; 123 ;) (type $3) (param $0 v128) (param $1 v128) (result v128)
+  (i32x4.dot_i16x8_s
+   (local.get $0)
+   (local.get $1)
+  )
+ )
+ (func $i64x2.neg (; 124 ;) (type $14) (param $0 v128) (result v128)
   (i64x2.neg
    (local.get $0)
   )
  )
- (func $i64x2.any_true (; 124 ;) (type $4) (param $0 v128) (result i32)
+ (func $i64x2.any_true (; 125 ;) (type $4) (param $0 v128) (result i32)
   (i64x2.any_true
    (local.get $0)
   )
  )
- (func $i64x2.all_true (; 125 ;) (type $4) (param $0 v128) (result i32)
+ (func $i64x2.all_true (; 126 ;) (type $4) (param $0 v128) (result i32)
   (i64x2.all_true
    (local.get $0)
   )
  )
- (func $i64x2.shl (; 126 ;) (type $5) (param $0 v128) (param $1 i32) (result v128)
+ (func $i64x2.shl (; 127 ;) (type $5) (param $0 v128) (param $1 i32) (result v128)
   (i64x2.shl
    (local.get $0)
    (local.get $1)
   )
  )
- (func $i64x2.shr_s (; 127 ;) (type $5) (param $0 v128) (param $1 i32) (result v128)
+ (func $i64x2.shr_s (; 128 ;) (type $5) (param $0 v128) (param $1 i32) (result v128)
   (i64x2.shr_s
    (local.get $0)
    (local.get $1)
   )
  )
- (func $i64x2.shr_u (; 128 ;) (type $5) (param $0 v128) (param $1 i32) (result v128)
+ (func $i64x2.shr_u (; 129 ;) (type $5) (param $0 v128) (param $1 i32) (result v128)
   (i64x2.shr_u
    (local.get $0)
    (local.get $1)
   )
  )
- (func $i64x2.add (; 129 ;) (type $3) (param $0 v128) (param $1 v128) (result v128)
+ (func $i64x2.add (; 130 ;) (type $3) (param $0 v128) (param $1 v128) (result v128)
   (i64x2.add
    (local.get $0)
    (local.get $1)
   )
  )
- (func $i64x2.sub (; 130 ;) (type $3) (param $0 v128) (param $1 v128) (result v128)
+ (func $i64x2.sub (; 131 ;) (type $3) (param $0 v128) (param $1 v128) (result v128)
   (i64x2.sub
    (local.get $0)
    (local.get $1)
   )
  )
- (func $f32x4.add (; 131 ;) (type $3) (param $0 v128) (param $1 v128) (result v128)
+ (func $f32x4.add (; 132 ;) (type $3) (param $0 v128) (param $1 v128) (result v128)
   (f32x4.add
    (local.get $0)
    (local.get $1)
   )
  )
- (func $f32x4.sub (; 132 ;) (type $3) (param $0 v128) (param $1 v128) (result v128)
+ (func $f32x4.sub (; 133 ;) (type $3) (param $0 v128) (param $1 v128) (result v128)
   (f32x4.sub
    (local.get $0)
    (local.get $1)
   )
  )
- (func $f32x4.mul (; 133 ;) (type $3) (param $0 v128) (param $1 v128) (result v128)
+ (func $f32x4.mul (; 134 ;) (type $3) (param $0 v128) (param $1 v128) (result v128)
   (f32x4.mul
    (local.get $0)
    (local.get $1)
   )
  )
- (func $f32x4.div (; 134 ;) (type $3) (param $0 v128) (param $1 v128) (result v128)
+ (func $f32x4.div (; 135 ;) (type $3) (param $0 v128) (param $1 v128) (result v128)
   (f32x4.div
    (local.get $0)
    (local.get $1)
   )
  )
- (func $f32x4.min (; 135 ;) (type $3) (param $0 v128) (param $1 v128) (result v128)
+ (func $f32x4.min (; 136 ;) (type $3) (param $0 v128) (param $1 v128) (result v128)
   (f32x4.min
    (local.get $0)
    (local.get $1)
   )
  )
- (func $f32x4.max (; 136 ;) (type $3) (param $0 v128) (param $1 v128) (result v128)
+ (func $f32x4.max (; 137 ;) (type $3) (param $0 v128) (param $1 v128) (result v128)
   (f32x4.max
    (local.get $0)
    (local.get $1)
   )
  )
- (func $f32x4.abs (; 137 ;) (type $14) (param $0 v128) (result v128)
+ (func $f32x4.abs (; 138 ;) (type $14) (param $0 v128) (result v128)
   (f32x4.abs
    (local.get $0)
   )
  )
- (func $f32x4.neg (; 138 ;) (type $14) (param $0 v128) (result v128)
+ (func $f32x4.neg (; 139 ;) (type $14) (param $0 v128) (result v128)
   (f32x4.neg
    (local.get $0)
   )
  )
- (func $f32x4.sqrt (; 139 ;) (type $14) (param $0 v128) (result v128)
+ (func $f32x4.sqrt (; 140 ;) (type $14) (param $0 v128) (result v128)
   (f32x4.sqrt
    (local.get $0)
   )
  )
- (func $f32x4.qfma (; 140 ;) (type $15) (param $0 v128) (param $1 v128) (param $2 v128) (result v128)
+ (func $f32x4.qfma (; 141 ;) (type $15) (param $0 v128) (param $1 v128) (param $2 v128) (result v128)
   (f32x4.qfma
    (local.get $0)
    (local.get $1)
    (local.get $2)
   )
  )
- (func $f32x4.qfms (; 141 ;) (type $15) (param $0 v128) (param $1 v128) (param $2 v128) (result v128)
+ (func $f32x4.qfms (; 142 ;) (type $15) (param $0 v128) (param $1 v128) (param $2 v128) (result v128)
   (f32x4.qfms
    (local.get $0)
    (local.get $1)
    (local.get $2)
   )
  )
- (func $f64x2.add (; 142 ;) (type $3) (param $0 v128) (param $1 v128) (result v128)
+ (func $f64x2.add (; 143 ;) (type $3) (param $0 v128) (param $1 v128) (result v128)
   (f64x2.add
    (local.get $0)
    (local.get $1)
   )
  )
- (func $f64x2.sub (; 143 ;) (type $3) (param $0 v128) (param $1 v128) (result v128)
+ (func $f64x2.sub (; 144 ;) (type $3) (param $0 v128) (param $1 v128) (result v128)
   (f64x2.sub
    (local.get $0)
    (local.get $1)
   )
  )
- (func $f64x2.mul (; 144 ;) (type $3) (param $0 v128) (param $1 v128) (result v128)
+ (func $f64x2.mul (; 145 ;) (type $3) (param $0 v128) (param $1 v128) (result v128)
   (f64x2.mul
    (local.get $0)
    (local.get $1)
   )
  )
- (func $f64x2.div (; 145 ;) (type $3) (param $0 v128) (param $1 v128) (result v128)
+ (func $f64x2.div (; 146 ;) (type $3) (param $0 v128) (param $1 v128) (result v128)
   (f64x2.div
    (local.get $0)
    (local.get $1)
   )
  )
- (func $f64x2.min (; 146 ;) (type $3) (param $0 v128) (param $1 v128) (result v128)
+ (func $f64x2.min (; 147 ;) (type $3) (param $0 v128) (param $1 v128) (result v128)
   (f64x2.min
    (local.get $0)
    (local.get $1)
   )
  )
- (func $f64x2.max (; 147 ;) (type $3) (param $0 v128) (param $1 v128) (result v128)
+ (func $f64x2.max (; 148 ;) (type $3) (param $0 v128) (param $1 v128) (result v128)
   (f64x2.max
    (local.get $0)
    (local.get $1)
   )
  )
- (func $f64x2.abs (; 148 ;) (type $14) (param $0 v128) (result v128)
+ (func $f64x2.abs (; 149 ;) (type $14) (param $0 v128) (result v128)
   (f64x2.abs
    (local.get $0)
   )
  )
- (func $f64x2.neg (; 149 ;) (type $14) (param $0 v128) (result v128)
+ (func $f64x2.neg (; 150 ;) (type $14) (param $0 v128) (result v128)
   (f64x2.neg
    (local.get $0)
   )
  )
- (func $f64x2.sqrt (; 150 ;) (type $14) (param $0 v128) (result v128)
+ (func $f64x2.sqrt (; 151 ;) (type $14) (param $0 v128) (result v128)
   (f64x2.sqrt
    (local.get $0)
   )
  )
- (func $f64x2.qfma (; 151 ;) (type $15) (param $0 v128) (param $1 v128) (param $2 v128) (result v128)
+ (func $f64x2.qfma (; 152 ;) (type $15) (param $0 v128) (param $1 v128) (param $2 v128) (result v128)
   (f64x2.qfma
    (local.get $0)
    (local.get $1)
    (local.get $2)
   )
  )
- (func $f64x2.qfms (; 152 ;) (type $15) (param $0 v128) (param $1 v128) (param $2 v128) (result v128)
+ (func $f64x2.qfms (; 153 ;) (type $15) (param $0 v128) (param $1 v128) (param $2 v128) (result v128)
   (f64x2.qfms
    (local.get $0)
    (local.get $1)
    (local.get $2)
   )
  )
- (func $i32x4.trunc_sat_f32x4_s (; 153 ;) (type $14) (param $0 v128) (result v128)
+ (func $i32x4.trunc_sat_f32x4_s (; 154 ;) (type $14) (param $0 v128) (result v128)
   (i32x4.trunc_sat_f32x4_s
    (local.get $0)
   )
  )
- (func $i32x4.trunc_sat_f32x4_u (; 154 ;) (type $14) (param $0 v128) (result v128)
+ (func $i32x4.trunc_sat_f32x4_u (; 155 ;) (type $14) (param $0 v128) (result v128)
   (i32x4.trunc_sat_f32x4_u
    (local.get $0)
   )
  )
- (func $i64x2.trunc_sat_f64x2_s (; 155 ;) (type $14) (param $0 v128) (result v128)
+ (func $i64x2.trunc_sat_f64x2_s (; 156 ;) (type $14) (param $0 v128) (result v128)
   (i64x2.trunc_sat_f64x2_s
    (local.get $0)
   )
  )
- (func $i64x2.trunc_sat_f64x2_u (; 156 ;) (type $14) (param $0 v128) (result v128)
+ (func $i64x2.trunc_sat_f64x2_u (; 157 ;) (type $14) (param $0 v128) (result v128)
   (i64x2.trunc_sat_f64x2_u
    (local.get $0)
   )
  )
- (func $f32x4.convert_i32x4_s (; 157 ;) (type $14) (param $0 v128) (result v128)
+ (func $f32x4.convert_i32x4_s (; 158 ;) (type $14) (param $0 v128) (result v128)
   (f32x4.convert_i32x4_s
    (local.get $0)
   )
  )
- (func $f32x4.convert_i32x4_u (; 158 ;) (type $14) (param $0 v128) (result v128)
+ (func $f32x4.convert_i32x4_u (; 159 ;) (type $14) (param $0 v128) (result v128)
   (f32x4.convert_i32x4_u
    (local.get $0)
   )
  )
- (func $f64x2.convert_i64x2_s (; 159 ;) (type $14) (param $0 v128) (result v128)
+ (func $f64x2.convert_i64x2_s (; 160 ;) (type $14) (param $0 v128) (result v128)
   (f64x2.convert_i64x2_s
    (local.get $0)
   )
  )
- (func $f64x2.convert_i64x2_u (; 160 ;) (type $14) (param $0 v128) (result v128)
+ (func $f64x2.convert_i64x2_u (; 161 ;) (type $14) (param $0 v128) (result v128)
   (f64x2.convert_i64x2_u
    (local.get $0)
   )
  )
- (func $v8x16.load_splat (; 161 ;) (type $0) (param $0 i32) (result v128)
+ (func $v8x16.load_splat (; 162 ;) (type $0) (param $0 i32) (result v128)
   (v8x16.load_splat
    (local.get $0)
   )
  )
- (func $v16x8.load_splat (; 162 ;) (type $0) (param $0 i32) (result v128)
+ (func $v16x8.load_splat (; 163 ;) (type $0) (param $0 i32) (result v128)
   (v16x8.load_splat
    (local.get $0)
   )
  )
- (func $v32x4.load_splat (; 163 ;) (type $0) (param $0 i32) (result v128)
+ (func $v32x4.load_splat (; 164 ;) (type $0) (param $0 i32) (result v128)
   (v32x4.load_splat
    (local.get $0)
   )
  )
- (func $v64x2.load_splat (; 164 ;) (type $0) (param $0 i32) (result v128)
+ (func $v64x2.load_splat (; 165 ;) (type $0) (param $0 i32) (result v128)
   (v64x2.load_splat
    (local.get $0)
   )
  )
- (func $i8x16.narrow_i16x8_s (; 165 ;) (type $3) (param $0 v128) (param $1 v128) (result v128)
+ (func $i8x16.narrow_i16x8_s (; 166 ;) (type $3) (param $0 v128) (param $1 v128) (result v128)
   (i8x16.narrow_i16x8_s
    (local.get $0)
    (local.get $1)
   )
  )
- (func $i8x16.narrow_i16x8_u (; 166 ;) (type $3) (param $0 v128) (param $1 v128) (result v128)
+ (func $i8x16.narrow_i16x8_u (; 167 ;) (type $3) (param $0 v128) (param $1 v128) (result v128)
   (i8x16.narrow_i16x8_u
    (local.get $0)
    (local.get $1)
   )
  )
- (func $i16x8.narrow_i32x4_s (; 167 ;) (type $3) (param $0 v128) (param $1 v128) (result v128)
+ (func $i16x8.narrow_i32x4_s (; 168 ;) (type $3) (param $0 v128) (param $1 v128) (result v128)
   (i16x8.narrow_i32x4_s
    (local.get $0)
    (local.get $1)
   )
  )
- (func $i16x8.narrow_i32x4_u (; 168 ;) (type $3) (param $0 v128) (param $1 v128) (result v128)
+ (func $i16x8.narrow_i32x4_u (; 169 ;) (type $3) (param $0 v128) (param $1 v128) (result v128)
   (i16x8.narrow_i32x4_u
    (local.get $0)
    (local.get $1)
   )
  )
- (func $i16x8.widen_low_i8x16_s (; 169 ;) (type $14) (param $0 v128) (result v128)
+ (func $i16x8.widen_low_i8x16_s (; 170 ;) (type $14) (param $0 v128) (result v128)
   (i16x8.widen_low_i8x16_s
    (local.get $0)
   )
  )
- (func $i16x8.widen_high_i8x16_s (; 170 ;) (type $14) (param $0 v128) (result v128)
+ (func $i16x8.widen_high_i8x16_s (; 171 ;) (type $14) (param $0 v128) (result v128)
   (i16x8.widen_high_i8x16_s
    (local.get $0)
   )
  )
- (func $i16x8.widen_low_i8x16_u (; 171 ;) (type $14) (param $0 v128) (result v128)
+ (func $i16x8.widen_low_i8x16_u (; 172 ;) (type $14) (param $0 v128) (result v128)
   (i16x8.widen_low_i8x16_u
    (local.get $0)
   )
  )
- (func $i16x8.widen_high_i8x16_u (; 172 ;) (type $14) (param $0 v128) (result v128)
+ (func $i16x8.widen_high_i8x16_u (; 173 ;) (type $14) (param $0 v128) (result v128)
   (i16x8.widen_high_i8x16_u
    (local.get $0)
   )
  )
- (func $i32x4.widen_low_i16x8_s (; 173 ;) (type $14) (param $0 v128) (result v128)
+ (func $i32x4.widen_low_i16x8_s (; 174 ;) (type $14) (param $0 v128) (result v128)
   (i32x4.widen_low_i16x8_s
    (local.get $0)
   )
  )
- (func $i32x4.widen_high_i16x8_s (; 174 ;) (type $14) (param $0 v128) (result v128)
+ (func $i32x4.widen_high_i16x8_s (; 175 ;) (type $14) (param $0 v128) (result v128)
   (i32x4.widen_high_i16x8_s
    (local.get $0)
   )
  )
- (func $i32x4.widen_low_i16x8_u (; 175 ;) (type $14) (param $0 v128) (result v128)
+ (func $i32x4.widen_low_i16x8_u (; 176 ;) (type $14) (param $0 v128) (result v128)
   (i32x4.widen_low_i16x8_u
    (local.get $0)
   )
  )
- (func $i32x4.widen_high_i16x8_u (; 176 ;) (type $14) (param $0 v128) (result v128)
+ (func $i32x4.widen_high_i16x8_u (; 177 ;) (type $14) (param $0 v128) (result v128)
   (i32x4.widen_high_i16x8_u
    (local.get $0)
   )
  )
- (func $i16x8.load8x8_u (; 177 ;) (type $0) (param $0 i32) (result v128)
+ (func $i16x8.load8x8_u (; 178 ;) (type $0) (param $0 i32) (result v128)
   (i16x8.load8x8_u
    (local.get $0)
   )
  )
- (func $i16x8.load8x8_s (; 178 ;) (type $0) (param $0 i32) (result v128)
+ (func $i16x8.load8x8_s (; 179 ;) (type $0) (param $0 i32) (result v128)
   (i16x8.load8x8_s
    (local.get $0)
   )
  )
- (func $i32x4.load16x4_s (; 179 ;) (type $0) (param $0 i32) (result v128)
+ (func $i32x4.load16x4_s (; 180 ;) (type $0) (param $0 i32) (result v128)
   (i32x4.load16x4_s
    (local.get $0)
   )
  )
- (func $i32x4.load16x4_u (; 180 ;) (type $0) (param $0 i32) (result v128)
+ (func $i32x4.load16x4_u (; 181 ;) (type $0) (param $0 i32) (result v128)
   (i32x4.load16x4_u
    (local.get $0)
   )
  )
- (func $i64x2.load32x2_s (; 181 ;) (type $0) (param $0 i32) (result v128)
+ (func $i64x2.load32x2_s (; 182 ;) (type $0) (param $0 i32) (result v128)
   (i64x2.load32x2_s
    (local.get $0)
   )
  )
- (func $i64x2.load32x2_u (; 182 ;) (type $0) (param $0 i32) (result v128)
+ (func $i64x2.load32x2_u (; 183 ;) (type $0) (param $0 i32) (result v128)
   (i64x2.load32x2_u
    (local.get $0)
   )
  )
- (func $v8x16.swizzle (; 183 ;) (type $3) (param $0 v128) (param $1 v128) (result v128)
+ (func $v8x16.swizzle (; 184 ;) (type $3) (param $0 v128) (param $1 v128) (result v128)
   (v8x16.swizzle
    (local.get $0)
    (local.get $1)
diff --git a/test/simd.wast.fromBinary.noDebugInfo b/test/simd.wast.fromBinary.noDebugInfo
index 767dc51ed..3cacec11d 100644
--- a/test/simd.wast.fromBinary.noDebugInfo
+++ b/test/simd.wast.fromBinary.noDebugInfo
@@ -713,336 +713,342 @@
    (local.get $1)
   )
  )
- (func $123 (; 123 ;) (type $14) (param $0 v128) (result v128)
+ (func $123 (; 123 ;) (type $3) (param $0 v128) (param $1 v128) (result v128)
+  (i32x4.dot_i16x8_s
+   (local.get $0)
+   (local.get $1)
+  )
+ )
+ (func $124 (; 124 ;) (type $14) (param $0 v128) (result v128)
   (i64x2.neg
    (local.get $0)
   )
  )
- (func $124 (; 124 ;) (type $4) (param $0 v128) (result i32)
+ (func $125 (; 125 ;) (type $4) (param $0 v128) (result i32)
   (i64x2.any_true
    (local.get $0)
   )
  )
- (func $125 (; 125 ;) (type $4) (param $0 v128) (result i32)
+ (func $126 (; 126 ;) (type $4) (param $0 v128) (result i32)
   (i64x2.all_true
    (local.get $0)
   )
  )
- (func $126 (; 126 ;) (type $5) (param $0 v128) (param $1 i32) (result v128)
+ (func $127 (; 127 ;) (type $5) (param $0 v128) (param $1 i32) (result v128)
   (i64x2.shl
    (local.get $0)
    (local.get $1)
   )
  )
- (func $127 (; 127 ;) (type $5) (param $0 v128) (param $1 i32) (result v128)
+ (func $128 (; 128 ;) (type $5) (param $0 v128) (param $1 i32) (result v128)
   (i64x2.shr_s
    (local.get $0)
    (local.get $1)
   )
  )
- (func $128 (; 128 ;) (type $5) (param $0 v128) (param $1 i32) (result v128)
+ (func $129 (; 129 ;) (type $5) (param $0 v128) (param $1 i32) (result v128)
   (i64x2.shr_u
    (local.get $0)
    (local.get $1)
   )
  )
- (func $129 (; 129 ;) (type $3) (param $0 v128) (param $1 v128) (result v128)
+ (func $130 (; 130 ;) (type $3) (param $0 v128) (param $1 v128) (result v128)
   (i64x2.add
    (local.get $0)
    (local.get $1)
   )
  )
- (func $130 (; 130 ;) (type $3) (param $0 v128) (param $1 v128) (result v128)
+ (func $131 (; 131 ;) (type $3) (param $0 v128) (param $1 v128) (result v128)
   (i64x2.sub
    (local.get $0)
    (local.get $1)
   )
  )
- (func $131 (; 131 ;) (type $3) (param $0 v128) (param $1 v128) (result v128)
+ (func $132 (; 132 ;) (type $3) (param $0 v128) (param $1 v128) (result v128)
   (f32x4.add
    (local.get $0)
    (local.get $1)
   )
  )
- (func $132 (; 132 ;) (type $3) (param $0 v128) (param $1 v128) (result v128)
+ (func $133 (; 133 ;) (type $3) (param $0 v128) (param $1 v128) (result v128)
   (f32x4.sub
    (local.get $0)
    (local.get $1)
   )
  )
- (func $133 (; 133 ;) (type $3) (param $0 v128) (param $1 v128) (result v128)
+ (func $134 (; 134 ;) (type $3) (param $0 v128) (param $1 v128) (result v128)
   (f32x4.mul
    (local.get $0)
    (local.get $1)
   )
  )
- (func $134 (; 134 ;) (type $3) (param $0 v128) (param $1 v128) (result v128)
+ (func $135 (; 135 ;) (type $3) (param $0 v128) (param $1 v128) (result v128)
   (f32x4.div
    (local.get $0)
    (local.get $1)
   )
  )
- (func $135 (; 135 ;) (type $3) (param $0 v128) (param $1 v128) (result v128)
+ (func $136 (; 136 ;) (type $3) (param $0 v128) (param $1 v128) (result v128)
   (f32x4.min
    (local.get $0)
    (local.get $1)
   )
  )
- (func $136 (; 136 ;) (type $3) (param $0 v128) (param $1 v128) (result v128)
+ (func $137 (; 137 ;) (type $3) (param $0 v128) (param $1 v128) (result v128)
   (f32x4.max
    (local.get $0)
    (local.get $1)
   )
  )
- (func $137 (; 137 ;) (type $14) (param $0 v128) (result v128)
+ (func $138 (; 138 ;) (type $14) (param $0 v128) (result v128)
   (f32x4.abs
    (local.get $0)
   )
  )
- (func $138 (; 138 ;) (type $14) (param $0 v128) (result v128)
+ (func $139 (; 139 ;) (type $14) (param $0 v128) (result v128)
   (f32x4.neg
    (local.get $0)
   )
  )
- (func $139 (; 139 ;) (type $14) (param $0 v128) (result v128)
+ (func $140 (; 140 ;) (type $14) (param $0 v128) (result v128)
   (f32x4.sqrt
    (local.get $0)
   )
  )
- (func $140 (; 140 ;) (type $15) (param $0 v128) (param $1 v128) (param $2 v128) (result v128)
+ (func $141 (; 141 ;) (type $15) (param $0 v128) (param $1 v128) (param $2 v128) (result v128)
   (f32x4.qfma
    (local.get $0)
    (local.get $1)
    (local.get $2)
   )
  )
- (func $141 (; 141 ;) (type $15) (param $0 v128) (param $1 v128) (param $2 v128) (result v128)
+ (func $142 (; 142 ;) (type $15) (param $0 v128) (param $1 v128) (param $2 v128) (result v128)
   (f32x4.qfms
    (local.get $0)
    (local.get $1)
    (local.get $2)
   )
  )
- (func $142 (; 142 ;) (type $3) (param $0 v128) (param $1 v128) (result v128)
+ (func $143 (; 143 ;) (type $3) (param $0 v128) (param $1 v128) (result v128)
   (f64x2.add
    (local.get $0)
    (local.get $1)
   )
  )
- (func $143 (; 143 ;) (type $3) (param $0 v128) (param $1 v128) (result v128)
+ (func $144 (; 144 ;) (type $3) (param $0 v128) (param $1 v128) (result v128)
   (f64x2.sub
    (local.get $0)
    (local.get $1)
   )
  )
- (func $144 (; 144 ;) (type $3) (param $0 v128) (param $1 v128) (result v128)
+ (func $145 (; 145 ;) (type $3) (param $0 v128) (param $1 v128) (result v128)
   (f64x2.mul
    (local.get $0)
    (local.get $1)
   )
  )
- (func $145 (; 145 ;) (type $3) (param $0 v128) (param $1 v128) (result v128)
+ (func $146 (; 146 ;) (type $3) (param $0 v128) (param $1 v128) (result v128)
   (f64x2.div
    (local.get $0)
    (local.get $1)
   )
  )
- (func $146 (; 146 ;) (type $3) (param $0 v128) (param $1 v128) (result v128)
+ (func $147 (; 147 ;) (type $3) (param $0 v128) (param $1 v128) (result v128)
   (f64x2.min
    (local.get $0)
    (local.get $1)
   )
  )
- (func $147 (; 147 ;) (type $3) (param $0 v128) (param $1 v128) (result v128)
+ (func $148 (; 148 ;) (type $3) (param $0 v128) (param $1 v128) (result v128)
   (f64x2.max
    (local.get $0)
    (local.get $1)
   )
  )
- (func $148 (; 148 ;) (type $14) (param $0 v128) (result v128)
+ (func $149 (; 149 ;) (type $14) (param $0 v128) (result v128)
   (f64x2.abs
    (local.get $0)
   )
  )
- (func $149 (; 149 ;) (type $14) (param $0 v128) (result v128)
+ (func $150 (; 150 ;) (type $14) (param $0 v128) (result v128)
   (f64x2.neg
    (local.get $0)
   )
  )
- (func $150 (; 150 ;) (type $14) (param $0 v128) (result v128)
+ (func $151 (; 151 ;) (type $14) (param $0 v128) (result v128)
   (f64x2.sqrt
    (local.get $0)
   )
  )
- (func $151 (; 151 ;) (type $15) (param $0 v128) (param $1 v128) (param $2 v128) (result v128)
+ (func $152 (; 152 ;) (type $15) (param $0 v128) (param $1 v128) (param $2 v128) (result v128)
   (f64x2.qfma
    (local.get $0)
    (local.get $1)
    (local.get $2)
   )
  )
- (func $152 (; 152 ;) (type $15) (param $0 v128) (param $1 v128) (param $2 v128) (result v128)
+ (func $153 (; 153 ;) (type $15) (param $0 v128) (param $1 v128) (param $2 v128) (result v128)
   (f64x2.qfms
    (local.get $0)
    (local.get $1)
    (local.get $2)
   )
  )
- (func $153 (; 153 ;) (type $14) (param $0 v128) (result v128)
+ (func $154 (; 154 ;) (type $14) (param $0 v128) (result v128)
   (i32x4.trunc_sat_f32x4_s
    (local.get $0)
   )
  )
- (func $154 (; 154 ;) (type $14) (param $0 v128) (result v128)
+ (func $155 (; 155 ;) (type $14) (param $0 v128) (result v128)
   (i32x4.trunc_sat_f32x4_u
    (local.get $0)
   )
  )
- (func $155 (; 155 ;) (type $14) (param $0 v128) (result v128)
+ (func $156 (; 156 ;) (type $14) (param $0 v128) (result v128)
   (i64x2.trunc_sat_f64x2_s
    (local.get $0)
   )
  )
- (func $156 (; 156 ;) (type $14) (param $0 v128) (result v128)
+ (func $157 (; 157 ;) (type $14) (param $0 v128) (result v128)
   (i64x2.trunc_sat_f64x2_u
    (local.get $0)
   )
  )
- (func $157 (; 157 ;) (type $14) (param $0 v128) (result v128)
+ (func $158 (; 158 ;) (type $14) (param $0 v128) (result v128)
   (f32x4.convert_i32x4_s
    (local.get $0)
   )
  )
- (func $158 (; 158 ;) (type $14) (param $0 v128) (result v128)
+ (func $159 (; 159 ;) (type $14) (param $0 v128) (result v128)
   (f32x4.convert_i32x4_u
    (local.get $0)
   )
  )
- (func $159 (; 159 ;) (type $14) (param $0 v128) (result v128)
+ (func $160 (; 160 ;) (type $14) (param $0 v128) (result v128)
   (f64x2.convert_i64x2_s
    (local.get $0)
   )
  )
- (func $160 (; 160 ;) (type $14) (param $0 v128) (result v128)
+ (func $161 (; 161 ;) (type $14) (param $0 v128) (result v128)
   (f64x2.convert_i64x2_u
    (local.get $0)
   )
  )
- (func $161 (; 161 ;) (type $0) (param $0 i32) (result v128)
+ (func $162 (; 162 ;) (type $0) (param $0 i32) (result v128)
   (v8x16.load_splat
    (local.get $0)
   )
  )
- (func $162 (; 162 ;) (type $0) (param $0 i32) (result v128)
+ (func $163 (; 163 ;) (type $0) (param $0 i32) (result v128)
   (v16x8.load_splat
    (local.get $0)
   )
  )
- (func $163 (; 163 ;) (type $0) (param $0 i32) (result v128)
+ (func $164 (; 164 ;) (type $0) (param $0 i32) (result v128)
   (v32x4.load_splat
    (local.get $0)
   )
  )
- (func $164 (; 164 ;) (type $0) (param $0 i32) (result v128)
+ (func $165 (; 165 ;) (type $0) (param $0 i32) (result v128)
   (v64x2.load_splat
    (local.get $0)
   )
  )
- (func $165 (; 165 ;) (type $3) (param $0 v128) (param $1 v128) (result v128)
+ (func $166 (; 166 ;) (type $3) (param $0 v128) (param $1 v128) (result v128)
   (i8x16.narrow_i16x8_s
    (local.get $0)
    (local.get $1)
   )
  )
- (func $166 (; 166 ;) (type $3) (param $0 v128) (param $1 v128) (result v128)
+ (func $167 (; 167 ;) (type $3) (param $0 v128) (param $1 v128) (result v128)
   (i8x16.narrow_i16x8_u
    (local.get $0)
    (local.get $1)
   )
  )
- (func $167 (; 167 ;) (type $3) (param $0 v128) (param $1 v128) (result v128)
+ (func $168 (; 168 ;) (type $3) (param $0 v128) (param $1 v128) (result v128)
   (i16x8.narrow_i32x4_s
    (local.get $0)
    (local.get $1)
   )
  )
- (func $168 (; 168 ;) (type $3) (param $0 v128) (param $1 v128) (result v128)
+ (func $169 (; 169 ;) (type $3) (param $0 v128) (param $1 v128) (result v128)
   (i16x8.narrow_i32x4_u
    (local.get $0)
    (local.get $1)
   )
  )
- (func $169 (; 169 ;) (type $14) (param $0 v128) (result v128)
+ (func $170 (; 170 ;) (type $14) (param $0 v128) (result v128)
   (i16x8.widen_low_i8x16_s
    (local.get $0)
   )
  )
- (func $170 (; 170 ;) (type $14) (param $0 v128) (result v128)
+ (func $171 (; 171 ;) (type $14) (param $0 v128) (result v128)
   (i16x8.widen_high_i8x16_s
    (local.get $0)
   )
  )
- (func $171 (; 171 ;) (type $14) (param $0 v128) (result v128)
+ (func $172 (; 172 ;) (type $14) (param $0 v128) (result v128)
   (i16x8.widen_low_i8x16_u
    (local.get $0)
   )
  )
- (func $172 (; 172 ;) (type $14) (param $0 v128) (result v128)
+ (func $173 (; 173 ;) (type $14) (param $0 v128) (result v128)
   (i16x8.widen_high_i8x16_u
    (local.get $0)
   )
  )
- (func $173 (; 173 ;) (type $14) (param $0 v128) (result v128)
+ (func $174 (; 174 ;) (type $14) (param $0 v128) (result v128)
   (i32x4.widen_low_i16x8_s
    (local.get $0)
   )
  )
- (func $174 (; 174 ;) (type $14) (param $0 v128) (result v128)
+ (func $175 (; 175 ;) (type $14) (param $0 v128) (result v128)
   (i32x4.widen_high_i16x8_s
    (local.get $0)
   )
  )
- (func $175 (; 175 ;) (type $14) (param $0 v128) (result v128)
+ (func $176 (; 176 ;) (type $14) (param $0 v128) (result v128)
   (i32x4.widen_low_i16x8_u
    (local.get $0)
   )
  )
- (func $176 (; 176 ;) (type $14) (param $0 v128) (result v128)
+ (func $177 (; 177 ;) (type $14) (param $0 v128) (result v128)
   (i32x4.widen_high_i16x8_u
    (local.get $0)
   )
  )
- (func $177 (; 177 ;) (type $0) (param $0 i32) (result v128)
+ (func $178 (; 178 ;) (type $0) (param $0 i32) (result v128)
   (i16x8.load8x8_u
    (local.get $0)
   )
  )
- (func $178 (; 178 ;) (type $0) (param $0 i32) (result v128)
+ (func $179 (; 179 ;) (type $0) (param $0 i32) (result v128)
   (i16x8.load8x8_s
    (local.get $0)
   )
  )
- (func $179 (; 179 ;) (type $0) (param $0 i32) (result v128)
+ (func $180 (; 180 ;) (type $0) (param $0 i32) (result v128)
   (i32x4.load16x4_s
    (local.get $0)
   )
  )
- (func $180 (; 180 ;) (type $0) (param $0 i32) (result v128)
+ (func $181 (; 181 ;) (type $0) (param $0 i32) (result v128)
   (i32x4.load16x4_u
    (local.get $0)
   )
  )
- (func $181 (; 181 ;) (type $0) (param $0 i32) (result v128)
+ (func $182 (; 182 ;) (type $0) (param $0 i32) (result v128)
   (i64x2.load32x2_s
    (local.get $0)
   )
  )
- (func $182 (; 182 ;) (type $0) (param $0 i32) (result v128)
+ (func $183 (; 183 ;) (type $0) (param $0 i32) (result v128)
   (i64x2.load32x2_u
    (local.get $0)
   )
  )
- (func $183 (; 183 ;) (type $3) (param $0 v128) (param $1 v128) (result v128)
+ (func $184 (; 184 ;) (type $3) (param $0 v128) (param $1 v128) (result v128)
   (v8x16.swizzle
    (local.get $0)
    (local.get $1)
diff --git a/test/spec/simd.wast b/test/spec/simd.wast
index 8eacf76aa..0df98f123 100644
--- a/test/spec/simd.wast
+++ b/test/spec/simd.wast
@@ -150,6 +150,7 @@
  (func (export "i32x4.min_u") (param $0 v128) (param $1 v128) (result v128) (i32x4.min_u (local.get $0) (local.get $1)))
  (func (export "i32x4.max_s") (param $0 v128) (param $1 v128) (result v128) (i32x4.max_s (local.get $0) (local.get $1)))
  (func (export "i32x4.max_u") (param $0 v128) (param $1 v128) (result v128) (i32x4.max_u (local.get $0) (local.get $1)))
+ (func (export "i32x4.dot_i16x8_s") (param $0 v128) (param $1 v128) (result v128) (i32x4.dot_i16x8_s (local.get $0) (local.get $1)))
  (func (export "i64x2.neg") (param $0 v128) (result v128) (i64x2.neg (local.get $0)))
  (func (export "i64x2.any_true") (param $0 v128) (result i32) (i64x2.any_true (local.get $0)))
  (func (export "i64x2.all_true") (param $0 v128) (result i32) (i64x2.all_true (local.get $0)))
@@ -725,6 +726,10 @@
   (invoke "i32x4.max_u" (v128.const i32x4 0 0x80000001 42 0xc0000000) (v128.const i32x4 0xffffffff 42 0 0xb0000000))
   (v128.const i32x4 0xffffffff 0x80000001 42 0xc0000000)
 )
+(assert_return
+  (invoke "i32x4.dot_i16x8_s" (v128.const i32x4 0 1 2 3 4 5 6 7) (v128.const i32x4 -1 2 -3 4 5 6 -7 -8))
+  (v128.const i32x4 2 6 50 -98)
+)
 
 ;; i64x2 arithmetic
 (assert_return (invoke "i64x2.neg" (v128.const i64x2 0x8000000000000000 42)) (v128.const i64x2 0x8000000000000000 -42))