Tuple operations in C and JS APIs (#2711)

Adds functions for creating and inspecting tuple.make and
tuple.extract expressions in the C and JS APIs.

8 files changed, 1344 insertions, 1006 deletions

diff --git a/src/binaryen-c.cpp b/src/binaryen-c.cpp
index 97565688a..84612d0e4 100644
--- a/src/binaryen-c.cpp
+++ b/src/binaryen-c.cpp
@@ -264,6 +264,31 @@ void traceExpression(BinaryenExpressionRef expr,
   }
 }
 
+template<typename F>
+void traceWithExpressionArray(const char* name,
+                              BinaryenExpressionRef* exprs,
+                              BinaryenIndex numExprs,
+                              F body) {
+  std::cout << "  {\n";
+  std::cout << "    BinaryenExpressionRef " << name << "[] = { ";
+  for (BinaryenIndex i = 0; i < numExprs; i++) {
+    if (i > 0) {
+      std::cout << ", ";
+    }
+    if (i % 6 == 5) {
+      std::cout << "\n       "; // don't create hugely long lines
+    }
+    std::cout << "expressions[" << expressions[exprs[i]] << "]";
+  }
+  if (numExprs == 0) {
+    // ensure the array is not empty, otherwise a compiler error on VS
+    std::cout << "0";
+  }
+  std::cout << " };\n  ";
+  body();
+  std::cout << "  }\n";
+}
+
 extern "C" {
 
 //
@@ -429,6 +454,12 @@ BinaryenExpressionId BinaryenRethrowId(void) {
 BinaryenExpressionId BinaryenBrOnExnId(void) {
   return Expression::Id::BrOnExnId;
 }
+BinaryenExpressionId BinaryenTupleMakeId(void) {
+  return Expression::Id::TupleMakeId;
+}
+BinaryenExpressionId BinaryenTupleExtractId(void) {
+  return Expression::Id::TupleExtractId;
+}
 BinaryenExpressionId BinaryenPushId(void) { return Expression::Id::PushId; }
 BinaryenExpressionId BinaryenPopId(void) { return Expression::Id::PopId; }
 
@@ -981,25 +1012,10 @@ BinaryenExpressionRef BinaryenBlock(BinaryenModuleRef module,
   }
 
   if (tracing) {
-    std::cout << "  {\n";
-    std::cout << "    BinaryenExpressionRef children[] = { ";
-    for (BinaryenIndex i = 0; i < numChildren; i++) {
-      if (i > 0) {
-        std::cout << ", ";
-      }
-      if (i % 6 == 5) {
-        std::cout << "\n       "; // don't create hugely long lines
-      }
-      std::cout << "expressions[" << expressions[children[i]] << "]";
-    }
-    if (numChildren == 0) {
-      // ensure the array is not empty, otherwise a compiler error on VS
-      std::cout << "0";
-    }
-    std::cout << " };\n  ";
-    traceExpression(
-      ret, "BinaryenBlock", StringLit(name), "children", numChildren, type);
-    std::cout << "  }\n";
+    traceWithExpressionArray("children", children, numChildren, [&]() {
+      traceExpression(
+        ret, "BinaryenBlock", StringLit(name), "children", numChildren, type);
+    });
   }
 
   return static_cast<Expression*>(ret);
@@ -1095,26 +1111,14 @@ static BinaryenExpressionRef makeBinaryenCall(BinaryenModuleRef module,
   auto* ret = ((Module*)module)->allocator.alloc<Call>();
 
   if (tracing) {
-    std::cout << "  {\n";
-    std::cout << "    BinaryenExpressionRef operands[] = { ";
-    for (BinaryenIndex i = 0; i < numOperands; i++) {
-      if (i > 0) {
-        std::cout << ", ";
-      }
-      std::cout << "expressions[" << expressions[operands[i]] << "]";
-    }
-    if (numOperands == 0) {
-      // ensure the array is not empty, otherwise a compiler error on VS
-      std::cout << "0";
-    }
-    std::cout << " };\n  ";
-    traceExpression(ret,
-                    (isReturn ? "BinaryenReturnCall" : "BinaryenCall"),
-                    StringLit(target),
-                    "operands",
-                    numOperands,
-                    returnType);
-    std::cout << "  }\n";
+    traceWithExpressionArray("operands", operands, numOperands, [&]() {
+      traceExpression(ret,
+                      (isReturn ? "BinaryenReturnCall" : "BinaryenCall"),
+                      StringLit(target),
+                      "operands",
+                      numOperands,
+                      returnType);
+    });
   }
 
   ret->target = target;
@@ -1717,6 +1721,35 @@ BinaryenExpressionRef BinaryenMemoryFill(BinaryenModuleRef module,
   }
   return static_cast<Expression*>(ret);
 }
+
+BinaryenExpressionRef BinaryenTupleMake(BinaryenModuleRef module,
+                                        BinaryenExpressionRef* operands,
+                                        BinaryenIndex numOperands) {
+  std::vector<Expression*> ops;
+  ops.resize(numOperands);
+  for (size_t i = 0; i < numOperands; ++i) {
+    ops[i] = (Expression*)operands[i];
+  }
+  auto* ret = Builder(*(Module*)module).makeTupleMake(ops);
+  if (tracing) {
+    traceWithExpressionArray("operands", operands, numOperands, [&]() {
+      traceExpression(ret, "BinaryenTupleMake", "operands", numOperands);
+    });
+  }
+  return static_cast<Expression*>(ret);
+}
+
+BinaryenExpressionRef BinaryenTupleExtract(BinaryenModuleRef module,
+                                           BinaryenExpressionRef tuple,
+                                           BinaryenIndex index) {
+  auto* ret =
+    Builder(*(Module*)module).makeTupleExtract((Expression*)tuple, index);
+  if (tracing) {
+    traceExpression(ret, "BinaryenTupleExtract", tuple, index);
+  }
+  return ret;
+}
+
 BinaryenExpressionRef BinaryenPush(BinaryenModuleRef module,
                                    BinaryenExpressionRef value) {
   auto* ret = Builder(*(Module*)module).makePush((Expression*)value);
@@ -1781,22 +1814,10 @@ BinaryenExpressionRef BinaryenThrow(BinaryenModuleRef module,
   auto* ret = Builder(*(Module*)module).makeThrow(event, args);
 
   if (tracing) {
-    std::cout << "  {\n";
-    std::cout << "    BinaryenExpressionRef operands[] = { ";
-    for (BinaryenIndex i = 0; i < numOperands; i++) {
-      if (i > 0) {
-        std::cout << ", ";
-      }
-      std::cout << "expressions[" << expressions[operands[i]] << "]";
-    }
-    if (numOperands == 0) {
-      // ensure the array is not empty, otherwise a compiler error on VS
-      std::cout << "0";
-    }
-    std::cout << " };\n  ";
-    traceExpression(
-      ret, "BinaryenThrow", StringLit(event), "operands", numOperands);
-    std::cout << "  }\n";
+    traceWithExpressionArray("operands", operands, numOperands, [&]() {
+      traceExpression(
+        ret, "BinaryenThrow", StringLit(event), "operands", numOperands);
+    });
   }
   return static_cast<Expression*>(ret);
 }
@@ -3017,17 +3038,6 @@ BinaryenExpressionRef BinaryenMemoryFillGetSize(BinaryenExpressionRef expr) {
   assert(expression->is<MemoryFill>());
   return static_cast<MemoryFill*>(expression)->size;
 }
-// Push
-BinaryenExpressionRef BinaryenPushGetValue(BinaryenExpressionRef expr) {
-  if (tracing) {
-    std::cout << "  BinaryenPushGetValue(expressions[" << expressions[expr]
-              << "]);\n";
-  }
-
-  auto* expression = (Expression*)expr;
-  assert(expression->is<Push>());
-  return static_cast<Push*>(expression)->value;
-}
 // RefIsNull
 BinaryenExpressionRef BinaryenRefIsNullGetValue(BinaryenExpressionRef expr) {
   if (tracing) {
@@ -3146,6 +3156,60 @@ BinaryenExpressionRef BinaryenBrOnExnGetExnref(BinaryenExpressionRef expr) {
   assert(expression->is<BrOnExn>());
   return static_cast<BrOnExn*>(expression)->exnref;
 }
+// TupleMake
+BinaryenIndex BinaryenTupleMakeGetNumOperands(BinaryenExpressionRef expr) {
+  if (tracing) {
+    std::cout << "  BinaryenTupleMakeGetNumOperands(expressions["
+              << expressions[expr] << "]);\n";
+  }
+
+  auto* expression = (Expression*)expr;
+  assert(expression->is<TupleMake>());
+  return static_cast<TupleMake*>(expression)->operands.size();
+}
+BinaryenExpressionRef BinaryenTupleMakeGetOperand(BinaryenExpressionRef expr,
+                                                  BinaryenIndex index) {
+  if (tracing) {
+    std::cout << "  BinaryenTupleMakeGetOperand(expressions["
+              << expressions[expr] << "], " << index << ");\n";
+  }
+
+  auto* expression = (Expression*)expr;
+  assert(expression->is<TupleMake>());
+  return static_cast<TupleMake*>(expression)->operands[index];
+}
+// TupleExtract
+BinaryenExpressionRef BinaryenTupleExtractGetTuple(BinaryenExpressionRef expr) {
+  if (tracing) {
+    std::cout << "  BinaryenTupleExtractGetTuple(expressions["
+              << expressions[expr] << "]);\n";
+  }
+
+  auto* expression = (Expression*)expr;
+  assert(expression->is<TupleExtract>());
+  return static_cast<TupleExtract*>(expression)->tuple;
+}
+BinaryenIndex BinaryenTupleExtractGetIndex(BinaryenExpressionRef expr) {
+  if (tracing) {
+    std::cout << "  BinaryenTupleExtractGetIndex(expressions["
+              << expressions[expr] << "]);\n";
+  }
+
+  auto* expression = (Expression*)expr;
+  assert(expression->is<TupleExtract>());
+  return static_cast<TupleExtract*>(expression)->index;
+}
+// Push
+BinaryenExpressionRef BinaryenPushGetValue(BinaryenExpressionRef expr) {
+  if (tracing) {
+    std::cout << "  BinaryenPushGetValue(expressions[" << expressions[expr]
+              << "]);\n";
+  }
+
+  auto* expression = (Expression*)expr;
+  assert(expression->is<Push>());
+  return static_cast<Push*>(expression)->value;
+}
 
 // Functions
 
diff --git a/src/binaryen-c.h b/src/binaryen-c.h
index b820bbdcb..33faab45d 100644
--- a/src/binaryen-c.h
+++ b/src/binaryen-c.h
@@ -167,6 +167,8 @@ BINARYEN_API BinaryenExpressionId BinaryenTryId(void);
 BINARYEN_API BinaryenExpressionId BinaryenThrowId(void);
 BINARYEN_API BinaryenExpressionId BinaryenRethrowId(void);
 BINARYEN_API BinaryenExpressionId BinaryenBrOnExnId(void);
+BINARYEN_API BinaryenExpressionId BinaryenTupleMakeId(void);
+BINARYEN_API BinaryenExpressionId BinaryenTupleExtractId(void);
 BINARYEN_API BinaryenExpressionId BinaryenPushId(void);
 BINARYEN_API BinaryenExpressionId BinaryenPopId(void);
 
@@ -831,6 +833,12 @@ BinaryenBrOnExn(BinaryenModuleRef module,
                 const char* name,
                 const char* eventName,
                 BinaryenExpressionRef exnref);
+BINARYEN_API BinaryenExpressionRef
+BinaryenTupleMake(BinaryenModuleRef module,
+                  BinaryenExpressionRef* operands,
+                  BinaryenIndex numOperands);
+BINARYEN_API BinaryenExpressionRef BinaryenTupleExtract(
+  BinaryenModuleRef module, BinaryenExpressionRef tuple, BinaryenIndex index);
 BINARYEN_API BinaryenExpressionRef BinaryenPush(BinaryenModuleRef module,
                                                 BinaryenExpressionRef value);
 BINARYEN_API BinaryenExpressionRef BinaryenPop(BinaryenModuleRef module,
@@ -1078,6 +1086,16 @@ BINARYEN_API const char* BinaryenBrOnExnGetName(BinaryenExpressionRef expr);
 BINARYEN_API BinaryenExpressionRef
 BinaryenBrOnExnGetExnref(BinaryenExpressionRef expr);
 
+BINARYEN_API BinaryenIndex
+BinaryenTupleMakeGetNumOperands(BinaryenExpressionRef expr);
+BINARYEN_API BinaryenExpressionRef
+BinaryenTupleMakeGetOperand(BinaryenExpressionRef expr, BinaryenIndex index);
+
+BINARYEN_API BinaryenExpressionRef
+BinaryenTupleExtractGetTuple(BinaryenExpressionRef expr);
+BINARYEN_API BinaryenIndex
+BinaryenTupleExtractGetIndex(BinaryenExpressionRef expr);
+
 BINARYEN_API BinaryenExpressionRef
 BinaryenPushGetValue(BinaryenExpressionRef expr);
 
diff --git a/src/js/binaryen.js-post.js b/src/js/binaryen.js-post.js
index 49b02d336..44dc7174b 100644
--- a/src/js/binaryen.js-post.js
+++ b/src/js/binaryen.js-post.js
@@ -95,6 +95,8 @@ function initializeConstants() {
     'Throw',
     'Rethrow',
     'BrOnExn',
+    'TupleMake',
+    'TupleExtract',
     'Push',
     'Pop'
   ].forEach(function(name) {
@@ -2091,6 +2093,17 @@ function wrapModule(module, self) {
     return Module['_BinaryenPush'](module, value);
   };
 
+  self['tuple'] = {
+    'make': function(elements) {
+      return preserveStack(function() {
+        return Module['_BinaryenTupleMake'](module, i32sToStack(elements), elements.length);
+      });
+    },
+    'extract': function(tuple, index) {
+      return Module['_BinaryenTupleExtract'](module, tuple, index);
+    }
+  };
+
   // 'Module' operations
   self['addFunction'] = function(name, params, results, varTypes, body) {
     return preserveStack(function() {
@@ -2790,6 +2803,19 @@ Module['getExpressionInfo'] = function(expr) {
         'event': UTF8ToString(Module['_BinaryenBrOnExnGetEvent'](expr)),
         'exnref': Module['_BinaryenBrOnExnGetExnref'](expr)
       };
+    case Module['TupleMakeId']:
+      return {
+        'id': id,
+        'type': type,
+        'operands': getAllNested(expr, Module['_BinaryenTupleMakeGetNumOperands'], Module['_BinaryenTupleMakeGetOperand'])
+      };
+    case Module['TupleExtractId']:
+      return {
+        'id': id,
+        'type': type,
+        'tuple': Module['_BinaryenTupleExtractGetTuple'](expr),
+        'index': Module['_BinaryenTupleExtractGetIndex'](expr)
+      };
     case Module['PushId']:
       return {
         'id': id,
diff --git a/test/binaryen.js/kitchen-sink.js b/test/binaryen.js/kitchen-sink.js
index a3428e63a..d6cdaf3cb 100644
--- a/test/binaryen.js/kitchen-sink.js
+++ b/test/binaryen.js/kitchen-sink.js
@@ -531,6 +531,16 @@ function test_core() {
     ),
     module.atomic.fence(),
 
+    // Tuples
+    module.tuple.make(
+      [ makeInt32(13), makeInt64(37, 0), makeFloat32(1.3), makeFloat64(3.7) ]
+    ),
+    module.tuple.extract(
+      module.tuple.make(
+        [ makeInt32(13), makeInt64(37, 0), makeFloat32(1.3), makeFloat64(3.7) ]
+      ), 2
+    ),
+
     // Push and pop
     module.push(module.i32.pop()),
     module.push(module.i64.pop()),
@@ -554,6 +564,12 @@ function test_core() {
   console.log("getExpressionInfo(i64.const)=" + JSON.stringify(binaryen.getExpressionInfo(module.i64.const(6, 7))));
   console.log("getExpressionInfo(f32.const)=" + JSON.stringify(binaryen.getExpressionInfo(module.f32.const(8.5))));
   console.log("getExpressionInfo(f64.const)=" + JSON.stringify(binaryen.getExpressionInfo(module.f64.const(9.5))));
+  var elements = binaryen.getExpressionInfo(
+    module.tuple.make([ makeInt32(13), makeInt64(37, 0), makeFloat32(1.3), makeFloat64(3.7) ])
+  ).operands;
+  for (var i = 0; i < elements.length; i++) {
+    console.log("getExpressionInfo(tuple[" + i + "])=" + JSON.stringify(binaryen.getExpressionInfo(elements[i])));
+  }
 
   // Make the main body of the function. and one block with a return value, one without
   var value = module.block("the-value", valueList);
diff --git a/test/binaryen.js/kitchen-sink.js.txt b/test/binaryen.js/kitchen-sink.js.txt
index 4df548571..647d04004 100644
--- a/test/binaryen.js/kitchen-sink.js.txt
+++ b/test/binaryen.js/kitchen-sink.js.txt
@@ -1702,26 +1702,43 @@ int main() {
   expressions[812] = BinaryenAtomicNotify(the_module, expressions[810], expressions[811]);
   expressions[813] = BinaryenDrop(the_module, expressions[812]);
   expressions[814] = BinaryenAtomicFence(the_module);
-  expressions[815] = BinaryenPop(the_module, 2);
-  expressions[816] = BinaryenPush(the_module, expressions[815]);
-  expressions[817] = BinaryenPop(the_module, 3);
-  expressions[818] = BinaryenPush(the_module, expressions[817]);
-  expressions[819] = BinaryenPop(the_module, 4);
-  expressions[820] = BinaryenPush(the_module, expressions[819]);
-  expressions[821] = BinaryenPop(the_module, 5);
-  expressions[822] = BinaryenPush(the_module, expressions[821]);
-  expressions[823] = BinaryenPop(the_module, 6);
-  expressions[824] = BinaryenPush(the_module, expressions[823]);
-  expressions[825] = BinaryenPop(the_module, 8);
-  expressions[826] = BinaryenPush(the_module, expressions[825]);
-  expressions[827] = BinaryenPop(the_module, 7);
-  expressions[828] = BinaryenPush(the_module, expressions[827]);
-  expressions[829] = BinaryenPop(the_module, 9);
-  expressions[830] = BinaryenPush(the_module, expressions[829]);
-  expressions[831] = BinaryenPop(the_module, 10);
-  expressions[832] = BinaryenPush(the_module, expressions[831]);
-  expressions[833] = BinaryenNop(the_module);
-  expressions[834] = BinaryenUnreachable(the_module);
+  expressions[815] = BinaryenConst(the_module, BinaryenLiteralInt32(13));
+  expressions[816] = BinaryenConst(the_module, BinaryenLiteralInt64(37));
+  expressions[817] = BinaryenConst(the_module, BinaryenLiteralFloat32(1.3));
+  expressions[818] = BinaryenConst(the_module, BinaryenLiteralFloat64(3.7));
+  {
+    BinaryenExpressionRef operands[] = { expressions[815], expressions[816], expressions[817], expressions[818] };
+    expressions[819] = BinaryenTupleMake(the_module, operands, 4);
+  }
+  expressions[820] = BinaryenConst(the_module, BinaryenLiteralInt32(13));
+  expressions[821] = BinaryenConst(the_module, BinaryenLiteralInt64(37));
+  expressions[822] = BinaryenConst(the_module, BinaryenLiteralFloat32(1.3));
+  expressions[823] = BinaryenConst(the_module, BinaryenLiteralFloat64(3.7));
+  {
+    BinaryenExpressionRef operands[] = { expressions[820], expressions[821], expressions[822], expressions[823] };
+    expressions[824] = BinaryenTupleMake(the_module, operands, 4);
+  }
+  expressions[825] = BinaryenTupleExtract(the_module, expressions[824], 2);
+  expressions[826] = BinaryenPop(the_module, 2);
+  expressions[827] = BinaryenPush(the_module, expressions[826]);
+  expressions[828] = BinaryenPop(the_module, 3);
+  expressions[829] = BinaryenPush(the_module, expressions[828]);
+  expressions[830] = BinaryenPop(the_module, 4);
+  expressions[831] = BinaryenPush(the_module, expressions[830]);
+  expressions[832] = BinaryenPop(the_module, 5);
+  expressions[833] = BinaryenPush(the_module, expressions[832]);
+  expressions[834] = BinaryenPop(the_module, 6);
+  expressions[835] = BinaryenPush(the_module, expressions[834]);
+  expressions[836] = BinaryenPop(the_module, 8);
+  expressions[837] = BinaryenPush(the_module, expressions[836]);
+  expressions[838] = BinaryenPop(the_module, 7);
+  expressions[839] = BinaryenPush(the_module, expressions[838]);
+  expressions[840] = BinaryenPop(the_module, 9);
+  expressions[841] = BinaryenPush(the_module, expressions[840]);
+  expressions[842] = BinaryenPop(the_module, 10);
+  expressions[843] = BinaryenPush(the_module, expressions[842]);
+  expressions[844] = BinaryenNop(the_module);
+  expressions[845] = BinaryenUnreachable(the_module);
   BinaryenExpressionGetId(expressions[30]);
   BinaryenExpressionGetType(expressions[30]);
   BinaryenUnaryGetOp(expressions[30]);
@@ -1732,27 +1749,59 @@ getExpressionInfo={"id":15,"type":4,"op":6}
  (f32.const -33.61199951171875)
 )
 
-  expressions[835] = BinaryenConst(the_module, BinaryenLiteralInt32(5));
-  BinaryenExpressionGetId(expressions[835]);
-  BinaryenExpressionGetType(expressions[835]);
-  BinaryenConstGetValueI32(expressions[835]);
+  expressions[846] = BinaryenConst(the_module, BinaryenLiteralInt32(5));
+  BinaryenExpressionGetId(expressions[846]);
+  BinaryenExpressionGetType(expressions[846]);
+  BinaryenConstGetValueI32(expressions[846]);
 getExpressionInfo(i32.const)={"id":14,"type":2,"value":5}
-  expressions[836] = BinaryenConst(the_module, BinaryenLiteralInt64(30064771078));
-  BinaryenExpressionGetId(expressions[836]);
-  BinaryenExpressionGetType(expressions[836]);
-  BinaryenConstGetValueI64Low(expressions[836]);
-  BinaryenConstGetValueI64High(expressions[836]);
+  expressions[847] = BinaryenConst(the_module, BinaryenLiteralInt64(30064771078));
+  BinaryenExpressionGetId(expressions[847]);
+  BinaryenExpressionGetType(expressions[847]);
+  BinaryenConstGetValueI64Low(expressions[847]);
+  BinaryenConstGetValueI64High(expressions[847]);
 getExpressionInfo(i64.const)={"id":14,"type":3,"value":{"low":6,"high":7}}
-  expressions[837] = BinaryenConst(the_module, BinaryenLiteralFloat32(8.5));
-  BinaryenExpressionGetId(expressions[837]);
-  BinaryenExpressionGetType(expressions[837]);
-  BinaryenConstGetValueF32(expressions[837]);
+  expressions[848] = BinaryenConst(the_module, BinaryenLiteralFloat32(8.5));
+  BinaryenExpressionGetId(expressions[848]);
+  BinaryenExpressionGetType(expressions[848]);
+  BinaryenConstGetValueF32(expressions[848]);
 getExpressionInfo(f32.const)={"id":14,"type":4,"value":8.5}
-  expressions[838] = BinaryenConst(the_module, BinaryenLiteralFloat64(9.5));
-  BinaryenExpressionGetId(expressions[838]);
-  BinaryenExpressionGetType(expressions[838]);
-  BinaryenConstGetValueF64(expressions[838]);
+  expressions[849] = BinaryenConst(the_module, BinaryenLiteralFloat64(9.5));
+  BinaryenExpressionGetId(expressions[849]);
+  BinaryenExpressionGetType(expressions[849]);
+  BinaryenConstGetValueF64(expressions[849]);
 getExpressionInfo(f64.const)={"id":14,"type":5,"value":9.5}
+  expressions[850] = BinaryenConst(the_module, BinaryenLiteralInt32(13));
+  expressions[851] = BinaryenConst(the_module, BinaryenLiteralInt64(37));
+  expressions[852] = BinaryenConst(the_module, BinaryenLiteralFloat32(1.3));
+  expressions[853] = BinaryenConst(the_module, BinaryenLiteralFloat64(3.7));
+  {
+    BinaryenExpressionRef operands[] = { expressions[850], expressions[851], expressions[852], expressions[853] };
+    expressions[854] = BinaryenTupleMake(the_module, operands, 4);
+  }
+  BinaryenExpressionGetId(expressions[854]);
+  BinaryenExpressionGetType(expressions[854]);
+  BinaryenTupleMakeGetNumOperands(expressions[854]);
+  BinaryenTupleMakeGetOperand(expressions[854], 0);
+  BinaryenTupleMakeGetOperand(expressions[854], 1);
+  BinaryenTupleMakeGetOperand(expressions[854], 2);
+  BinaryenTupleMakeGetOperand(expressions[854], 3);
+  BinaryenExpressionGetId(expressions[850]);
+  BinaryenExpressionGetType(expressions[850]);
+  BinaryenConstGetValueI32(expressions[850]);
+getExpressionInfo(tuple[0])={"id":14,"type":2,"value":13}
+  BinaryenExpressionGetId(expressions[851]);
+  BinaryenExpressionGetType(expressions[851]);
+  BinaryenConstGetValueI64Low(expressions[851]);
+  BinaryenConstGetValueI64High(expressions[851]);
+getExpressionInfo(tuple[1])={"id":14,"type":3,"value":{"low":37,"high":0}}
+  BinaryenExpressionGetId(expressions[852]);
+  BinaryenExpressionGetType(expressions[852]);
+  BinaryenConstGetValueF32(expressions[852]);
+getExpressionInfo(tuple[2])={"id":14,"type":4,"value":1.2999999523162842}
+  BinaryenExpressionGetId(expressions[853]);
+  BinaryenExpressionGetType(expressions[853]);
+  BinaryenConstGetValueF64(expressions[853]);
+getExpressionInfo(tuple[3])={"id":14,"type":5,"value":3.7}
   {
     BinaryenExpressionRef children[] = { expressions[24], expressions[26], expressions[28], expressions[30], expressions[32], 
        expressions[34], expressions[36], expressions[38], expressions[40], expressions[42], expressions[44], 
@@ -1804,27 +1853,27 @@ getExpressionInfo(f64.const)={"id":14,"type":5,"value":9.5}
        expressions[755], expressions[758], expressions[760], expressions[762], expressions[764], expressions[766], 
        expressions[767], expressions[768], expressions[769], expressions[771], expressions[776], expressions[782], 
        expressions[784], expressions[786], expressions[789], expressions[800], expressions[804], expressions[809], 
-       expressions[813], expressions[814], expressions[816], expressions[818], expressions[820], expressions[822], 
-       expressions[824], expressions[826], expressions[828], expressions[830], expressions[832], expressions[833], 
-       expressions[834] };
-    expressions[839] = BinaryenBlock(the_module, "the-value", children, 312, 0);
+       expressions[813], expressions[814], expressions[819], expressions[825], expressions[827], expressions[829], 
+       expressions[831], expressions[833], expressions[835], expressions[837], expressions[839], expressions[841], 
+       expressions[843], expressions[844], expressions[845] };
+    expressions[855] = BinaryenBlock(the_module, "the-value", children, 314, 0);
   }
-  expressions[840] = BinaryenDrop(the_module, expressions[839]);
+  expressions[856] = BinaryenDrop(the_module, expressions[855]);
   {
-    BinaryenExpressionRef children[] = { expressions[840] };
-    expressions[841] = BinaryenBlock(the_module, "the-nothing", children, 1, 0);
+    BinaryenExpressionRef children[] = { expressions[856] };
+    expressions[857] = BinaryenBlock(the_module, "the-nothing", children, 1, 0);
   }
-  expressions[842] = BinaryenConst(the_module, BinaryenLiteralInt32(42));
+  expressions[858] = BinaryenConst(the_module, BinaryenLiteralInt32(42));
   {
-    BinaryenExpressionRef children[] = { expressions[841], expressions[842] };
-    expressions[843] = BinaryenBlock(the_module, "the-body", children, 2, 0);
+    BinaryenExpressionRef children[] = { expressions[857], expressions[858] };
+    expressions[859] = BinaryenBlock(the_module, "the-body", children, 2, 0);
   }
   {
     BinaryenType varTypes[] = { 2, 10 };
-    functions[0] = BinaryenAddFunction(the_module, "kitchen()sinker", 11, 2, varTypes, 2, expressions[843]);
+    functions[0] = BinaryenAddFunction(the_module, "kitchen()sinker", 11, 2, varTypes, 2, expressions[859]);
   }
-  expressions[844] = BinaryenConst(the_module, BinaryenLiteralInt32(1));
-  globals[0] = BinaryenAddGlobal(the_module, "a-global", 2, 0, expressions[844]);
+  expressions[860] = BinaryenConst(the_module, BinaryenLiteralInt32(1));
+  globals[0] = BinaryenAddGlobal(the_module, "a-global", 2, 0, expressions[860]);
   {
     BinaryenType t279[] = {2, 5};
     BinaryenTypeCreate(t279, 2); // 12
@@ -1845,25 +1894,25 @@ getExpressionInfo(f64.const)={"id":14,"type":5,"value":9.5}
   BinaryenFunctionGetVar(functions[0], 0);
   BinaryenFunctionGetVar(functions[0], 1);
   BinaryenFunctionGetBody(functions[0]);
-  expressions[845] = BinaryenConst(the_module, BinaryenLiteralInt32(0));
+  expressions[861] = BinaryenConst(the_module, BinaryenLiteralInt32(0));
   {
     const char* funcNames[] = { "kitchen()sinker" };
-    BinaryenSetFunctionTable(the_module, 1, 4294967295, funcNames, 1, expressions[845]);
+    BinaryenSetFunctionTable(the_module, 1, 4294967295, funcNames, 1, expressions[861]);
   }
-  expressions[846] = BinaryenConst(the_module, BinaryenLiteralInt32(10));
+  expressions[862] = 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[846], expressions[0] };
+    BinaryenExpressionRef segmentOffsets[] = { expressions[862], expressions[0] };
     BinaryenIndex segmentSizes[] = { 12, 12 };
     BinaryenSetMemory(the_module, 1, 256, "mem", segments, segmentPassive, segmentOffsets, segmentSizes, 2, 1);
   }
-  expressions[847] = BinaryenNop(the_module);
+  expressions[863] = BinaryenNop(the_module);
   {
     BinaryenType varTypes[] = { 0 };
-    functions[1] = BinaryenAddFunction(the_module, "starter", 0, 0, varTypes, 0, expressions[847]);
+    functions[1] = BinaryenAddFunction(the_module, "starter", 0, 0, varTypes, 0, expressions[863]);
   }
   BinaryenSetStart(the_module, functions[1]);
   BinaryenModuleAutoDrop(the_module);
@@ -3578,6 +3627,24 @@ getExpressionInfo(f64.const)={"id":14,"type":5,"value":9.5}
        )
       )
       (atomic.fence)
+      (drop
+       (tuple.make
+        (i32.const 13)
+        (i64.const 37)
+        (f32.const 1.2999999523162842)
+        (f64.const 3.7)
+       )
+      )
+      (drop
+       (tuple.extract 2
+        (tuple.make
+         (i32.const 13)
+         (i64.const 37)
+         (f32.const 1.2999999523162842)
+         (f64.const 3.7)
+        )
+       )
+      )
       (push
        (i32.pop)
       )
@@ -5328,6 +5395,24 @@ getExpressionInfo(f64.const)={"id":14,"type":5,"value":9.5}
        )
       )
       (atomic.fence)
+      (drop
+       (tuple.make
+        (i32.const 13)
+        (i64.const 37)
+        (f32.const 1.2999999523162842)
+        (f64.const 3.7)
+       )
+      )
+      (drop
+       (tuple.extract 2
+        (tuple.make
+         (i32.const 13)
+         (i64.const 37)
+         (f32.const 1.2999999523162842)
+         (f64.const 3.7)
+        )
+       )
+      )
       (push
        (i32.pop)
       )
@@ -6427,6 +6512,10 @@ getExpressionInfo(i32.const)={"id":14,"type":2,"value":5}
 getExpressionInfo(i64.const)={"id":14,"type":3,"value":{"low":6,"high":7}}
 getExpressionInfo(f32.const)={"id":14,"type":4,"value":8.5}
 getExpressionInfo(f64.const)={"id":14,"type":5,"value":9.5}
+getExpressionInfo(tuple[0])={"id":14,"type":2,"value":13}
+getExpressionInfo(tuple[1])={"id":14,"type":3,"value":{"low":37,"high":0}}
+getExpressionInfo(tuple[2])={"id":14,"type":4,"value":1.2999999523162842}
+getExpressionInfo(tuple[3])={"id":14,"type":5,"value":3.7}
 (module
  (type $i32_i64_f32_f64_=>_i32 (func (param i32 i64 f32 f64) (result i32)))
  (type $i32_=>_none (func (param i32)))
@@ -8135,6 +8224,24 @@ getExpressionInfo(f64.const)={"id":14,"type":5,"value":9.5}
        )
       )
       (atomic.fence)
+      (drop
+       (tuple.make
+        (i32.const 13)
+        (i64.const 37)
+        (f32.const 1.2999999523162842)
+        (f64.const 3.7)
+       )
+      )
+      (drop
+       (tuple.extract 2
+        (tuple.make
+         (i32.const 13)
+         (i64.const 37)
+         (f32.const 1.2999999523162842)
+         (f64.const 3.7)
+        )
+       )
+      )
       (push
        (i32.pop)
       )
@@ -9883,6 +9990,24 @@ getExpressionInfo(f64.const)={"id":14,"type":5,"value":9.5}
        )
       )
       (atomic.fence)
+      (drop
+       (tuple.make
+        (i32.const 13)
+        (i64.const 37)
+        (f32.const 1.2999999523162842)
+        (f64.const 3.7)
+       )
+      )
+      (drop
+       (tuple.extract 2
+        (tuple.make
+         (i32.const 13)
+         (i64.const 37)
+         (f32.const 1.2999999523162842)
+         (f64.const 3.7)
+        )
+       )
+      )
       (push
        (i32.pop)
       )
diff --git a/test/example/c-api-kitchen-sink.c b/test/example/c-api-kitchen-sink.c
index 883d1ff75..0158bd73d 100644
--- a/test/example/c-api-kitchen-sink.c
+++ b/test/example/c-api-kitchen-sink.c
@@ -272,6 +272,14 @@ void test_core() {
   BinaryenExpressionRef callOperands2[] = { makeInt32(module, 13), makeFloat64(module, 3.7) };
   BinaryenExpressionRef callOperands4[] = { makeInt32(module, 13), makeInt64(module, 37), makeFloat32(module, 1.3f), makeFloat64(module, 3.7) };
   BinaryenExpressionRef callOperands4b[] = { makeInt32(module, 13), makeInt64(module, 37), makeFloat32(module, 1.3f), makeFloat64(module, 3.7) };
+  BinaryenExpressionRef tupleElements4a[] = {makeInt32(module, 13),
+                                             makeInt64(module, 37),
+                                             makeFloat32(module, 1.3f),
+                                             makeFloat64(module, 3.7)};
+  BinaryenExpressionRef tupleElements4b[] = {makeInt32(module, 13),
+                                             makeInt64(module, 37),
+                                             makeFloat32(module, 1.3f),
+                                             makeFloat64(module, 3.7)};
 
   BinaryenType iIfF_[4] = {BinaryenTypeInt32(),
                            BinaryenTypeInt64(),
@@ -714,6 +722,10 @@ void test_core() {
       BinaryenAtomicWait(module, temp6, temp6, temp16, BinaryenTypeInt32())),
     BinaryenDrop(module, BinaryenAtomicNotify(module, temp6, temp6)),
     BinaryenAtomicFence(module),
+    // Tuples
+    BinaryenTupleMake(module, tupleElements4a, 4),
+    BinaryenTupleExtract(
+      module, BinaryenTupleMake(module, tupleElements4b, 4), 2),
     // Push and pop
     BinaryenPush(module, BinaryenPop(module, BinaryenTypeInt32())),
     BinaryenPush(module, BinaryenPop(module, BinaryenTypeInt64())),
@@ -735,11 +747,17 @@ void test_core() {
   BinaryenExpressionPrint(valueList[3]); // test printing a standalone expression
 
   // Make the main body of the function. and one block with a return value, one without
-  BinaryenExpressionRef value = BinaryenBlock(module, "the-value", valueList, sizeof(valueList) / sizeof(BinaryenExpressionRef), -1);
+  BinaryenExpressionRef value =
+    BinaryenBlock(module,
+                  "the-value",
+                  valueList,
+                  sizeof(valueList) / sizeof(BinaryenExpressionRef),
+                  BinaryenTypeAuto());
   BinaryenExpressionRef droppedValue = BinaryenDrop(module, value);
   BinaryenExpressionRef nothing = BinaryenBlock(module, "the-nothing", &droppedValue, 1, -1);
   BinaryenExpressionRef bodyList[] = { nothing, makeInt32(module, 42) };
-  BinaryenExpressionRef body = BinaryenBlock(module, "the-body", bodyList, 2, -1);
+  BinaryenExpressionRef body =
+    BinaryenBlock(module, "the-body", bodyList, 2, BinaryenTypeAuto());
 
   // Create the function
   BinaryenType localTypes[] = {BinaryenTypeInt32(), BinaryenTypeExnref()};
diff --git a/test/example/c-api-kitchen-sink.txt b/test/example/c-api-kitchen-sink.txt
index af51fd781..989fe3dbb 100644
--- a/test/example/c-api-kitchen-sink.txt
+++ b/test/example/c-api-kitchen-sink.txt
@@ -33,1764 +33,1781 @@ int main() {
   expressions[15] = BinaryenConst(the_module, BinaryenLiteralInt64(37));
   expressions[16] = BinaryenConst(the_module, BinaryenLiteralFloat32(1.3));
   expressions[17] = BinaryenConst(the_module, BinaryenLiteralFloat64(3.7));
+  expressions[18] = BinaryenConst(the_module, BinaryenLiteralInt32(13));
+  expressions[19] = BinaryenConst(the_module, BinaryenLiteralInt64(37));
+  expressions[20] = BinaryenConst(the_module, BinaryenLiteralFloat32(1.3));
+  expressions[21] = BinaryenConst(the_module, BinaryenLiteralFloat64(3.7));
+  expressions[22] = BinaryenConst(the_module, BinaryenLiteralInt32(13));
+  expressions[23] = BinaryenConst(the_module, BinaryenLiteralInt64(37));
+  expressions[24] = BinaryenConst(the_module, BinaryenLiteralFloat32(1.3));
+  expressions[25] = BinaryenConst(the_module, BinaryenLiteralFloat64(3.7));
   {
     BinaryenType t1[] = {2, 3, 4, 5};
     BinaryenTypeCreate(t1, 4); // 11
   }
-  expressions[18] = BinaryenConst(the_module, BinaryenLiteralInt32(1));
-  expressions[19] = BinaryenConst(the_module, BinaryenLiteralInt32(2));
-  expressions[20] = BinaryenConst(the_module, BinaryenLiteralInt32(3));
-  expressions[21] = BinaryenConst(the_module, BinaryenLiteralInt32(4));
-  expressions[22] = BinaryenConst(the_module, BinaryenLiteralInt32(5));
-  expressions[23] = BinaryenConst(the_module, BinaryenLiteralInt32(0));
-  expressions[24] = BinaryenConst(the_module, BinaryenLiteralInt32(1));
-  expressions[25] = BinaryenConst(the_module, BinaryenLiteralInt32(0));
   expressions[26] = BinaryenConst(the_module, BinaryenLiteralInt32(1));
-  expressions[27] = BinaryenConst(the_module, BinaryenLiteralInt32(1));
+  expressions[27] = BinaryenConst(the_module, BinaryenLiteralInt32(2));
   expressions[28] = BinaryenConst(the_module, BinaryenLiteralInt32(3));
-  expressions[29] = BinaryenConst(the_module, BinaryenLiteralInt32(5));
-  expressions[30] = BinaryenConst(the_module, BinaryenLiteralInt32(10));
-  expressions[31] = BinaryenConst(the_module, BinaryenLiteralInt32(11));
-  expressions[32] = BinaryenConst(the_module, BinaryenLiteralInt32(110));
-  expressions[33] = BinaryenConst(the_module, BinaryenLiteralInt64(111));
-  expressions[34] = BinaryenRefNull(the_module);
-  expressions[35] = BinaryenRefFunc(the_module, "kitchen()sinker");
+  expressions[29] = BinaryenConst(the_module, BinaryenLiteralInt32(4));
+  expressions[30] = BinaryenConst(the_module, BinaryenLiteralInt32(5));
+  expressions[31] = BinaryenConst(the_module, BinaryenLiteralInt32(0));
+  expressions[32] = BinaryenConst(the_module, BinaryenLiteralInt32(1));
+  expressions[33] = BinaryenConst(the_module, BinaryenLiteralInt32(0));
+  expressions[34] = BinaryenConst(the_module, BinaryenLiteralInt32(1));
+  expressions[35] = BinaryenConst(the_module, BinaryenLiteralInt32(1));
+  expressions[36] = BinaryenConst(the_module, BinaryenLiteralInt32(3));
+  expressions[37] = BinaryenConst(the_module, BinaryenLiteralInt32(5));
+  expressions[38] = BinaryenConst(the_module, BinaryenLiteralInt32(10));
+  expressions[39] = BinaryenConst(the_module, BinaryenLiteralInt32(11));
+  expressions[40] = BinaryenConst(the_module, BinaryenLiteralInt32(110));
+  expressions[41] = BinaryenConst(the_module, BinaryenLiteralInt64(111));
+  expressions[42] = BinaryenRefNull(the_module);
+  expressions[43] = BinaryenRefFunc(the_module, "kitchen()sinker");
   BinaryenAddEvent(the_module, "a-event", 0, 2, 0);
-  expressions[36] = BinaryenConst(the_module, BinaryenLiteralInt32(0));
-  {
-    BinaryenExpressionRef operands[] = { expressions[36] };
-    expressions[37] = BinaryenThrow(the_module, "a-event", operands, 1);
-  }
-  expressions[38] = BinaryenPop(the_module, 10);
-  expressions[39] = BinaryenLocalSet(the_module, 5, expressions[38]);
-  expressions[40] = BinaryenLocalGet(the_module, 5, 10);
-  expressions[41] = BinaryenBrOnExn(the_module, "try-block", "a-event", expressions[40]);
-  expressions[42] = BinaryenRethrow(the_module, expressions[41]);
-  {
-    BinaryenExpressionRef children[] = { expressions[42] };
-    expressions[43] = BinaryenBlock(the_module, "try-block", children, 1, 2);
-  }
-  expressions[44] = BinaryenDrop(the_module, expressions[43]);
-  {
-    BinaryenExpressionRef children[] = { expressions[39], expressions[44] };
-    expressions[45] = BinaryenBlock(the_module, NULL, children, 2, 0);
-  }
-  expressions[46] = BinaryenConst(the_module, BinaryenLiteralInt32(-10));
-  expressions[47] = BinaryenUnary(the_module, 0, expressions[46]);
-  expressions[48] = BinaryenConst(the_module, BinaryenLiteralInt64(-22));
-  expressions[49] = BinaryenUnary(the_module, 3, expressions[48]);
-  expressions[50] = BinaryenConst(the_module, BinaryenLiteralInt32(-10));
-  expressions[51] = BinaryenUnary(the_module, 4, expressions[50]);
-  expressions[52] = BinaryenConst(the_module, BinaryenLiteralFloat32(-33.612));
-  expressions[53] = BinaryenUnary(the_module, 6, expressions[52]);
-  expressions[54] = BinaryenConst(the_module, BinaryenLiteralFloat64(-9005.84));
-  expressions[55] = BinaryenUnary(the_module, 9, expressions[54]);
-  expressions[56] = BinaryenConst(the_module, BinaryenLiteralFloat32(-33.612));
-  expressions[57] = BinaryenUnary(the_module, 10, expressions[56]);
-  expressions[58] = BinaryenConst(the_module, BinaryenLiteralFloat64(-9005.84));
-  expressions[59] = BinaryenUnary(the_module, 13, expressions[58]);
+  expressions[44] = BinaryenConst(the_module, BinaryenLiteralInt32(0));
+  {
+    BinaryenExpressionRef operands[] = { expressions[44] };
+    expressions[45] = BinaryenThrow(the_module, "a-event", operands, 1);
+  }
+  expressions[46] = BinaryenPop(the_module, 10);
+  expressions[47] = BinaryenLocalSet(the_module, 5, expressions[46]);
+  expressions[48] = BinaryenLocalGet(the_module, 5, 10);
+  expressions[49] = BinaryenBrOnExn(the_module, "try-block", "a-event", expressions[48]);
+  expressions[50] = BinaryenRethrow(the_module, expressions[49]);
+  {
+    BinaryenExpressionRef children[] = { expressions[50] };
+    expressions[51] = BinaryenBlock(the_module, "try-block", children, 1, 2);
+  }
+  expressions[52] = BinaryenDrop(the_module, expressions[51]);
+  {
+    BinaryenExpressionRef children[] = { expressions[47], expressions[52] };
+    expressions[53] = BinaryenBlock(the_module, NULL, children, 2, 0);
+  }
+  expressions[54] = BinaryenConst(the_module, BinaryenLiteralInt32(-10));
+  expressions[55] = BinaryenUnary(the_module, 0, expressions[54]);
+  expressions[56] = BinaryenConst(the_module, BinaryenLiteralInt64(-22));
+  expressions[57] = BinaryenUnary(the_module, 3, expressions[56]);
+  expressions[58] = BinaryenConst(the_module, BinaryenLiteralInt32(-10));
+  expressions[59] = BinaryenUnary(the_module, 4, expressions[58]);
   expressions[60] = BinaryenConst(the_module, BinaryenLiteralFloat32(-33.612));
-  expressions[61] = BinaryenUnary(the_module, 14, expressions[60]);
-  expressions[62] = BinaryenConst(the_module, BinaryenLiteralFloat32(-33.612));
-  expressions[63] = BinaryenUnary(the_module, 16, expressions[62]);
-  expressions[64] = BinaryenConst(the_module, BinaryenLiteralFloat64(-9005.84));
-  expressions[65] = BinaryenUnary(the_module, 19, expressions[64]);
-  expressions[66] = BinaryenConst(the_module, BinaryenLiteralInt32(-10));
-  expressions[67] = BinaryenUnary(the_module, 20, expressions[66]);
-  expressions[68] = BinaryenConst(the_module, BinaryenLiteralInt32(-10));
-  expressions[69] = BinaryenUnary(the_module, 22, expressions[68]);
-  expressions[70] = BinaryenConst(the_module, BinaryenLiteralInt32(-10));
-  expressions[71] = BinaryenUnary(the_module, 23, expressions[70]);
-  expressions[72] = BinaryenConst(the_module, BinaryenLiteralInt64(-22));
-  expressions[73] = BinaryenUnary(the_module, 24, expressions[72]);
-  expressions[74] = BinaryenConst(the_module, BinaryenLiteralFloat32(-33.612));
-  expressions[75] = BinaryenUnary(the_module, 25, expressions[74]);
-  expressions[76] = BinaryenConst(the_module, BinaryenLiteralFloat32(-33.612));
-  expressions[77] = BinaryenUnary(the_module, 26, expressions[76]);
-  expressions[78] = BinaryenConst(the_module, BinaryenLiteralFloat32(-33.612));
-  expressions[79] = BinaryenUnary(the_module, 27, expressions[78]);
-  expressions[80] = BinaryenConst(the_module, BinaryenLiteralFloat32(-33.612));
-  expressions[81] = BinaryenUnary(the_module, 28, expressions[80]);
-  expressions[82] = BinaryenConst(the_module, BinaryenLiteralFloat64(-9005.84));
-  expressions[83] = BinaryenUnary(the_module, 29, expressions[82]);
-  expressions[84] = BinaryenConst(the_module, BinaryenLiteralFloat64(-9005.84));
-  expressions[85] = BinaryenUnary(the_module, 30, expressions[84]);
-  expressions[86] = BinaryenConst(the_module, BinaryenLiteralFloat64(-9005.84));
-  expressions[87] = BinaryenUnary(the_module, 31, expressions[86]);
-  expressions[88] = BinaryenConst(the_module, BinaryenLiteralFloat64(-9005.84));
-  expressions[89] = BinaryenUnary(the_module, 32, expressions[88]);
-  expressions[90] = BinaryenConst(the_module, BinaryenLiteralFloat32(-33.612));
-  expressions[91] = BinaryenUnary(the_module, 52, expressions[90]);
-  expressions[92] = BinaryenConst(the_module, BinaryenLiteralFloat32(-33.612));
-  expressions[93] = BinaryenUnary(the_module, 56, expressions[92]);
-  expressions[94] = BinaryenConst(the_module, BinaryenLiteralFloat32(-33.612));
-  expressions[95] = BinaryenUnary(the_module, 53, expressions[94]);
-  expressions[96] = BinaryenConst(the_module, BinaryenLiteralFloat32(-33.612));
-  expressions[97] = BinaryenUnary(the_module, 57, expressions[96]);
-  expressions[98] = BinaryenConst(the_module, BinaryenLiteralFloat64(-9005.84));
-  expressions[99] = BinaryenUnary(the_module, 54, expressions[98]);
-  expressions[100] = BinaryenConst(the_module, BinaryenLiteralFloat64(-9005.84));
-  expressions[101] = BinaryenUnary(the_module, 58, expressions[100]);
-  expressions[102] = BinaryenConst(the_module, BinaryenLiteralFloat64(-9005.84));
-  expressions[103] = BinaryenUnary(the_module, 55, expressions[102]);
-  expressions[104] = BinaryenConst(the_module, BinaryenLiteralFloat64(-9005.84));
-  expressions[105] = BinaryenUnary(the_module, 59, expressions[104]);
-  expressions[106] = BinaryenConst(the_module, BinaryenLiteralFloat32(-33.612));
-  expressions[107] = BinaryenUnary(the_module, 33, expressions[106]);
+  expressions[61] = BinaryenUnary(the_module, 6, expressions[60]);
+  expressions[62] = BinaryenConst(the_module, BinaryenLiteralFloat64(-9005.84));
+  expressions[63] = BinaryenUnary(the_module, 9, expressions[62]);
+  expressions[64] = BinaryenConst(the_module, BinaryenLiteralFloat32(-33.612));
+  expressions[65] = BinaryenUnary(the_module, 10, expressions[64]);
+  expressions[66] = BinaryenConst(the_module, BinaryenLiteralFloat64(-9005.84));
+  expressions[67] = BinaryenUnary(the_module, 13, expressions[66]);
+  expressions[68] = BinaryenConst(the_module, BinaryenLiteralFloat32(-33.612));
+  expressions[69] = BinaryenUnary(the_module, 14, expressions[68]);
+  expressions[70] = BinaryenConst(the_module, BinaryenLiteralFloat32(-33.612));
+  expressions[71] = BinaryenUnary(the_module, 16, expressions[70]);
+  expressions[72] = BinaryenConst(the_module, BinaryenLiteralFloat64(-9005.84));
+  expressions[73] = BinaryenUnary(the_module, 19, expressions[72]);
+  expressions[74] = BinaryenConst(the_module, BinaryenLiteralInt32(-10));
+  expressions[75] = BinaryenUnary(the_module, 20, expressions[74]);
+  expressions[76] = BinaryenConst(the_module, BinaryenLiteralInt32(-10));
+  expressions[77] = BinaryenUnary(the_module, 22, expressions[76]);
+  expressions[78] = BinaryenConst(the_module, BinaryenLiteralInt32(-10));
+  expressions[79] = BinaryenUnary(the_module, 23, expressions[78]);
+  expressions[80] = BinaryenConst(the_module, BinaryenLiteralInt64(-22));
+  expressions[81] = BinaryenUnary(the_module, 24, expressions[80]);
+  expressions[82] = BinaryenConst(the_module, BinaryenLiteralFloat32(-33.612));
+  expressions[83] = BinaryenUnary(the_module, 25, expressions[82]);
+  expressions[84] = BinaryenConst(the_module, BinaryenLiteralFloat32(-33.612));
+  expressions[85] = BinaryenUnary(the_module, 26, expressions[84]);
+  expressions[86] = BinaryenConst(the_module, BinaryenLiteralFloat32(-33.612));
+  expressions[87] = BinaryenUnary(the_module, 27, expressions[86]);
+  expressions[88] = BinaryenConst(the_module, BinaryenLiteralFloat32(-33.612));
+  expressions[89] = BinaryenUnary(the_module, 28, expressions[88]);
+  expressions[90] = BinaryenConst(the_module, BinaryenLiteralFloat64(-9005.84));
+  expressions[91] = BinaryenUnary(the_module, 29, expressions[90]);
+  expressions[92] = BinaryenConst(the_module, BinaryenLiteralFloat64(-9005.84));
+  expressions[93] = BinaryenUnary(the_module, 30, expressions[92]);
+  expressions[94] = BinaryenConst(the_module, BinaryenLiteralFloat64(-9005.84));
+  expressions[95] = BinaryenUnary(the_module, 31, expressions[94]);
+  expressions[96] = BinaryenConst(the_module, BinaryenLiteralFloat64(-9005.84));
+  expressions[97] = BinaryenUnary(the_module, 32, expressions[96]);
+  expressions[98] = BinaryenConst(the_module, BinaryenLiteralFloat32(-33.612));
+  expressions[99] = BinaryenUnary(the_module, 52, expressions[98]);
+  expressions[100] = BinaryenConst(the_module, BinaryenLiteralFloat32(-33.612));
+  expressions[101] = BinaryenUnary(the_module, 56, expressions[100]);
+  expressions[102] = BinaryenConst(the_module, BinaryenLiteralFloat32(-33.612));
+  expressions[103] = BinaryenUnary(the_module, 53, expressions[102]);
+  expressions[104] = BinaryenConst(the_module, BinaryenLiteralFloat32(-33.612));
+  expressions[105] = BinaryenUnary(the_module, 57, expressions[104]);
+  expressions[106] = BinaryenConst(the_module, BinaryenLiteralFloat64(-9005.84));
+  expressions[107] = BinaryenUnary(the_module, 54, expressions[106]);
   expressions[108] = BinaryenConst(the_module, BinaryenLiteralFloat64(-9005.84));
-  expressions[109] = BinaryenUnary(the_module, 34, expressions[108]);
-  expressions[110] = BinaryenConst(the_module, BinaryenLiteralInt32(-10));
-  expressions[111] = BinaryenUnary(the_module, 35, expressions[110]);
-  expressions[112] = BinaryenConst(the_module, BinaryenLiteralInt32(-10));
-  expressions[113] = BinaryenUnary(the_module, 36, expressions[112]);
-  expressions[114] = BinaryenConst(the_module, BinaryenLiteralInt32(-10));
-  expressions[115] = BinaryenUnary(the_module, 37, expressions[114]);
-  expressions[116] = BinaryenConst(the_module, BinaryenLiteralInt32(-10));
-  expressions[117] = BinaryenUnary(the_module, 38, expressions[116]);
-  expressions[118] = BinaryenConst(the_module, BinaryenLiteralInt64(-22));
-  expressions[119] = BinaryenUnary(the_module, 39, expressions[118]);
-  expressions[120] = BinaryenConst(the_module, BinaryenLiteralInt64(-22));
-  expressions[121] = BinaryenUnary(the_module, 40, expressions[120]);
-  expressions[122] = BinaryenConst(the_module, BinaryenLiteralInt64(-22));
-  expressions[123] = BinaryenUnary(the_module, 41, expressions[122]);
-  expressions[124] = BinaryenConst(the_module, BinaryenLiteralInt64(-22));
-  expressions[125] = BinaryenUnary(the_module, 42, expressions[124]);
-  expressions[126] = BinaryenConst(the_module, BinaryenLiteralFloat32(-33.612));
-  expressions[127] = BinaryenUnary(the_module, 43, expressions[126]);
-  expressions[128] = BinaryenConst(the_module, BinaryenLiteralFloat64(-9005.84));
-  expressions[129] = BinaryenUnary(the_module, 44, expressions[128]);
-  expressions[130] = BinaryenConst(the_module, BinaryenLiteralInt32(-10));
-  expressions[131] = BinaryenUnary(the_module, 45, expressions[130]);
+  expressions[109] = BinaryenUnary(the_module, 58, expressions[108]);
+  expressions[110] = BinaryenConst(the_module, BinaryenLiteralFloat64(-9005.84));
+  expressions[111] = BinaryenUnary(the_module, 55, expressions[110]);
+  expressions[112] = BinaryenConst(the_module, BinaryenLiteralFloat64(-9005.84));
+  expressions[113] = BinaryenUnary(the_module, 59, expressions[112]);
+  expressions[114] = BinaryenConst(the_module, BinaryenLiteralFloat32(-33.612));
+  expressions[115] = BinaryenUnary(the_module, 33, expressions[114]);
+  expressions[116] = BinaryenConst(the_module, BinaryenLiteralFloat64(-9005.84));
+  expressions[117] = BinaryenUnary(the_module, 34, expressions[116]);
+  expressions[118] = BinaryenConst(the_module, BinaryenLiteralInt32(-10));
+  expressions[119] = BinaryenUnary(the_module, 35, expressions[118]);
+  expressions[120] = BinaryenConst(the_module, BinaryenLiteralInt32(-10));
+  expressions[121] = BinaryenUnary(the_module, 36, expressions[120]);
+  expressions[122] = BinaryenConst(the_module, BinaryenLiteralInt32(-10));
+  expressions[123] = BinaryenUnary(the_module, 37, expressions[122]);
+  expressions[124] = BinaryenConst(the_module, BinaryenLiteralInt32(-10));
+  expressions[125] = BinaryenUnary(the_module, 38, expressions[124]);
+  expressions[126] = BinaryenConst(the_module, BinaryenLiteralInt64(-22));
+  expressions[127] = BinaryenUnary(the_module, 39, expressions[126]);
+  expressions[128] = BinaryenConst(the_module, BinaryenLiteralInt64(-22));
+  expressions[129] = BinaryenUnary(the_module, 40, expressions[128]);
+  expressions[130] = BinaryenConst(the_module, BinaryenLiteralInt64(-22));
+  expressions[131] = BinaryenUnary(the_module, 41, expressions[130]);
   expressions[132] = BinaryenConst(the_module, BinaryenLiteralInt64(-22));
-  expressions[133] = BinaryenUnary(the_module, 46, expressions[132]);
-  expressions[134] = BinaryenConst(the_module, BinaryenLiteralInt32(-10));
-  expressions[135] = BinaryenUnary(the_module, 60, expressions[134]);
-  expressions[136] = BinaryenConst(the_module, BinaryenLiteralInt32(-10));
-  expressions[137] = BinaryenUnary(the_module, 61, expressions[136]);
+  expressions[133] = BinaryenUnary(the_module, 42, expressions[132]);
+  expressions[134] = BinaryenConst(the_module, BinaryenLiteralFloat32(-33.612));
+  expressions[135] = BinaryenUnary(the_module, 43, expressions[134]);
+  expressions[136] = BinaryenConst(the_module, BinaryenLiteralFloat64(-9005.84));
+  expressions[137] = BinaryenUnary(the_module, 44, expressions[136]);
   expressions[138] = BinaryenConst(the_module, BinaryenLiteralInt32(-10));
-  expressions[139] = BinaryenUnary(the_module, 62, expressions[138]);
+  expressions[139] = BinaryenUnary(the_module, 45, expressions[138]);
   expressions[140] = BinaryenConst(the_module, BinaryenLiteralInt64(-22));
-  expressions[141] = BinaryenUnary(the_module, 63, expressions[140]);
-  expressions[142] = BinaryenConst(the_module, BinaryenLiteralFloat32(-33.612));
-  expressions[143] = BinaryenUnary(the_module, 64, expressions[142]);
-  expressions[144] = BinaryenConst(the_module, BinaryenLiteralFloat64(-9005.84));
-  expressions[145] = BinaryenUnary(the_module, 65, expressions[144]);
+  expressions[141] = BinaryenUnary(the_module, 46, expressions[140]);
+  expressions[142] = BinaryenConst(the_module, BinaryenLiteralInt32(-10));
+  expressions[143] = BinaryenUnary(the_module, 60, expressions[142]);
+  expressions[144] = BinaryenConst(the_module, BinaryenLiteralInt32(-10));
+  expressions[145] = BinaryenUnary(the_module, 61, expressions[144]);
+  expressions[146] = BinaryenConst(the_module, BinaryenLiteralInt32(-10));
+  expressions[147] = BinaryenUnary(the_module, 62, expressions[146]);
+  expressions[148] = BinaryenConst(the_module, BinaryenLiteralInt64(-22));
+  expressions[149] = BinaryenUnary(the_module, 63, expressions[148]);
+  expressions[150] = BinaryenConst(the_module, BinaryenLiteralFloat32(-33.612));
+  expressions[151] = BinaryenUnary(the_module, 64, expressions[150]);
+  expressions[152] = BinaryenConst(the_module, BinaryenLiteralFloat64(-9005.84));
+  expressions[153] = BinaryenUnary(the_module, 65, expressions[152]);
   {
     uint8_t t2[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[146] = BinaryenConst(the_module, BinaryenLiteralVec128(t2));
+    expressions[154] = BinaryenConst(the_module, BinaryenLiteralVec128(t2));
   }
-  expressions[147] = BinaryenUnary(the_module, 66, expressions[146]);
+  expressions[155] = BinaryenUnary(the_module, 66, expressions[154]);
   {
     uint8_t t3[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[148] = BinaryenConst(the_module, BinaryenLiteralVec128(t3));
+    expressions[156] = BinaryenConst(the_module, BinaryenLiteralVec128(t3));
   }
-  expressions[149] = BinaryenUnary(the_module, 67, expressions[148]);
+  expressions[157] = BinaryenUnary(the_module, 67, expressions[156]);
   {
     uint8_t t4[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[150] = BinaryenConst(the_module, BinaryenLiteralVec128(t4));
+    expressions[158] = BinaryenConst(the_module, BinaryenLiteralVec128(t4));
   }
-  expressions[151] = BinaryenUnary(the_module, 68, expressions[150]);
+  expressions[159] = BinaryenUnary(the_module, 68, expressions[158]);
   {
     uint8_t t5[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[152] = BinaryenConst(the_module, BinaryenLiteralVec128(t5));
+    expressions[160] = BinaryenConst(the_module, BinaryenLiteralVec128(t5));
   }
-  expressions[153] = BinaryenUnary(the_module, 69, expressions[152]);
+  expressions[161] = BinaryenUnary(the_module, 69, expressions[160]);
   {
     uint8_t t6[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[154] = BinaryenConst(the_module, BinaryenLiteralVec128(t6));
+    expressions[162] = BinaryenConst(the_module, BinaryenLiteralVec128(t6));
   }
-  expressions[155] = BinaryenUnary(the_module, 70, expressions[154]);
+  expressions[163] = BinaryenUnary(the_module, 70, expressions[162]);
   {
     uint8_t t7[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[156] = BinaryenConst(the_module, BinaryenLiteralVec128(t7));
+    expressions[164] = BinaryenConst(the_module, BinaryenLiteralVec128(t7));
   }
-  expressions[157] = BinaryenUnary(the_module, 71, expressions[156]);
+  expressions[165] = BinaryenUnary(the_module, 71, expressions[164]);
   {
     uint8_t t8[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[158] = BinaryenConst(the_module, BinaryenLiteralVec128(t8));
+    expressions[166] = BinaryenConst(the_module, BinaryenLiteralVec128(t8));
   }
-  expressions[159] = BinaryenUnary(the_module, 72, expressions[158]);
+  expressions[167] = BinaryenUnary(the_module, 72, expressions[166]);
   {
     uint8_t t9[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[160] = BinaryenConst(the_module, BinaryenLiteralVec128(t9));
+    expressions[168] = BinaryenConst(the_module, BinaryenLiteralVec128(t9));
   }
-  expressions[161] = BinaryenUnary(the_module, 73, expressions[160]);
+  expressions[169] = BinaryenUnary(the_module, 73, expressions[168]);
   {
     uint8_t t10[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[162] = BinaryenConst(the_module, BinaryenLiteralVec128(t10));
+    expressions[170] = BinaryenConst(the_module, BinaryenLiteralVec128(t10));
   }
-  expressions[163] = BinaryenUnary(the_module, 74, expressions[162]);
+  expressions[171] = BinaryenUnary(the_module, 74, expressions[170]);
   {
     uint8_t t11[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[164] = BinaryenConst(the_module, BinaryenLiteralVec128(t11));
+    expressions[172] = BinaryenConst(the_module, BinaryenLiteralVec128(t11));
   }
-  expressions[165] = BinaryenUnary(the_module, 75, expressions[164]);
+  expressions[173] = BinaryenUnary(the_module, 75, expressions[172]);
   {
     uint8_t t12[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[166] = BinaryenConst(the_module, BinaryenLiteralVec128(t12));
+    expressions[174] = BinaryenConst(the_module, BinaryenLiteralVec128(t12));
   }
-  expressions[167] = BinaryenUnary(the_module, 76, expressions[166]);
+  expressions[175] = BinaryenUnary(the_module, 76, expressions[174]);
   {
     uint8_t t13[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[168] = BinaryenConst(the_module, BinaryenLiteralVec128(t13));
+    expressions[176] = BinaryenConst(the_module, BinaryenLiteralVec128(t13));
   }
-  expressions[169] = BinaryenUnary(the_module, 77, expressions[168]);
+  expressions[177] = BinaryenUnary(the_module, 77, expressions[176]);
   {
     uint8_t t14[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[170] = BinaryenConst(the_module, BinaryenLiteralVec128(t14));
+    expressions[178] = BinaryenConst(the_module, BinaryenLiteralVec128(t14));
   }
-  expressions[171] = BinaryenUnary(the_module, 78, expressions[170]);
+  expressions[179] = BinaryenUnary(the_module, 78, expressions[178]);
   {
     uint8_t t15[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[172] = BinaryenConst(the_module, BinaryenLiteralVec128(t15));
+    expressions[180] = BinaryenConst(the_module, BinaryenLiteralVec128(t15));
   }
-  expressions[173] = BinaryenUnary(the_module, 79, expressions[172]);
+  expressions[181] = BinaryenUnary(the_module, 79, expressions[180]);
   {
     uint8_t t16[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[174] = BinaryenConst(the_module, BinaryenLiteralVec128(t16));
+    expressions[182] = BinaryenConst(the_module, BinaryenLiteralVec128(t16));
   }
-  expressions[175] = BinaryenUnary(the_module, 80, expressions[174]);
+  expressions[183] = BinaryenUnary(the_module, 80, expressions[182]);
   {
     uint8_t t17[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[176] = BinaryenConst(the_module, BinaryenLiteralVec128(t17));
+    expressions[184] = BinaryenConst(the_module, BinaryenLiteralVec128(t17));
   }
-  expressions[177] = BinaryenUnary(the_module, 81, expressions[176]);
+  expressions[185] = BinaryenUnary(the_module, 81, expressions[184]);
   {
     uint8_t t18[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[178] = BinaryenConst(the_module, BinaryenLiteralVec128(t18));
+    expressions[186] = BinaryenConst(the_module, BinaryenLiteralVec128(t18));
   }
-  expressions[179] = BinaryenUnary(the_module, 82, expressions[178]);
+  expressions[187] = BinaryenUnary(the_module, 82, expressions[186]);
   {
     uint8_t t19[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[180] = BinaryenConst(the_module, BinaryenLiteralVec128(t19));
+    expressions[188] = BinaryenConst(the_module, BinaryenLiteralVec128(t19));
   }
-  expressions[181] = BinaryenUnary(the_module, 83, expressions[180]);
+  expressions[189] = BinaryenUnary(the_module, 83, expressions[188]);
   {
     uint8_t t20[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[182] = BinaryenConst(the_module, BinaryenLiteralVec128(t20));
+    expressions[190] = BinaryenConst(the_module, BinaryenLiteralVec128(t20));
   }
-  expressions[183] = BinaryenUnary(the_module, 84, expressions[182]);
+  expressions[191] = BinaryenUnary(the_module, 84, expressions[190]);
   {
     uint8_t t21[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[184] = BinaryenConst(the_module, BinaryenLiteralVec128(t21));
+    expressions[192] = BinaryenConst(the_module, BinaryenLiteralVec128(t21));
   }
-  expressions[185] = BinaryenUnary(the_module, 85, expressions[184]);
+  expressions[193] = BinaryenUnary(the_module, 85, expressions[192]);
   {
     uint8_t t22[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[186] = BinaryenConst(the_module, BinaryenLiteralVec128(t22));
+    expressions[194] = BinaryenConst(the_module, BinaryenLiteralVec128(t22));
   }
-  expressions[187] = BinaryenUnary(the_module, 86, expressions[186]);
+  expressions[195] = BinaryenUnary(the_module, 86, expressions[194]);
   {
     uint8_t t23[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[188] = BinaryenConst(the_module, BinaryenLiteralVec128(t23));
+    expressions[196] = BinaryenConst(the_module, BinaryenLiteralVec128(t23));
   }
-  expressions[189] = BinaryenUnary(the_module, 87, expressions[188]);
+  expressions[197] = BinaryenUnary(the_module, 87, expressions[196]);
   {
     uint8_t t24[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[190] = BinaryenConst(the_module, BinaryenLiteralVec128(t24));
+    expressions[198] = BinaryenConst(the_module, BinaryenLiteralVec128(t24));
   }
-  expressions[191] = BinaryenUnary(the_module, 88, expressions[190]);
+  expressions[199] = BinaryenUnary(the_module, 88, expressions[198]);
   {
     uint8_t t25[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[192] = BinaryenConst(the_module, BinaryenLiteralVec128(t25));
+    expressions[200] = BinaryenConst(the_module, BinaryenLiteralVec128(t25));
   }
-  expressions[193] = BinaryenUnary(the_module, 89, expressions[192]);
+  expressions[201] = BinaryenUnary(the_module, 89, expressions[200]);
   {
     uint8_t t26[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[194] = BinaryenConst(the_module, BinaryenLiteralVec128(t26));
+    expressions[202] = BinaryenConst(the_module, BinaryenLiteralVec128(t26));
   }
-  expressions[195] = BinaryenUnary(the_module, 90, expressions[194]);
+  expressions[203] = BinaryenUnary(the_module, 90, expressions[202]);
   {
     uint8_t t27[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[196] = BinaryenConst(the_module, BinaryenLiteralVec128(t27));
+    expressions[204] = BinaryenConst(the_module, BinaryenLiteralVec128(t27));
   }
-  expressions[197] = BinaryenUnary(the_module, 91, expressions[196]);
+  expressions[205] = BinaryenUnary(the_module, 91, expressions[204]);
   {
     uint8_t t28[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[198] = BinaryenConst(the_module, BinaryenLiteralVec128(t28));
+    expressions[206] = BinaryenConst(the_module, BinaryenLiteralVec128(t28));
   }
-  expressions[199] = BinaryenUnary(the_module, 92, expressions[198]);
+  expressions[207] = BinaryenUnary(the_module, 92, expressions[206]);
   {
     uint8_t t29[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[200] = BinaryenConst(the_module, BinaryenLiteralVec128(t29));
+    expressions[208] = BinaryenConst(the_module, BinaryenLiteralVec128(t29));
   }
-  expressions[201] = BinaryenUnary(the_module, 93, expressions[200]);
+  expressions[209] = BinaryenUnary(the_module, 93, expressions[208]);
   {
     uint8_t t30[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[202] = BinaryenConst(the_module, BinaryenLiteralVec128(t30));
+    expressions[210] = BinaryenConst(the_module, BinaryenLiteralVec128(t30));
   }
-  expressions[203] = BinaryenUnary(the_module, 94, expressions[202]);
+  expressions[211] = BinaryenUnary(the_module, 94, expressions[210]);
   {
     uint8_t t31[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[204] = BinaryenConst(the_module, BinaryenLiteralVec128(t31));
+    expressions[212] = BinaryenConst(the_module, BinaryenLiteralVec128(t31));
   }
-  expressions[205] = BinaryenUnary(the_module, 95, expressions[204]);
+  expressions[213] = BinaryenUnary(the_module, 95, expressions[212]);
   {
     uint8_t t32[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[206] = BinaryenConst(the_module, BinaryenLiteralVec128(t32));
+    expressions[214] = BinaryenConst(the_module, BinaryenLiteralVec128(t32));
   }
-  expressions[207] = BinaryenUnary(the_module, 96, expressions[206]);
+  expressions[215] = BinaryenUnary(the_module, 96, expressions[214]);
   {
     uint8_t t33[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[208] = BinaryenConst(the_module, BinaryenLiteralVec128(t33));
+    expressions[216] = BinaryenConst(the_module, BinaryenLiteralVec128(t33));
   }
-  expressions[209] = BinaryenUnary(the_module, 97, expressions[208]);
+  expressions[217] = BinaryenUnary(the_module, 97, expressions[216]);
   {
     uint8_t t34[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[210] = BinaryenConst(the_module, BinaryenLiteralVec128(t34));
+    expressions[218] = BinaryenConst(the_module, BinaryenLiteralVec128(t34));
   }
-  expressions[211] = BinaryenUnary(the_module, 98, expressions[210]);
+  expressions[219] = BinaryenUnary(the_module, 98, expressions[218]);
   {
     uint8_t t35[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[212] = BinaryenConst(the_module, BinaryenLiteralVec128(t35));
+    expressions[220] = BinaryenConst(the_module, BinaryenLiteralVec128(t35));
   }
-  expressions[213] = BinaryenUnary(the_module, 99, expressions[212]);
+  expressions[221] = BinaryenUnary(the_module, 99, expressions[220]);
   {
     uint8_t t36[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[214] = BinaryenConst(the_module, BinaryenLiteralVec128(t36));
+    expressions[222] = BinaryenConst(the_module, BinaryenLiteralVec128(t36));
   }
-  expressions[215] = BinaryenUnary(the_module, 100, expressions[214]);
+  expressions[223] = BinaryenUnary(the_module, 100, expressions[222]);
   {
     uint8_t t37[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[216] = BinaryenConst(the_module, BinaryenLiteralVec128(t37));
+    expressions[224] = BinaryenConst(the_module, BinaryenLiteralVec128(t37));
   }
-  expressions[217] = BinaryenUnary(the_module, 101, expressions[216]);
+  expressions[225] = BinaryenUnary(the_module, 101, expressions[224]);
   {
     uint8_t t38[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[218] = BinaryenConst(the_module, BinaryenLiteralVec128(t38));
+    expressions[226] = BinaryenConst(the_module, BinaryenLiteralVec128(t38));
   }
-  expressions[219] = BinaryenUnary(the_module, 102, expressions[218]);
+  expressions[227] = BinaryenUnary(the_module, 102, expressions[226]);
   {
     uint8_t t39[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[220] = BinaryenConst(the_module, BinaryenLiteralVec128(t39));
+    expressions[228] = BinaryenConst(the_module, BinaryenLiteralVec128(t39));
   }
-  expressions[221] = BinaryenUnary(the_module, 103, expressions[220]);
+  expressions[229] = BinaryenUnary(the_module, 103, expressions[228]);
   {
     uint8_t t40[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[222] = BinaryenConst(the_module, BinaryenLiteralVec128(t40));
+    expressions[230] = BinaryenConst(the_module, BinaryenLiteralVec128(t40));
   }
-  expressions[223] = BinaryenUnary(the_module, 104, expressions[222]);
+  expressions[231] = BinaryenUnary(the_module, 104, expressions[230]);
   {
     uint8_t t41[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[224] = BinaryenConst(the_module, BinaryenLiteralVec128(t41));
+    expressions[232] = BinaryenConst(the_module, BinaryenLiteralVec128(t41));
   }
-  expressions[225] = BinaryenUnary(the_module, 105, expressions[224]);
+  expressions[233] = BinaryenUnary(the_module, 105, expressions[232]);
   {
     uint8_t t42[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[226] = BinaryenConst(the_module, BinaryenLiteralVec128(t42));
-  }
-  expressions[227] = BinaryenUnary(the_module, 106, expressions[226]);
-  expressions[228] = BinaryenConst(the_module, BinaryenLiteralInt32(-11));
-  expressions[229] = BinaryenConst(the_module, BinaryenLiteralInt32(-10));
-  expressions[230] = BinaryenBinary(the_module, 0, expressions[229], expressions[228]);
-  expressions[231] = BinaryenConst(the_module, BinaryenLiteralFloat64(-9007.33));
-  expressions[232] = BinaryenConst(the_module, BinaryenLiteralFloat64(-9005.84));
-  expressions[233] = BinaryenBinary(the_module, 64, expressions[232], expressions[231]);
-  expressions[234] = BinaryenConst(the_module, BinaryenLiteralInt32(-11));
-  expressions[235] = BinaryenConst(the_module, BinaryenLiteralInt32(-10));
-  expressions[236] = BinaryenBinary(the_module, 3, expressions[235], expressions[234]);
-  expressions[237] = BinaryenConst(the_module, BinaryenLiteralInt64(-23));
-  expressions[238] = BinaryenConst(the_module, BinaryenLiteralInt64(-22));
-  expressions[239] = BinaryenBinary(the_module, 29, expressions[238], expressions[237]);
-  expressions[240] = BinaryenConst(the_module, BinaryenLiteralInt64(-23));
-  expressions[241] = BinaryenConst(the_module, BinaryenLiteralInt64(-22));
-  expressions[242] = BinaryenBinary(the_module, 30, expressions[241], expressions[240]);
-  expressions[243] = BinaryenConst(the_module, BinaryenLiteralInt32(-11));
-  expressions[244] = BinaryenConst(the_module, BinaryenLiteralInt32(-10));
-  expressions[245] = BinaryenBinary(the_module, 6, expressions[244], expressions[243]);
-  expressions[246] = BinaryenConst(the_module, BinaryenLiteralInt32(-11));
-  expressions[247] = BinaryenConst(the_module, BinaryenLiteralInt32(-10));
-  expressions[248] = BinaryenBinary(the_module, 7, expressions[247], expressions[246]);
-  expressions[249] = BinaryenConst(the_module, BinaryenLiteralInt64(-23));
-  expressions[250] = BinaryenConst(the_module, BinaryenLiteralInt64(-22));
-  expressions[251] = BinaryenBinary(the_module, 33, expressions[250], expressions[249]);
-  expressions[252] = BinaryenConst(the_module, BinaryenLiteralInt32(-11));
-  expressions[253] = BinaryenConst(the_module, BinaryenLiteralInt32(-10));
-  expressions[254] = BinaryenBinary(the_module, 9, expressions[253], expressions[252]);
-  expressions[255] = BinaryenConst(the_module, BinaryenLiteralInt64(-23));
-  expressions[256] = BinaryenConst(the_module, BinaryenLiteralInt64(-22));
-  expressions[257] = BinaryenBinary(the_module, 35, expressions[256], expressions[255]);
-  expressions[258] = BinaryenConst(the_module, BinaryenLiteralInt64(-23));
-  expressions[259] = BinaryenConst(the_module, BinaryenLiteralInt64(-22));
-  expressions[260] = BinaryenBinary(the_module, 36, expressions[259], expressions[258]);
-  expressions[261] = BinaryenConst(the_module, BinaryenLiteralInt32(-11));
-  expressions[262] = BinaryenConst(the_module, BinaryenLiteralInt32(-10));
-  expressions[263] = BinaryenBinary(the_module, 12, expressions[262], expressions[261]);
-  expressions[264] = BinaryenConst(the_module, BinaryenLiteralInt32(-11));
-  expressions[265] = BinaryenConst(the_module, BinaryenLiteralInt32(-10));
-  expressions[266] = BinaryenBinary(the_module, 13, expressions[265], expressions[264]);
-  expressions[267] = BinaryenConst(the_module, BinaryenLiteralInt64(-23));
-  expressions[268] = BinaryenConst(the_module, BinaryenLiteralInt64(-22));
-  expressions[269] = BinaryenBinary(the_module, 39, expressions[268], expressions[267]);
-  expressions[270] = BinaryenConst(the_module, BinaryenLiteralFloat32(-62.5));
-  expressions[271] = BinaryenConst(the_module, BinaryenLiteralFloat32(-33.612));
-  expressions[272] = BinaryenBinary(the_module, 53, expressions[271], expressions[270]);
-  expressions[273] = BinaryenConst(the_module, BinaryenLiteralFloat64(-9007.33));
-  expressions[274] = BinaryenConst(the_module, BinaryenLiteralFloat64(-9005.84));
-  expressions[275] = BinaryenBinary(the_module, 67, expressions[274], expressions[273]);
-  expressions[276] = BinaryenConst(the_module, BinaryenLiteralFloat32(-62.5));
-  expressions[277] = BinaryenConst(the_module, BinaryenLiteralFloat32(-33.612));
-  expressions[278] = BinaryenBinary(the_module, 55, expressions[277], expressions[276]);
-  expressions[279] = BinaryenConst(the_module, BinaryenLiteralFloat64(-9007.33));
-  expressions[280] = BinaryenConst(the_module, BinaryenLiteralFloat64(-9005.84));
-  expressions[281] = BinaryenBinary(the_module, 69, expressions[280], expressions[279]);
-  expressions[282] = BinaryenConst(the_module, BinaryenLiteralInt32(-11));
-  expressions[283] = BinaryenConst(the_module, BinaryenLiteralInt32(-10));
-  expressions[284] = BinaryenBinary(the_module, 15, expressions[283], expressions[282]);
-  expressions[285] = BinaryenConst(the_module, BinaryenLiteralFloat32(-62.5));
-  expressions[286] = BinaryenConst(the_module, BinaryenLiteralFloat32(-33.612));
-  expressions[287] = BinaryenBinary(the_module, 58, expressions[286], expressions[285]);
-  expressions[288] = BinaryenConst(the_module, BinaryenLiteralInt32(-11));
-  expressions[289] = BinaryenConst(the_module, BinaryenLiteralInt32(-10));
-  expressions[290] = BinaryenBinary(the_module, 17, expressions[289], expressions[288]);
-  expressions[291] = BinaryenConst(the_module, BinaryenLiteralInt64(-23));
-  expressions[292] = BinaryenConst(the_module, BinaryenLiteralInt64(-22));
-  expressions[293] = BinaryenBinary(the_module, 43, expressions[292], expressions[291]);
-  expressions[294] = BinaryenConst(the_module, BinaryenLiteralInt64(-23));
-  expressions[295] = BinaryenConst(the_module, BinaryenLiteralInt64(-22));
-  expressions[296] = BinaryenBinary(the_module, 44, expressions[295], expressions[294]);
-  expressions[297] = BinaryenConst(the_module, BinaryenLiteralInt32(-11));
-  expressions[298] = BinaryenConst(the_module, BinaryenLiteralInt32(-10));
-  expressions[299] = BinaryenBinary(the_module, 20, expressions[298], expressions[297]);
-  expressions[300] = BinaryenConst(the_module, BinaryenLiteralInt64(-23));
-  expressions[301] = BinaryenConst(the_module, BinaryenLiteralInt64(-22));
-  expressions[302] = BinaryenBinary(the_module, 46, expressions[301], expressions[300]);
-  expressions[303] = BinaryenConst(the_module, BinaryenLiteralInt32(-11));
-  expressions[304] = BinaryenConst(the_module, BinaryenLiteralInt32(-10));
-  expressions[305] = BinaryenBinary(the_module, 22, expressions[304], expressions[303]);
-  expressions[306] = BinaryenConst(the_module, BinaryenLiteralInt32(-11));
-  expressions[307] = BinaryenConst(the_module, BinaryenLiteralInt32(-10));
-  expressions[308] = BinaryenBinary(the_module, 23, expressions[307], expressions[306]);
-  expressions[309] = BinaryenConst(the_module, BinaryenLiteralInt64(-23));
-  expressions[310] = BinaryenConst(the_module, BinaryenLiteralInt64(-22));
-  expressions[311] = BinaryenBinary(the_module, 49, expressions[310], expressions[309]);
-  expressions[312] = BinaryenConst(the_module, BinaryenLiteralFloat32(-62.5));
-  expressions[313] = BinaryenConst(the_module, BinaryenLiteralFloat32(-33.612));
-  expressions[314] = BinaryenBinary(the_module, 59, expressions[313], expressions[312]);
-  expressions[315] = BinaryenConst(the_module, BinaryenLiteralFloat64(-9007.33));
-  expressions[316] = BinaryenConst(the_module, BinaryenLiteralFloat64(-9005.84));
-  expressions[317] = BinaryenBinary(the_module, 73, expressions[316], expressions[315]);
-  expressions[318] = BinaryenConst(the_module, BinaryenLiteralFloat64(-9007.33));
-  expressions[319] = BinaryenConst(the_module, BinaryenLiteralFloat64(-9005.84));
-  expressions[320] = BinaryenBinary(the_module, 74, expressions[319], expressions[318]);
-  expressions[321] = BinaryenConst(the_module, BinaryenLiteralFloat32(-62.5));
-  expressions[322] = BinaryenConst(the_module, BinaryenLiteralFloat32(-33.612));
-  expressions[323] = BinaryenBinary(the_module, 62, expressions[322], expressions[321]);
+    expressions[234] = BinaryenConst(the_module, BinaryenLiteralVec128(t42));
+  }
+  expressions[235] = BinaryenUnary(the_module, 106, expressions[234]);
+  expressions[236] = BinaryenConst(the_module, BinaryenLiteralInt32(-11));
+  expressions[237] = BinaryenConst(the_module, BinaryenLiteralInt32(-10));
+  expressions[238] = BinaryenBinary(the_module, 0, expressions[237], expressions[236]);
+  expressions[239] = BinaryenConst(the_module, BinaryenLiteralFloat64(-9007.33));
+  expressions[240] = BinaryenConst(the_module, BinaryenLiteralFloat64(-9005.84));
+  expressions[241] = BinaryenBinary(the_module, 64, expressions[240], expressions[239]);
+  expressions[242] = BinaryenConst(the_module, BinaryenLiteralInt32(-11));
+  expressions[243] = BinaryenConst(the_module, BinaryenLiteralInt32(-10));
+  expressions[244] = BinaryenBinary(the_module, 3, expressions[243], expressions[242]);
+  expressions[245] = BinaryenConst(the_module, BinaryenLiteralInt64(-23));
+  expressions[246] = BinaryenConst(the_module, BinaryenLiteralInt64(-22));
+  expressions[247] = BinaryenBinary(the_module, 29, expressions[246], expressions[245]);
+  expressions[248] = BinaryenConst(the_module, BinaryenLiteralInt64(-23));
+  expressions[249] = BinaryenConst(the_module, BinaryenLiteralInt64(-22));
+  expressions[250] = BinaryenBinary(the_module, 30, expressions[249], expressions[248]);
+  expressions[251] = BinaryenConst(the_module, BinaryenLiteralInt32(-11));
+  expressions[252] = BinaryenConst(the_module, BinaryenLiteralInt32(-10));
+  expressions[253] = BinaryenBinary(the_module, 6, expressions[252], expressions[251]);
+  expressions[254] = BinaryenConst(the_module, BinaryenLiteralInt32(-11));
+  expressions[255] = BinaryenConst(the_module, BinaryenLiteralInt32(-10));
+  expressions[256] = BinaryenBinary(the_module, 7, expressions[255], expressions[254]);
+  expressions[257] = BinaryenConst(the_module, BinaryenLiteralInt64(-23));
+  expressions[258] = BinaryenConst(the_module, BinaryenLiteralInt64(-22));
+  expressions[259] = BinaryenBinary(the_module, 33, expressions[258], expressions[257]);
+  expressions[260] = BinaryenConst(the_module, BinaryenLiteralInt32(-11));
+  expressions[261] = BinaryenConst(the_module, BinaryenLiteralInt32(-10));
+  expressions[262] = BinaryenBinary(the_module, 9, expressions[261], expressions[260]);
+  expressions[263] = BinaryenConst(the_module, BinaryenLiteralInt64(-23));
+  expressions[264] = BinaryenConst(the_module, BinaryenLiteralInt64(-22));
+  expressions[265] = BinaryenBinary(the_module, 35, expressions[264], expressions[263]);
+  expressions[266] = BinaryenConst(the_module, BinaryenLiteralInt64(-23));
+  expressions[267] = BinaryenConst(the_module, BinaryenLiteralInt64(-22));
+  expressions[268] = BinaryenBinary(the_module, 36, expressions[267], expressions[266]);
+  expressions[269] = BinaryenConst(the_module, BinaryenLiteralInt32(-11));
+  expressions[270] = BinaryenConst(the_module, BinaryenLiteralInt32(-10));
+  expressions[271] = BinaryenBinary(the_module, 12, expressions[270], expressions[269]);
+  expressions[272] = BinaryenConst(the_module, BinaryenLiteralInt32(-11));
+  expressions[273] = BinaryenConst(the_module, BinaryenLiteralInt32(-10));
+  expressions[274] = BinaryenBinary(the_module, 13, expressions[273], expressions[272]);
+  expressions[275] = BinaryenConst(the_module, BinaryenLiteralInt64(-23));
+  expressions[276] = BinaryenConst(the_module, BinaryenLiteralInt64(-22));
+  expressions[277] = BinaryenBinary(the_module, 39, expressions[276], expressions[275]);
+  expressions[278] = BinaryenConst(the_module, BinaryenLiteralFloat32(-62.5));
+  expressions[279] = BinaryenConst(the_module, BinaryenLiteralFloat32(-33.612));
+  expressions[280] = BinaryenBinary(the_module, 53, expressions[279], expressions[278]);
+  expressions[281] = BinaryenConst(the_module, BinaryenLiteralFloat64(-9007.33));
+  expressions[282] = BinaryenConst(the_module, BinaryenLiteralFloat64(-9005.84));
+  expressions[283] = BinaryenBinary(the_module, 67, expressions[282], expressions[281]);
+  expressions[284] = BinaryenConst(the_module, BinaryenLiteralFloat32(-62.5));
+  expressions[285] = BinaryenConst(the_module, BinaryenLiteralFloat32(-33.612));
+  expressions[286] = BinaryenBinary(the_module, 55, expressions[285], expressions[284]);
+  expressions[287] = BinaryenConst(the_module, BinaryenLiteralFloat64(-9007.33));
+  expressions[288] = BinaryenConst(the_module, BinaryenLiteralFloat64(-9005.84));
+  expressions[289] = BinaryenBinary(the_module, 69, expressions[288], expressions[287]);
+  expressions[290] = BinaryenConst(the_module, BinaryenLiteralInt32(-11));
+  expressions[291] = BinaryenConst(the_module, BinaryenLiteralInt32(-10));
+  expressions[292] = BinaryenBinary(the_module, 15, expressions[291], expressions[290]);
+  expressions[293] = BinaryenConst(the_module, BinaryenLiteralFloat32(-62.5));
+  expressions[294] = BinaryenConst(the_module, BinaryenLiteralFloat32(-33.612));
+  expressions[295] = BinaryenBinary(the_module, 58, expressions[294], expressions[293]);
+  expressions[296] = BinaryenConst(the_module, BinaryenLiteralInt32(-11));
+  expressions[297] = BinaryenConst(the_module, BinaryenLiteralInt32(-10));
+  expressions[298] = BinaryenBinary(the_module, 17, expressions[297], expressions[296]);
+  expressions[299] = BinaryenConst(the_module, BinaryenLiteralInt64(-23));
+  expressions[300] = BinaryenConst(the_module, BinaryenLiteralInt64(-22));
+  expressions[301] = BinaryenBinary(the_module, 43, expressions[300], expressions[299]);
+  expressions[302] = BinaryenConst(the_module, BinaryenLiteralInt64(-23));
+  expressions[303] = BinaryenConst(the_module, BinaryenLiteralInt64(-22));
+  expressions[304] = BinaryenBinary(the_module, 44, expressions[303], expressions[302]);
+  expressions[305] = BinaryenConst(the_module, BinaryenLiteralInt32(-11));
+  expressions[306] = BinaryenConst(the_module, BinaryenLiteralInt32(-10));
+  expressions[307] = BinaryenBinary(the_module, 20, expressions[306], expressions[305]);
+  expressions[308] = BinaryenConst(the_module, BinaryenLiteralInt64(-23));
+  expressions[309] = BinaryenConst(the_module, BinaryenLiteralInt64(-22));
+  expressions[310] = BinaryenBinary(the_module, 46, expressions[309], expressions[308]);
+  expressions[311] = BinaryenConst(the_module, BinaryenLiteralInt32(-11));
+  expressions[312] = BinaryenConst(the_module, BinaryenLiteralInt32(-10));
+  expressions[313] = BinaryenBinary(the_module, 22, expressions[312], expressions[311]);
+  expressions[314] = BinaryenConst(the_module, BinaryenLiteralInt32(-11));
+  expressions[315] = BinaryenConst(the_module, BinaryenLiteralInt32(-10));
+  expressions[316] = BinaryenBinary(the_module, 23, expressions[315], expressions[314]);
+  expressions[317] = BinaryenConst(the_module, BinaryenLiteralInt64(-23));
+  expressions[318] = BinaryenConst(the_module, BinaryenLiteralInt64(-22));
+  expressions[319] = BinaryenBinary(the_module, 49, expressions[318], expressions[317]);
+  expressions[320] = BinaryenConst(the_module, BinaryenLiteralFloat32(-62.5));
+  expressions[321] = BinaryenConst(the_module, BinaryenLiteralFloat32(-33.612));
+  expressions[322] = BinaryenBinary(the_module, 59, expressions[321], expressions[320]);
+  expressions[323] = BinaryenConst(the_module, BinaryenLiteralFloat64(-9007.33));
+  expressions[324] = BinaryenConst(the_module, BinaryenLiteralFloat64(-9005.84));
+  expressions[325] = BinaryenBinary(the_module, 73, expressions[324], expressions[323]);
+  expressions[326] = BinaryenConst(the_module, BinaryenLiteralFloat64(-9007.33));
+  expressions[327] = BinaryenConst(the_module, BinaryenLiteralFloat64(-9005.84));
+  expressions[328] = BinaryenBinary(the_module, 74, expressions[327], expressions[326]);
+  expressions[329] = BinaryenConst(the_module, BinaryenLiteralFloat32(-62.5));
+  expressions[330] = BinaryenConst(the_module, BinaryenLiteralFloat32(-33.612));
+  expressions[331] = BinaryenBinary(the_module, 62, expressions[330], expressions[329]);
   {
     uint8_t t43[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[324] = BinaryenConst(the_module, BinaryenLiteralVec128(t43));
+    expressions[332] = BinaryenConst(the_module, BinaryenLiteralVec128(t43));
   }
   {
     uint8_t t44[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[325] = BinaryenConst(the_module, BinaryenLiteralVec128(t44));
+    expressions[333] = BinaryenConst(the_module, BinaryenLiteralVec128(t44));
   }
-  expressions[326] = BinaryenBinary(the_module, 76, expressions[325], expressions[324]);
+  expressions[334] = BinaryenBinary(the_module, 76, expressions[333], expressions[332]);
   {
     uint8_t t45[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[327] = BinaryenConst(the_module, BinaryenLiteralVec128(t45));
+    expressions[335] = BinaryenConst(the_module, BinaryenLiteralVec128(t45));
   }
   {
     uint8_t t46[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[328] = BinaryenConst(the_module, BinaryenLiteralVec128(t46));
+    expressions[336] = BinaryenConst(the_module, BinaryenLiteralVec128(t46));
   }
-  expressions[329] = BinaryenBinary(the_module, 77, expressions[328], expressions[327]);
+  expressions[337] = BinaryenBinary(the_module, 77, expressions[336], expressions[335]);
   {
     uint8_t t47[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[330] = BinaryenConst(the_module, BinaryenLiteralVec128(t47));
+    expressions[338] = BinaryenConst(the_module, BinaryenLiteralVec128(t47));
   }
   {
     uint8_t t48[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[331] = BinaryenConst(the_module, BinaryenLiteralVec128(t48));
+    expressions[339] = BinaryenConst(the_module, BinaryenLiteralVec128(t48));
   }
-  expressions[332] = BinaryenBinary(the_module, 78, expressions[331], expressions[330]);
+  expressions[340] = BinaryenBinary(the_module, 78, expressions[339], expressions[338]);
   {
     uint8_t t49[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[333] = BinaryenConst(the_module, BinaryenLiteralVec128(t49));
+    expressions[341] = BinaryenConst(the_module, BinaryenLiteralVec128(t49));
   }
   {
     uint8_t t50[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[334] = BinaryenConst(the_module, BinaryenLiteralVec128(t50));
+    expressions[342] = BinaryenConst(the_module, BinaryenLiteralVec128(t50));
   }
-  expressions[335] = BinaryenBinary(the_module, 79, expressions[334], expressions[333]);
+  expressions[343] = BinaryenBinary(the_module, 79, expressions[342], expressions[341]);
   {
     uint8_t t51[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[336] = BinaryenConst(the_module, BinaryenLiteralVec128(t51));
+    expressions[344] = BinaryenConst(the_module, BinaryenLiteralVec128(t51));
   }
   {
     uint8_t t52[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[337] = BinaryenConst(the_module, BinaryenLiteralVec128(t52));
+    expressions[345] = BinaryenConst(the_module, BinaryenLiteralVec128(t52));
   }
-  expressions[338] = BinaryenBinary(the_module, 80, expressions[337], expressions[336]);
+  expressions[346] = BinaryenBinary(the_module, 80, expressions[345], expressions[344]);
   {
     uint8_t t53[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[339] = BinaryenConst(the_module, BinaryenLiteralVec128(t53));
+    expressions[347] = BinaryenConst(the_module, BinaryenLiteralVec128(t53));
   }
   {
     uint8_t t54[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[340] = BinaryenConst(the_module, BinaryenLiteralVec128(t54));
+    expressions[348] = BinaryenConst(the_module, BinaryenLiteralVec128(t54));
   }
-  expressions[341] = BinaryenBinary(the_module, 81, expressions[340], expressions[339]);
+  expressions[349] = BinaryenBinary(the_module, 81, expressions[348], expressions[347]);
   {
     uint8_t t55[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[342] = BinaryenConst(the_module, BinaryenLiteralVec128(t55));
+    expressions[350] = BinaryenConst(the_module, BinaryenLiteralVec128(t55));
   }
   {
     uint8_t t56[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[343] = BinaryenConst(the_module, BinaryenLiteralVec128(t56));
+    expressions[351] = BinaryenConst(the_module, BinaryenLiteralVec128(t56));
   }
-  expressions[344] = BinaryenBinary(the_module, 82, expressions[343], expressions[342]);
+  expressions[352] = BinaryenBinary(the_module, 82, expressions[351], expressions[350]);
   {
     uint8_t t57[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[345] = BinaryenConst(the_module, BinaryenLiteralVec128(t57));
+    expressions[353] = BinaryenConst(the_module, BinaryenLiteralVec128(t57));
   }
   {
     uint8_t t58[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[346] = BinaryenConst(the_module, BinaryenLiteralVec128(t58));
+    expressions[354] = BinaryenConst(the_module, BinaryenLiteralVec128(t58));
   }
-  expressions[347] = BinaryenBinary(the_module, 83, expressions[346], expressions[345]);
+  expressions[355] = BinaryenBinary(the_module, 83, expressions[354], expressions[353]);
   {
     uint8_t t59[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[348] = BinaryenConst(the_module, BinaryenLiteralVec128(t59));
+    expressions[356] = BinaryenConst(the_module, BinaryenLiteralVec128(t59));
   }
   {
     uint8_t t60[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[349] = BinaryenConst(the_module, BinaryenLiteralVec128(t60));
+    expressions[357] = BinaryenConst(the_module, BinaryenLiteralVec128(t60));
   }
-  expressions[350] = BinaryenBinary(the_module, 84, expressions[349], expressions[348]);
+  expressions[358] = BinaryenBinary(the_module, 84, expressions[357], expressions[356]);
   {
     uint8_t t61[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[351] = BinaryenConst(the_module, BinaryenLiteralVec128(t61));
+    expressions[359] = BinaryenConst(the_module, BinaryenLiteralVec128(t61));
   }
   {
     uint8_t t62[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[352] = BinaryenConst(the_module, BinaryenLiteralVec128(t62));
+    expressions[360] = BinaryenConst(the_module, BinaryenLiteralVec128(t62));
   }
-  expressions[353] = BinaryenBinary(the_module, 85, expressions[352], expressions[351]);
+  expressions[361] = BinaryenBinary(the_module, 85, expressions[360], expressions[359]);
   {
     uint8_t t63[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[354] = BinaryenConst(the_module, BinaryenLiteralVec128(t63));
+    expressions[362] = BinaryenConst(the_module, BinaryenLiteralVec128(t63));
   }
   {
     uint8_t t64[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[355] = BinaryenConst(the_module, BinaryenLiteralVec128(t64));
+    expressions[363] = BinaryenConst(the_module, BinaryenLiteralVec128(t64));
   }
-  expressions[356] = BinaryenBinary(the_module, 86, expressions[355], expressions[354]);
+  expressions[364] = BinaryenBinary(the_module, 86, expressions[363], expressions[362]);
   {
     uint8_t t65[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[357] = BinaryenConst(the_module, BinaryenLiteralVec128(t65));
+    expressions[365] = BinaryenConst(the_module, BinaryenLiteralVec128(t65));
   }
   {
     uint8_t t66[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[358] = BinaryenConst(the_module, BinaryenLiteralVec128(t66));
+    expressions[366] = BinaryenConst(the_module, BinaryenLiteralVec128(t66));
   }
-  expressions[359] = BinaryenBinary(the_module, 87, expressions[358], expressions[357]);
+  expressions[367] = BinaryenBinary(the_module, 87, expressions[366], expressions[365]);
   {
     uint8_t t67[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[360] = BinaryenConst(the_module, BinaryenLiteralVec128(t67));
+    expressions[368] = BinaryenConst(the_module, BinaryenLiteralVec128(t67));
   }
   {
     uint8_t t68[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[361] = BinaryenConst(the_module, BinaryenLiteralVec128(t68));
+    expressions[369] = BinaryenConst(the_module, BinaryenLiteralVec128(t68));
   }
-  expressions[362] = BinaryenBinary(the_module, 88, expressions[361], expressions[360]);
+  expressions[370] = BinaryenBinary(the_module, 88, expressions[369], expressions[368]);
   {
     uint8_t t69[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[363] = BinaryenConst(the_module, BinaryenLiteralVec128(t69));
+    expressions[371] = BinaryenConst(the_module, BinaryenLiteralVec128(t69));
   }
   {
     uint8_t t70[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[364] = BinaryenConst(the_module, BinaryenLiteralVec128(t70));
+    expressions[372] = BinaryenConst(the_module, BinaryenLiteralVec128(t70));
   }
-  expressions[365] = BinaryenBinary(the_module, 89, expressions[364], expressions[363]);
+  expressions[373] = BinaryenBinary(the_module, 89, expressions[372], expressions[371]);
   {
     uint8_t t71[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[366] = BinaryenConst(the_module, BinaryenLiteralVec128(t71));
+    expressions[374] = BinaryenConst(the_module, BinaryenLiteralVec128(t71));
   }
   {
     uint8_t t72[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[367] = BinaryenConst(the_module, BinaryenLiteralVec128(t72));
+    expressions[375] = BinaryenConst(the_module, BinaryenLiteralVec128(t72));
   }
-  expressions[368] = BinaryenBinary(the_module, 90, expressions[367], expressions[366]);
+  expressions[376] = BinaryenBinary(the_module, 90, expressions[375], expressions[374]);
   {
     uint8_t t73[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[369] = BinaryenConst(the_module, BinaryenLiteralVec128(t73));
+    expressions[377] = BinaryenConst(the_module, BinaryenLiteralVec128(t73));
   }
   {
     uint8_t t74[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[370] = BinaryenConst(the_module, BinaryenLiteralVec128(t74));
+    expressions[378] = BinaryenConst(the_module, BinaryenLiteralVec128(t74));
   }
-  expressions[371] = BinaryenBinary(the_module, 91, expressions[370], expressions[369]);
+  expressions[379] = BinaryenBinary(the_module, 91, expressions[378], expressions[377]);
   {
     uint8_t t75[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[372] = BinaryenConst(the_module, BinaryenLiteralVec128(t75));
+    expressions[380] = BinaryenConst(the_module, BinaryenLiteralVec128(t75));
   }
   {
     uint8_t t76[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[373] = BinaryenConst(the_module, BinaryenLiteralVec128(t76));
+    expressions[381] = BinaryenConst(the_module, BinaryenLiteralVec128(t76));
   }
-  expressions[374] = BinaryenBinary(the_module, 92, expressions[373], expressions[372]);
+  expressions[382] = BinaryenBinary(the_module, 92, expressions[381], expressions[380]);
   {
     uint8_t t77[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[375] = BinaryenConst(the_module, BinaryenLiteralVec128(t77));
+    expressions[383] = BinaryenConst(the_module, BinaryenLiteralVec128(t77));
   }
   {
     uint8_t t78[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[376] = BinaryenConst(the_module, BinaryenLiteralVec128(t78));
+    expressions[384] = BinaryenConst(the_module, BinaryenLiteralVec128(t78));
   }
-  expressions[377] = BinaryenBinary(the_module, 93, expressions[376], expressions[375]);
+  expressions[385] = BinaryenBinary(the_module, 93, expressions[384], expressions[383]);
   {
     uint8_t t79[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[378] = BinaryenConst(the_module, BinaryenLiteralVec128(t79));
+    expressions[386] = BinaryenConst(the_module, BinaryenLiteralVec128(t79));
   }
   {
     uint8_t t80[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[379] = BinaryenConst(the_module, BinaryenLiteralVec128(t80));
+    expressions[387] = BinaryenConst(the_module, BinaryenLiteralVec128(t80));
   }
-  expressions[380] = BinaryenBinary(the_module, 94, expressions[379], expressions[378]);
+  expressions[388] = BinaryenBinary(the_module, 94, expressions[387], expressions[386]);
   {
     uint8_t t81[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[381] = BinaryenConst(the_module, BinaryenLiteralVec128(t81));
+    expressions[389] = BinaryenConst(the_module, BinaryenLiteralVec128(t81));
   }
   {
     uint8_t t82[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[382] = BinaryenConst(the_module, BinaryenLiteralVec128(t82));
+    expressions[390] = BinaryenConst(the_module, BinaryenLiteralVec128(t82));
   }
-  expressions[383] = BinaryenBinary(the_module, 95, expressions[382], expressions[381]);
+  expressions[391] = BinaryenBinary(the_module, 95, expressions[390], expressions[389]);
   {
     uint8_t t83[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[384] = BinaryenConst(the_module, BinaryenLiteralVec128(t83));
+    expressions[392] = BinaryenConst(the_module, BinaryenLiteralVec128(t83));
   }
   {
     uint8_t t84[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[385] = BinaryenConst(the_module, BinaryenLiteralVec128(t84));
+    expressions[393] = BinaryenConst(the_module, BinaryenLiteralVec128(t84));
   }
-  expressions[386] = BinaryenBinary(the_module, 96, expressions[385], expressions[384]);
+  expressions[394] = BinaryenBinary(the_module, 96, expressions[393], expressions[392]);
   {
     uint8_t t85[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[387] = BinaryenConst(the_module, BinaryenLiteralVec128(t85));
+    expressions[395] = BinaryenConst(the_module, BinaryenLiteralVec128(t85));
   }
   {
     uint8_t t86[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[388] = BinaryenConst(the_module, BinaryenLiteralVec128(t86));
+    expressions[396] = BinaryenConst(the_module, BinaryenLiteralVec128(t86));
   }
-  expressions[389] = BinaryenBinary(the_module, 97, expressions[388], expressions[387]);
+  expressions[397] = BinaryenBinary(the_module, 97, expressions[396], expressions[395]);
   {
     uint8_t t87[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[390] = BinaryenConst(the_module, BinaryenLiteralVec128(t87));
+    expressions[398] = BinaryenConst(the_module, BinaryenLiteralVec128(t87));
   }
   {
     uint8_t t88[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[391] = BinaryenConst(the_module, BinaryenLiteralVec128(t88));
+    expressions[399] = BinaryenConst(the_module, BinaryenLiteralVec128(t88));
   }
-  expressions[392] = BinaryenBinary(the_module, 98, expressions[391], expressions[390]);
+  expressions[400] = BinaryenBinary(the_module, 98, expressions[399], expressions[398]);
   {
     uint8_t t89[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[393] = BinaryenConst(the_module, BinaryenLiteralVec128(t89));
+    expressions[401] = BinaryenConst(the_module, BinaryenLiteralVec128(t89));
   }
   {
     uint8_t t90[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[394] = BinaryenConst(the_module, BinaryenLiteralVec128(t90));
+    expressions[402] = BinaryenConst(the_module, BinaryenLiteralVec128(t90));
   }
-  expressions[395] = BinaryenBinary(the_module, 99, expressions[394], expressions[393]);
+  expressions[403] = BinaryenBinary(the_module, 99, expressions[402], expressions[401]);
   {
     uint8_t t91[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[396] = BinaryenConst(the_module, BinaryenLiteralVec128(t91));
+    expressions[404] = BinaryenConst(the_module, BinaryenLiteralVec128(t91));
   }
   {
     uint8_t t92[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[397] = BinaryenConst(the_module, BinaryenLiteralVec128(t92));
+    expressions[405] = BinaryenConst(the_module, BinaryenLiteralVec128(t92));
   }
-  expressions[398] = BinaryenBinary(the_module, 100, expressions[397], expressions[396]);
+  expressions[406] = BinaryenBinary(the_module, 100, expressions[405], expressions[404]);
   {
     uint8_t t93[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[399] = BinaryenConst(the_module, BinaryenLiteralVec128(t93));
+    expressions[407] = BinaryenConst(the_module, BinaryenLiteralVec128(t93));
   }
   {
     uint8_t t94[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[400] = BinaryenConst(the_module, BinaryenLiteralVec128(t94));
+    expressions[408] = BinaryenConst(the_module, BinaryenLiteralVec128(t94));
   }
-  expressions[401] = BinaryenBinary(the_module, 101, expressions[400], expressions[399]);
+  expressions[409] = BinaryenBinary(the_module, 101, expressions[408], expressions[407]);
   {
     uint8_t t95[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[402] = BinaryenConst(the_module, BinaryenLiteralVec128(t95));
+    expressions[410] = BinaryenConst(the_module, BinaryenLiteralVec128(t95));
   }
   {
     uint8_t t96[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[403] = BinaryenConst(the_module, BinaryenLiteralVec128(t96));
+    expressions[411] = BinaryenConst(the_module, BinaryenLiteralVec128(t96));
   }
-  expressions[404] = BinaryenBinary(the_module, 102, expressions[403], expressions[402]);
+  expressions[412] = BinaryenBinary(the_module, 102, expressions[411], expressions[410]);
   {
     uint8_t t97[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[405] = BinaryenConst(the_module, BinaryenLiteralVec128(t97));
+    expressions[413] = BinaryenConst(the_module, BinaryenLiteralVec128(t97));
   }
   {
     uint8_t t98[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[406] = BinaryenConst(the_module, BinaryenLiteralVec128(t98));
+    expressions[414] = BinaryenConst(the_module, BinaryenLiteralVec128(t98));
   }
-  expressions[407] = BinaryenBinary(the_module, 103, expressions[406], expressions[405]);
+  expressions[415] = BinaryenBinary(the_module, 103, expressions[414], expressions[413]);
   {
     uint8_t t99[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[408] = BinaryenConst(the_module, BinaryenLiteralVec128(t99));
+    expressions[416] = BinaryenConst(the_module, BinaryenLiteralVec128(t99));
   }
   {
     uint8_t t100[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[409] = BinaryenConst(the_module, BinaryenLiteralVec128(t100));
+    expressions[417] = BinaryenConst(the_module, BinaryenLiteralVec128(t100));
   }
-  expressions[410] = BinaryenBinary(the_module, 104, expressions[409], expressions[408]);
+  expressions[418] = BinaryenBinary(the_module, 104, expressions[417], expressions[416]);
   {
     uint8_t t101[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[411] = BinaryenConst(the_module, BinaryenLiteralVec128(t101));
+    expressions[419] = BinaryenConst(the_module, BinaryenLiteralVec128(t101));
   }
   {
     uint8_t t102[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[412] = BinaryenConst(the_module, BinaryenLiteralVec128(t102));
+    expressions[420] = BinaryenConst(the_module, BinaryenLiteralVec128(t102));
   }
-  expressions[413] = BinaryenBinary(the_module, 105, expressions[412], expressions[411]);
+  expressions[421] = BinaryenBinary(the_module, 105, expressions[420], expressions[419]);
   {
     uint8_t t103[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[414] = BinaryenConst(the_module, BinaryenLiteralVec128(t103));
+    expressions[422] = BinaryenConst(the_module, BinaryenLiteralVec128(t103));
   }
   {
     uint8_t t104[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[415] = BinaryenConst(the_module, BinaryenLiteralVec128(t104));
+    expressions[423] = BinaryenConst(the_module, BinaryenLiteralVec128(t104));
   }
-  expressions[416] = BinaryenBinary(the_module, 106, expressions[415], expressions[414]);
+  expressions[424] = BinaryenBinary(the_module, 106, expressions[423], expressions[422]);
   {
     uint8_t t105[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[417] = BinaryenConst(the_module, BinaryenLiteralVec128(t105));
+    expressions[425] = BinaryenConst(the_module, BinaryenLiteralVec128(t105));
   }
   {
     uint8_t t106[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[418] = BinaryenConst(the_module, BinaryenLiteralVec128(t106));
+    expressions[426] = BinaryenConst(the_module, BinaryenLiteralVec128(t106));
   }
-  expressions[419] = BinaryenBinary(the_module, 107, expressions[418], expressions[417]);
+  expressions[427] = BinaryenBinary(the_module, 107, expressions[426], expressions[425]);
   {
     uint8_t t107[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[420] = BinaryenConst(the_module, BinaryenLiteralVec128(t107));
+    expressions[428] = BinaryenConst(the_module, BinaryenLiteralVec128(t107));
   }
   {
     uint8_t t108[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[421] = BinaryenConst(the_module, BinaryenLiteralVec128(t108));
+    expressions[429] = BinaryenConst(the_module, BinaryenLiteralVec128(t108));
   }
-  expressions[422] = BinaryenBinary(the_module, 108, expressions[421], expressions[420]);
+  expressions[430] = BinaryenBinary(the_module, 108, expressions[429], expressions[428]);
   {
     uint8_t t109[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[423] = BinaryenConst(the_module, BinaryenLiteralVec128(t109));
+    expressions[431] = BinaryenConst(the_module, BinaryenLiteralVec128(t109));
   }
   {
     uint8_t t110[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[424] = BinaryenConst(the_module, BinaryenLiteralVec128(t110));
+    expressions[432] = BinaryenConst(the_module, BinaryenLiteralVec128(t110));
   }
-  expressions[425] = BinaryenBinary(the_module, 109, expressions[424], expressions[423]);
+  expressions[433] = BinaryenBinary(the_module, 109, expressions[432], expressions[431]);
   {
     uint8_t t111[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[426] = BinaryenConst(the_module, BinaryenLiteralVec128(t111));
+    expressions[434] = BinaryenConst(the_module, BinaryenLiteralVec128(t111));
   }
   {
     uint8_t t112[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[427] = BinaryenConst(the_module, BinaryenLiteralVec128(t112));
+    expressions[435] = BinaryenConst(the_module, BinaryenLiteralVec128(t112));
   }
-  expressions[428] = BinaryenBinary(the_module, 110, expressions[427], expressions[426]);
+  expressions[436] = BinaryenBinary(the_module, 110, expressions[435], expressions[434]);
   {
     uint8_t t113[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[429] = BinaryenConst(the_module, BinaryenLiteralVec128(t113));
+    expressions[437] = BinaryenConst(the_module, BinaryenLiteralVec128(t113));
   }
   {
     uint8_t t114[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[430] = BinaryenConst(the_module, BinaryenLiteralVec128(t114));
+    expressions[438] = BinaryenConst(the_module, BinaryenLiteralVec128(t114));
   }
-  expressions[431] = BinaryenBinary(the_module, 111, expressions[430], expressions[429]);
+  expressions[439] = BinaryenBinary(the_module, 111, expressions[438], expressions[437]);
   {
     uint8_t t115[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[432] = BinaryenConst(the_module, BinaryenLiteralVec128(t115));
+    expressions[440] = BinaryenConst(the_module, BinaryenLiteralVec128(t115));
   }
   {
     uint8_t t116[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[433] = BinaryenConst(the_module, BinaryenLiteralVec128(t116));
+    expressions[441] = BinaryenConst(the_module, BinaryenLiteralVec128(t116));
   }
-  expressions[434] = BinaryenBinary(the_module, 112, expressions[433], expressions[432]);
+  expressions[442] = BinaryenBinary(the_module, 112, expressions[441], expressions[440]);
   {
     uint8_t t117[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[435] = BinaryenConst(the_module, BinaryenLiteralVec128(t117));
+    expressions[443] = BinaryenConst(the_module, BinaryenLiteralVec128(t117));
   }
   {
     uint8_t t118[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[436] = BinaryenConst(the_module, BinaryenLiteralVec128(t118));
+    expressions[444] = BinaryenConst(the_module, BinaryenLiteralVec128(t118));
   }
-  expressions[437] = BinaryenBinary(the_module, 113, expressions[436], expressions[435]);
+  expressions[445] = BinaryenBinary(the_module, 113, expressions[444], expressions[443]);
   {
     uint8_t t119[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[438] = BinaryenConst(the_module, BinaryenLiteralVec128(t119));
+    expressions[446] = BinaryenConst(the_module, BinaryenLiteralVec128(t119));
   }
   {
     uint8_t t120[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[439] = BinaryenConst(the_module, BinaryenLiteralVec128(t120));
+    expressions[447] = BinaryenConst(the_module, BinaryenLiteralVec128(t120));
   }
-  expressions[440] = BinaryenBinary(the_module, 114, expressions[439], expressions[438]);
+  expressions[448] = BinaryenBinary(the_module, 114, expressions[447], expressions[446]);
   {
     uint8_t t121[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[441] = BinaryenConst(the_module, BinaryenLiteralVec128(t121));
+    expressions[449] = BinaryenConst(the_module, BinaryenLiteralVec128(t121));
   }
   {
     uint8_t t122[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[442] = BinaryenConst(the_module, BinaryenLiteralVec128(t122));
+    expressions[450] = BinaryenConst(the_module, BinaryenLiteralVec128(t122));
   }
-  expressions[443] = BinaryenBinary(the_module, 115, expressions[442], expressions[441]);
+  expressions[451] = BinaryenBinary(the_module, 115, expressions[450], expressions[449]);
   {
     uint8_t t123[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[444] = BinaryenConst(the_module, BinaryenLiteralVec128(t123));
+    expressions[452] = BinaryenConst(the_module, BinaryenLiteralVec128(t123));
   }
   {
     uint8_t t124[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[445] = BinaryenConst(the_module, BinaryenLiteralVec128(t124));
+    expressions[453] = BinaryenConst(the_module, BinaryenLiteralVec128(t124));
   }
-  expressions[446] = BinaryenBinary(the_module, 116, expressions[445], expressions[444]);
+  expressions[454] = BinaryenBinary(the_module, 116, expressions[453], expressions[452]);
   {
     uint8_t t125[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[447] = BinaryenConst(the_module, BinaryenLiteralVec128(t125));
+    expressions[455] = BinaryenConst(the_module, BinaryenLiteralVec128(t125));
   }
   {
     uint8_t t126[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[448] = BinaryenConst(the_module, BinaryenLiteralVec128(t126));
+    expressions[456] = BinaryenConst(the_module, BinaryenLiteralVec128(t126));
   }
-  expressions[449] = BinaryenBinary(the_module, 117, expressions[448], expressions[447]);
+  expressions[457] = BinaryenBinary(the_module, 117, expressions[456], expressions[455]);
   {
     uint8_t t127[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[450] = BinaryenConst(the_module, BinaryenLiteralVec128(t127));
+    expressions[458] = BinaryenConst(the_module, BinaryenLiteralVec128(t127));
   }
   {
     uint8_t t128[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[451] = BinaryenConst(the_module, BinaryenLiteralVec128(t128));
+    expressions[459] = BinaryenConst(the_module, BinaryenLiteralVec128(t128));
   }
-  expressions[452] = BinaryenBinary(the_module, 118, expressions[451], expressions[450]);
+  expressions[460] = BinaryenBinary(the_module, 118, expressions[459], expressions[458]);
   {
     uint8_t t129[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[453] = BinaryenConst(the_module, BinaryenLiteralVec128(t129));
+    expressions[461] = BinaryenConst(the_module, BinaryenLiteralVec128(t129));
   }
   {
     uint8_t t130[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[454] = BinaryenConst(the_module, BinaryenLiteralVec128(t130));
+    expressions[462] = BinaryenConst(the_module, BinaryenLiteralVec128(t130));
   }
-  expressions[455] = BinaryenBinary(the_module, 119, expressions[454], expressions[453]);
+  expressions[463] = BinaryenBinary(the_module, 119, expressions[462], expressions[461]);
   {
     uint8_t t131[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[456] = BinaryenConst(the_module, BinaryenLiteralVec128(t131));
+    expressions[464] = BinaryenConst(the_module, BinaryenLiteralVec128(t131));
   }
   {
     uint8_t t132[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[457] = BinaryenConst(the_module, BinaryenLiteralVec128(t132));
+    expressions[465] = BinaryenConst(the_module, BinaryenLiteralVec128(t132));
   }
-  expressions[458] = BinaryenBinary(the_module, 120, expressions[457], expressions[456]);
+  expressions[466] = BinaryenBinary(the_module, 120, expressions[465], expressions[464]);
   {
     uint8_t t133[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[459] = BinaryenConst(the_module, BinaryenLiteralVec128(t133));
+    expressions[467] = BinaryenConst(the_module, BinaryenLiteralVec128(t133));
   }
   {
     uint8_t t134[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[460] = BinaryenConst(the_module, BinaryenLiteralVec128(t134));
+    expressions[468] = BinaryenConst(the_module, BinaryenLiteralVec128(t134));
   }
-  expressions[461] = BinaryenBinary(the_module, 121, expressions[460], expressions[459]);
+  expressions[469] = BinaryenBinary(the_module, 121, expressions[468], expressions[467]);
   {
     uint8_t t135[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[462] = BinaryenConst(the_module, BinaryenLiteralVec128(t135));
+    expressions[470] = BinaryenConst(the_module, BinaryenLiteralVec128(t135));
   }
   {
     uint8_t t136[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[463] = BinaryenConst(the_module, BinaryenLiteralVec128(t136));
+    expressions[471] = BinaryenConst(the_module, BinaryenLiteralVec128(t136));
   }
-  expressions[464] = BinaryenBinary(the_module, 122, expressions[463], expressions[462]);
+  expressions[472] = BinaryenBinary(the_module, 122, expressions[471], expressions[470]);
   {
     uint8_t t137[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[465] = BinaryenConst(the_module, BinaryenLiteralVec128(t137));
+    expressions[473] = BinaryenConst(the_module, BinaryenLiteralVec128(t137));
   }
   {
     uint8_t t138[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[466] = BinaryenConst(the_module, BinaryenLiteralVec128(t138));
+    expressions[474] = BinaryenConst(the_module, BinaryenLiteralVec128(t138));
   }
-  expressions[467] = BinaryenBinary(the_module, 123, expressions[466], expressions[465]);
+  expressions[475] = BinaryenBinary(the_module, 123, expressions[474], expressions[473]);
   {
     uint8_t t139[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[468] = BinaryenConst(the_module, BinaryenLiteralVec128(t139));
+    expressions[476] = BinaryenConst(the_module, BinaryenLiteralVec128(t139));
   }
   {
     uint8_t t140[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[469] = BinaryenConst(the_module, BinaryenLiteralVec128(t140));
+    expressions[477] = BinaryenConst(the_module, BinaryenLiteralVec128(t140));
   }
-  expressions[470] = BinaryenBinary(the_module, 124, expressions[469], expressions[468]);
+  expressions[478] = BinaryenBinary(the_module, 124, expressions[477], expressions[476]);
   {
     uint8_t t141[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[471] = BinaryenConst(the_module, BinaryenLiteralVec128(t141));
+    expressions[479] = BinaryenConst(the_module, BinaryenLiteralVec128(t141));
   }
   {
     uint8_t t142[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[472] = BinaryenConst(the_module, BinaryenLiteralVec128(t142));
+    expressions[480] = BinaryenConst(the_module, BinaryenLiteralVec128(t142));
   }
-  expressions[473] = BinaryenBinary(the_module, 125, expressions[472], expressions[471]);
+  expressions[481] = BinaryenBinary(the_module, 125, expressions[480], expressions[479]);
   {
     uint8_t t143[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[474] = BinaryenConst(the_module, BinaryenLiteralVec128(t143));
+    expressions[482] = BinaryenConst(the_module, BinaryenLiteralVec128(t143));
   }
   {
     uint8_t t144[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[475] = BinaryenConst(the_module, BinaryenLiteralVec128(t144));
+    expressions[483] = BinaryenConst(the_module, BinaryenLiteralVec128(t144));
   }
-  expressions[476] = BinaryenBinary(the_module, 126, expressions[475], expressions[474]);
+  expressions[484] = BinaryenBinary(the_module, 126, expressions[483], expressions[482]);
   {
     uint8_t t145[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[477] = BinaryenConst(the_module, BinaryenLiteralVec128(t145));
+    expressions[485] = BinaryenConst(the_module, BinaryenLiteralVec128(t145));
   }
   {
     uint8_t t146[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[478] = BinaryenConst(the_module, BinaryenLiteralVec128(t146));
+    expressions[486] = BinaryenConst(the_module, BinaryenLiteralVec128(t146));
   }
-  expressions[479] = BinaryenBinary(the_module, 127, expressions[478], expressions[477]);
+  expressions[487] = BinaryenBinary(the_module, 127, expressions[486], expressions[485]);
   {
     uint8_t t147[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[480] = BinaryenConst(the_module, BinaryenLiteralVec128(t147));
+    expressions[488] = BinaryenConst(the_module, BinaryenLiteralVec128(t147));
   }
   {
     uint8_t t148[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[481] = BinaryenConst(the_module, BinaryenLiteralVec128(t148));
+    expressions[489] = BinaryenConst(the_module, BinaryenLiteralVec128(t148));
   }
-  expressions[482] = BinaryenBinary(the_module, 128, expressions[481], expressions[480]);
+  expressions[490] = BinaryenBinary(the_module, 128, expressions[489], expressions[488]);
   {
     uint8_t t149[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[483] = BinaryenConst(the_module, BinaryenLiteralVec128(t149));
+    expressions[491] = BinaryenConst(the_module, BinaryenLiteralVec128(t149));
   }
   {
     uint8_t t150[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[484] = BinaryenConst(the_module, BinaryenLiteralVec128(t150));
+    expressions[492] = BinaryenConst(the_module, BinaryenLiteralVec128(t150));
   }
-  expressions[485] = BinaryenBinary(the_module, 129, expressions[484], expressions[483]);
+  expressions[493] = BinaryenBinary(the_module, 129, expressions[492], expressions[491]);
   {
     uint8_t t151[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[486] = BinaryenConst(the_module, BinaryenLiteralVec128(t151));
+    expressions[494] = BinaryenConst(the_module, BinaryenLiteralVec128(t151));
   }
   {
     uint8_t t152[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[487] = BinaryenConst(the_module, BinaryenLiteralVec128(t152));
+    expressions[495] = BinaryenConst(the_module, BinaryenLiteralVec128(t152));
   }
-  expressions[488] = BinaryenBinary(the_module, 130, expressions[487], expressions[486]);
+  expressions[496] = BinaryenBinary(the_module, 130, expressions[495], expressions[494]);
   {
     uint8_t t153[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[489] = BinaryenConst(the_module, BinaryenLiteralVec128(t153));
+    expressions[497] = BinaryenConst(the_module, BinaryenLiteralVec128(t153));
   }
   {
     uint8_t t154[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[490] = BinaryenConst(the_module, BinaryenLiteralVec128(t154));
+    expressions[498] = BinaryenConst(the_module, BinaryenLiteralVec128(t154));
   }
-  expressions[491] = BinaryenBinary(the_module, 131, expressions[490], expressions[489]);
+  expressions[499] = BinaryenBinary(the_module, 131, expressions[498], expressions[497]);
   {
     uint8_t t155[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[492] = BinaryenConst(the_module, BinaryenLiteralVec128(t155));
+    expressions[500] = BinaryenConst(the_module, BinaryenLiteralVec128(t155));
   }
   {
     uint8_t t156[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[493] = BinaryenConst(the_module, BinaryenLiteralVec128(t156));
+    expressions[501] = BinaryenConst(the_module, BinaryenLiteralVec128(t156));
   }
-  expressions[494] = BinaryenBinary(the_module, 132, expressions[493], expressions[492]);
+  expressions[502] = BinaryenBinary(the_module, 132, expressions[501], expressions[500]);
   {
     uint8_t t157[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[495] = BinaryenConst(the_module, BinaryenLiteralVec128(t157));
+    expressions[503] = BinaryenConst(the_module, BinaryenLiteralVec128(t157));
   }
   {
     uint8_t t158[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[496] = BinaryenConst(the_module, BinaryenLiteralVec128(t158));
+    expressions[504] = BinaryenConst(the_module, BinaryenLiteralVec128(t158));
   }
-  expressions[497] = BinaryenBinary(the_module, 133, expressions[496], expressions[495]);
+  expressions[505] = BinaryenBinary(the_module, 133, expressions[504], expressions[503]);
   {
     uint8_t t159[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[498] = BinaryenConst(the_module, BinaryenLiteralVec128(t159));
+    expressions[506] = BinaryenConst(the_module, BinaryenLiteralVec128(t159));
   }
   {
     uint8_t t160[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[499] = BinaryenConst(the_module, BinaryenLiteralVec128(t160));
+    expressions[507] = BinaryenConst(the_module, BinaryenLiteralVec128(t160));
   }
-  expressions[500] = BinaryenBinary(the_module, 134, expressions[499], expressions[498]);
+  expressions[508] = BinaryenBinary(the_module, 134, expressions[507], expressions[506]);
   {
     uint8_t t161[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[501] = BinaryenConst(the_module, BinaryenLiteralVec128(t161));
+    expressions[509] = BinaryenConst(the_module, BinaryenLiteralVec128(t161));
   }
   {
     uint8_t t162[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[502] = BinaryenConst(the_module, BinaryenLiteralVec128(t162));
+    expressions[510] = BinaryenConst(the_module, BinaryenLiteralVec128(t162));
   }
-  expressions[503] = BinaryenBinary(the_module, 135, expressions[502], expressions[501]);
+  expressions[511] = BinaryenBinary(the_module, 135, expressions[510], expressions[509]);
   {
     uint8_t t163[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[504] = BinaryenConst(the_module, BinaryenLiteralVec128(t163));
+    expressions[512] = BinaryenConst(the_module, BinaryenLiteralVec128(t163));
   }
   {
     uint8_t t164[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[505] = BinaryenConst(the_module, BinaryenLiteralVec128(t164));
+    expressions[513] = BinaryenConst(the_module, BinaryenLiteralVec128(t164));
   }
-  expressions[506] = BinaryenBinary(the_module, 136, expressions[505], expressions[504]);
+  expressions[514] = BinaryenBinary(the_module, 136, expressions[513], expressions[512]);
   {
     uint8_t t165[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[507] = BinaryenConst(the_module, BinaryenLiteralVec128(t165));
+    expressions[515] = BinaryenConst(the_module, BinaryenLiteralVec128(t165));
   }
   {
     uint8_t t166[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[508] = BinaryenConst(the_module, BinaryenLiteralVec128(t166));
+    expressions[516] = BinaryenConst(the_module, BinaryenLiteralVec128(t166));
   }
-  expressions[509] = BinaryenBinary(the_module, 137, expressions[508], expressions[507]);
+  expressions[517] = BinaryenBinary(the_module, 137, expressions[516], expressions[515]);
   {
     uint8_t t167[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[510] = BinaryenConst(the_module, BinaryenLiteralVec128(t167));
+    expressions[518] = BinaryenConst(the_module, BinaryenLiteralVec128(t167));
   }
   {
     uint8_t t168[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[511] = BinaryenConst(the_module, BinaryenLiteralVec128(t168));
+    expressions[519] = BinaryenConst(the_module, BinaryenLiteralVec128(t168));
   }
-  expressions[512] = BinaryenBinary(the_module, 138, expressions[511], expressions[510]);
+  expressions[520] = BinaryenBinary(the_module, 138, expressions[519], expressions[518]);
   {
     uint8_t t169[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[513] = BinaryenConst(the_module, BinaryenLiteralVec128(t169));
+    expressions[521] = BinaryenConst(the_module, BinaryenLiteralVec128(t169));
   }
   {
     uint8_t t170[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[514] = BinaryenConst(the_module, BinaryenLiteralVec128(t170));
+    expressions[522] = BinaryenConst(the_module, BinaryenLiteralVec128(t170));
   }
-  expressions[515] = BinaryenBinary(the_module, 139, expressions[514], expressions[513]);
+  expressions[523] = BinaryenBinary(the_module, 139, expressions[522], expressions[521]);
   {
     uint8_t t171[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[516] = BinaryenConst(the_module, BinaryenLiteralVec128(t171));
+    expressions[524] = BinaryenConst(the_module, BinaryenLiteralVec128(t171));
   }
   {
     uint8_t t172[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[517] = BinaryenConst(the_module, BinaryenLiteralVec128(t172));
+    expressions[525] = BinaryenConst(the_module, BinaryenLiteralVec128(t172));
   }
-  expressions[518] = BinaryenBinary(the_module, 140, expressions[517], expressions[516]);
+  expressions[526] = BinaryenBinary(the_module, 140, expressions[525], expressions[524]);
   {
     uint8_t t173[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[519] = BinaryenConst(the_module, BinaryenLiteralVec128(t173));
+    expressions[527] = BinaryenConst(the_module, BinaryenLiteralVec128(t173));
   }
   {
     uint8_t t174[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[520] = BinaryenConst(the_module, BinaryenLiteralVec128(t174));
+    expressions[528] = BinaryenConst(the_module, BinaryenLiteralVec128(t174));
   }
-  expressions[521] = BinaryenBinary(the_module, 141, expressions[520], expressions[519]);
+  expressions[529] = BinaryenBinary(the_module, 141, expressions[528], expressions[527]);
   {
     uint8_t t175[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[522] = BinaryenConst(the_module, BinaryenLiteralVec128(t175));
+    expressions[530] = BinaryenConst(the_module, BinaryenLiteralVec128(t175));
   }
   {
     uint8_t t176[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[523] = BinaryenConst(the_module, BinaryenLiteralVec128(t176));
+    expressions[531] = BinaryenConst(the_module, BinaryenLiteralVec128(t176));
   }
-  expressions[524] = BinaryenBinary(the_module, 142, expressions[523], expressions[522]);
+  expressions[532] = BinaryenBinary(the_module, 142, expressions[531], expressions[530]);
   {
     uint8_t t177[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[525] = BinaryenConst(the_module, BinaryenLiteralVec128(t177));
+    expressions[533] = BinaryenConst(the_module, BinaryenLiteralVec128(t177));
   }
   {
     uint8_t t178[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[526] = BinaryenConst(the_module, BinaryenLiteralVec128(t178));
+    expressions[534] = BinaryenConst(the_module, BinaryenLiteralVec128(t178));
   }
-  expressions[527] = BinaryenBinary(the_module, 143, expressions[526], expressions[525]);
+  expressions[535] = BinaryenBinary(the_module, 143, expressions[534], expressions[533]);
   {
     uint8_t t179[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[528] = BinaryenConst(the_module, BinaryenLiteralVec128(t179));
+    expressions[536] = BinaryenConst(the_module, BinaryenLiteralVec128(t179));
   }
   {
     uint8_t t180[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[529] = BinaryenConst(the_module, BinaryenLiteralVec128(t180));
+    expressions[537] = BinaryenConst(the_module, BinaryenLiteralVec128(t180));
   }
-  expressions[530] = BinaryenBinary(the_module, 144, expressions[529], expressions[528]);
+  expressions[538] = BinaryenBinary(the_module, 144, expressions[537], expressions[536]);
   {
     uint8_t t181[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[531] = BinaryenConst(the_module, BinaryenLiteralVec128(t181));
+    expressions[539] = BinaryenConst(the_module, BinaryenLiteralVec128(t181));
   }
   {
     uint8_t t182[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[532] = BinaryenConst(the_module, BinaryenLiteralVec128(t182));
+    expressions[540] = BinaryenConst(the_module, BinaryenLiteralVec128(t182));
   }
-  expressions[533] = BinaryenBinary(the_module, 145, expressions[532], expressions[531]);
+  expressions[541] = BinaryenBinary(the_module, 145, expressions[540], expressions[539]);
   {
     uint8_t t183[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[534] = BinaryenConst(the_module, BinaryenLiteralVec128(t183));
+    expressions[542] = BinaryenConst(the_module, BinaryenLiteralVec128(t183));
   }
   {
     uint8_t t184[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[535] = BinaryenConst(the_module, BinaryenLiteralVec128(t184));
+    expressions[543] = BinaryenConst(the_module, BinaryenLiteralVec128(t184));
   }
-  expressions[536] = BinaryenBinary(the_module, 146, expressions[535], expressions[534]);
+  expressions[544] = BinaryenBinary(the_module, 146, expressions[543], expressions[542]);
   {
     uint8_t t185[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[537] = BinaryenConst(the_module, BinaryenLiteralVec128(t185));
+    expressions[545] = BinaryenConst(the_module, BinaryenLiteralVec128(t185));
   }
   {
     uint8_t t186[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[538] = BinaryenConst(the_module, BinaryenLiteralVec128(t186));
+    expressions[546] = BinaryenConst(the_module, BinaryenLiteralVec128(t186));
   }
-  expressions[539] = BinaryenBinary(the_module, 147, expressions[538], expressions[537]);
+  expressions[547] = BinaryenBinary(the_module, 147, expressions[546], expressions[545]);
   {
     uint8_t t187[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[540] = BinaryenConst(the_module, BinaryenLiteralVec128(t187));
+    expressions[548] = BinaryenConst(the_module, BinaryenLiteralVec128(t187));
   }
   {
     uint8_t t188[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[541] = BinaryenConst(the_module, BinaryenLiteralVec128(t188));
+    expressions[549] = BinaryenConst(the_module, BinaryenLiteralVec128(t188));
   }
-  expressions[542] = BinaryenBinary(the_module, 148, expressions[541], expressions[540]);
+  expressions[550] = BinaryenBinary(the_module, 148, expressions[549], expressions[548]);
   {
     uint8_t t189[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[543] = BinaryenConst(the_module, BinaryenLiteralVec128(t189));
+    expressions[551] = BinaryenConst(the_module, BinaryenLiteralVec128(t189));
   }
   {
     uint8_t t190[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[544] = BinaryenConst(the_module, BinaryenLiteralVec128(t190));
+    expressions[552] = BinaryenConst(the_module, BinaryenLiteralVec128(t190));
   }
-  expressions[545] = BinaryenBinary(the_module, 154, expressions[544], expressions[543]);
+  expressions[553] = BinaryenBinary(the_module, 154, expressions[552], expressions[551]);
   {
     uint8_t t191[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[546] = BinaryenConst(the_module, BinaryenLiteralVec128(t191));
+    expressions[554] = BinaryenConst(the_module, BinaryenLiteralVec128(t191));
   }
   {
     uint8_t t192[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[547] = BinaryenConst(the_module, BinaryenLiteralVec128(t192));
+    expressions[555] = BinaryenConst(the_module, BinaryenLiteralVec128(t192));
   }
-  expressions[548] = BinaryenBinary(the_module, 155, expressions[547], expressions[546]);
+  expressions[556] = BinaryenBinary(the_module, 155, expressions[555], expressions[554]);
   {
     uint8_t t193[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[549] = BinaryenConst(the_module, BinaryenLiteralVec128(t193));
+    expressions[557] = BinaryenConst(the_module, BinaryenLiteralVec128(t193));
   }
   {
     uint8_t t194[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[550] = BinaryenConst(the_module, BinaryenLiteralVec128(t194));
+    expressions[558] = BinaryenConst(the_module, BinaryenLiteralVec128(t194));
   }
-  expressions[551] = BinaryenBinary(the_module, 156, expressions[550], expressions[549]);
+  expressions[559] = BinaryenBinary(the_module, 156, expressions[558], expressions[557]);
   {
     uint8_t t195[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[552] = BinaryenConst(the_module, BinaryenLiteralVec128(t195));
+    expressions[560] = BinaryenConst(the_module, BinaryenLiteralVec128(t195));
   }
   {
     uint8_t t196[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[553] = BinaryenConst(the_module, BinaryenLiteralVec128(t196));
+    expressions[561] = BinaryenConst(the_module, BinaryenLiteralVec128(t196));
   }
-  expressions[554] = BinaryenBinary(the_module, 157, expressions[553], expressions[552]);
+  expressions[562] = BinaryenBinary(the_module, 157, expressions[561], expressions[560]);
   {
     uint8_t t197[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[555] = BinaryenConst(the_module, BinaryenLiteralVec128(t197));
+    expressions[563] = BinaryenConst(the_module, BinaryenLiteralVec128(t197));
   }
   {
     uint8_t t198[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[556] = BinaryenConst(the_module, BinaryenLiteralVec128(t198));
+    expressions[564] = BinaryenConst(the_module, BinaryenLiteralVec128(t198));
   }
-  expressions[557] = BinaryenBinary(the_module, 158, expressions[556], expressions[555]);
+  expressions[565] = BinaryenBinary(the_module, 158, expressions[564], expressions[563]);
   {
     uint8_t t199[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[558] = BinaryenConst(the_module, BinaryenLiteralVec128(t199));
+    expressions[566] = BinaryenConst(the_module, BinaryenLiteralVec128(t199));
   }
   {
     uint8_t t200[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[559] = BinaryenConst(the_module, BinaryenLiteralVec128(t200));
+    expressions[567] = BinaryenConst(the_module, BinaryenLiteralVec128(t200));
   }
-  expressions[560] = BinaryenBinary(the_module, 149, expressions[559], expressions[558]);
+  expressions[568] = BinaryenBinary(the_module, 149, expressions[567], expressions[566]);
   {
     uint8_t t201[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[561] = BinaryenConst(the_module, BinaryenLiteralVec128(t201));
+    expressions[569] = BinaryenConst(the_module, BinaryenLiteralVec128(t201));
   }
   {
     uint8_t t202[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[562] = BinaryenConst(the_module, BinaryenLiteralVec128(t202));
+    expressions[570] = BinaryenConst(the_module, BinaryenLiteralVec128(t202));
   }
-  expressions[563] = BinaryenBinary(the_module, 150, expressions[562], expressions[561]);
+  expressions[571] = BinaryenBinary(the_module, 150, expressions[570], expressions[569]);
   {
     uint8_t t203[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[564] = BinaryenConst(the_module, BinaryenLiteralVec128(t203));
+    expressions[572] = BinaryenConst(the_module, BinaryenLiteralVec128(t203));
   }
   {
     uint8_t t204[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[565] = BinaryenConst(the_module, BinaryenLiteralVec128(t204));
+    expressions[573] = BinaryenConst(the_module, BinaryenLiteralVec128(t204));
   }
-  expressions[566] = BinaryenBinary(the_module, 151, expressions[565], expressions[564]);
+  expressions[574] = BinaryenBinary(the_module, 151, expressions[573], expressions[572]);
   {
     uint8_t t205[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[567] = BinaryenConst(the_module, BinaryenLiteralVec128(t205));
+    expressions[575] = BinaryenConst(the_module, BinaryenLiteralVec128(t205));
   }
   {
     uint8_t t206[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[568] = BinaryenConst(the_module, BinaryenLiteralVec128(t206));
+    expressions[576] = BinaryenConst(the_module, BinaryenLiteralVec128(t206));
   }
-  expressions[569] = BinaryenBinary(the_module, 152, expressions[568], expressions[567]);
+  expressions[577] = BinaryenBinary(the_module, 152, expressions[576], expressions[575]);
   {
     uint8_t t207[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[570] = BinaryenConst(the_module, BinaryenLiteralVec128(t207));
+    expressions[578] = BinaryenConst(the_module, BinaryenLiteralVec128(t207));
   }
   {
     uint8_t t208[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[571] = BinaryenConst(the_module, BinaryenLiteralVec128(t208));
+    expressions[579] = BinaryenConst(the_module, BinaryenLiteralVec128(t208));
   }
-  expressions[572] = BinaryenBinary(the_module, 153, expressions[571], expressions[570]);
+  expressions[580] = BinaryenBinary(the_module, 153, expressions[579], expressions[578]);
   {
     uint8_t t209[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[573] = BinaryenConst(the_module, BinaryenLiteralVec128(t209));
+    expressions[581] = BinaryenConst(the_module, BinaryenLiteralVec128(t209));
   }
   {
     uint8_t t210[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[574] = BinaryenConst(the_module, BinaryenLiteralVec128(t210));
+    expressions[582] = BinaryenConst(the_module, BinaryenLiteralVec128(t210));
   }
-  expressions[575] = BinaryenBinary(the_module, 159, expressions[574], expressions[573]);
+  expressions[583] = BinaryenBinary(the_module, 159, expressions[582], expressions[581]);
   {
     uint8_t t211[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[576] = BinaryenConst(the_module, BinaryenLiteralVec128(t211));
+    expressions[584] = BinaryenConst(the_module, BinaryenLiteralVec128(t211));
   }
   {
     uint8_t t212[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[577] = BinaryenConst(the_module, BinaryenLiteralVec128(t212));
+    expressions[585] = BinaryenConst(the_module, BinaryenLiteralVec128(t212));
   }
-  expressions[578] = BinaryenBinary(the_module, 160, expressions[577], expressions[576]);
+  expressions[586] = BinaryenBinary(the_module, 160, expressions[585], expressions[584]);
   {
     uint8_t t213[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[579] = BinaryenConst(the_module, BinaryenLiteralVec128(t213));
+    expressions[587] = BinaryenConst(the_module, BinaryenLiteralVec128(t213));
   }
   {
     uint8_t t214[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[580] = BinaryenConst(the_module, BinaryenLiteralVec128(t214));
+    expressions[588] = BinaryenConst(the_module, BinaryenLiteralVec128(t214));
   }
-  expressions[581] = BinaryenBinary(the_module, 161, expressions[580], expressions[579]);
+  expressions[589] = BinaryenBinary(the_module, 161, expressions[588], expressions[587]);
   {
     uint8_t t215[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[582] = BinaryenConst(the_module, BinaryenLiteralVec128(t215));
+    expressions[590] = BinaryenConst(the_module, BinaryenLiteralVec128(t215));
   }
   {
     uint8_t t216[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[583] = BinaryenConst(the_module, BinaryenLiteralVec128(t216));
+    expressions[591] = BinaryenConst(the_module, BinaryenLiteralVec128(t216));
   }
-  expressions[584] = BinaryenBinary(the_module, 162, expressions[583], expressions[582]);
+  expressions[592] = BinaryenBinary(the_module, 162, expressions[591], expressions[590]);
   {
     uint8_t t217[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[585] = BinaryenConst(the_module, BinaryenLiteralVec128(t217));
+    expressions[593] = BinaryenConst(the_module, BinaryenLiteralVec128(t217));
   }
   {
     uint8_t t218[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[586] = BinaryenConst(the_module, BinaryenLiteralVec128(t218));
+    expressions[594] = BinaryenConst(the_module, BinaryenLiteralVec128(t218));
   }
-  expressions[587] = BinaryenBinary(the_module, 163, expressions[586], expressions[585]);
+  expressions[595] = BinaryenBinary(the_module, 163, expressions[594], expressions[593]);
   {
     uint8_t t219[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[588] = BinaryenConst(the_module, BinaryenLiteralVec128(t219));
+    expressions[596] = BinaryenConst(the_module, BinaryenLiteralVec128(t219));
   }
   {
     uint8_t t220[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[589] = BinaryenConst(the_module, BinaryenLiteralVec128(t220));
+    expressions[597] = BinaryenConst(the_module, BinaryenLiteralVec128(t220));
   }
-  expressions[590] = BinaryenBinary(the_module, 164, expressions[589], expressions[588]);
+  expressions[598] = BinaryenBinary(the_module, 164, expressions[597], expressions[596]);
   {
     uint8_t t221[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[591] = BinaryenConst(the_module, BinaryenLiteralVec128(t221));
+    expressions[599] = BinaryenConst(the_module, BinaryenLiteralVec128(t221));
   }
   {
     uint8_t t222[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[592] = BinaryenConst(the_module, BinaryenLiteralVec128(t222));
+    expressions[600] = BinaryenConst(the_module, BinaryenLiteralVec128(t222));
   }
-  expressions[593] = BinaryenBinary(the_module, 165, expressions[592], expressions[591]);
+  expressions[601] = BinaryenBinary(the_module, 165, expressions[600], expressions[599]);
   {
     uint8_t t223[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[594] = BinaryenConst(the_module, BinaryenLiteralVec128(t223));
+    expressions[602] = BinaryenConst(the_module, BinaryenLiteralVec128(t223));
   }
   {
     uint8_t t224[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[595] = BinaryenConst(the_module, BinaryenLiteralVec128(t224));
+    expressions[603] = BinaryenConst(the_module, BinaryenLiteralVec128(t224));
   }
-  expressions[596] = BinaryenBinary(the_module, 166, expressions[595], expressions[594]);
+  expressions[604] = BinaryenBinary(the_module, 166, expressions[603], expressions[602]);
   {
     uint8_t t225[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[597] = BinaryenConst(the_module, BinaryenLiteralVec128(t225));
+    expressions[605] = BinaryenConst(the_module, BinaryenLiteralVec128(t225));
   }
   {
     uint8_t t226[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[598] = BinaryenConst(the_module, BinaryenLiteralVec128(t226));
+    expressions[606] = BinaryenConst(the_module, BinaryenLiteralVec128(t226));
   }
-  expressions[599] = BinaryenBinary(the_module, 167, expressions[598], expressions[597]);
+  expressions[607] = BinaryenBinary(the_module, 167, expressions[606], expressions[605]);
   {
     uint8_t t227[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[600] = BinaryenConst(the_module, BinaryenLiteralVec128(t227));
+    expressions[608] = BinaryenConst(the_module, BinaryenLiteralVec128(t227));
   }
   {
     uint8_t t228[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[601] = BinaryenConst(the_module, BinaryenLiteralVec128(t228));
+    expressions[609] = BinaryenConst(the_module, BinaryenLiteralVec128(t228));
   }
-  expressions[602] = BinaryenBinary(the_module, 168, expressions[601], expressions[600]);
+  expressions[610] = BinaryenBinary(the_module, 168, expressions[609], expressions[608]);
   {
     uint8_t t229[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[603] = BinaryenConst(the_module, BinaryenLiteralVec128(t229));
+    expressions[611] = BinaryenConst(the_module, BinaryenLiteralVec128(t229));
   }
   {
     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[612] = BinaryenConst(the_module, BinaryenLiteralVec128(t230));
   }
-  expressions[605] = BinaryenBinary(the_module, 169, expressions[604], expressions[603]);
+  expressions[613] = BinaryenBinary(the_module, 169, expressions[612], expressions[611]);
   {
     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[614] = BinaryenConst(the_module, BinaryenLiteralVec128(t231));
   }
   {
     uint8_t t232[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[607] = BinaryenConst(the_module, BinaryenLiteralVec128(t232));
+    expressions[615] = BinaryenConst(the_module, BinaryenLiteralVec128(t232));
   }
-  expressions[608] = BinaryenBinary(the_module, 170, expressions[607], expressions[606]);
+  expressions[616] = BinaryenBinary(the_module, 170, expressions[615], expressions[614]);
   {
     uint8_t t233[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[609] = BinaryenConst(the_module, BinaryenLiteralVec128(t233));
+    expressions[617] = BinaryenConst(the_module, BinaryenLiteralVec128(t233));
   }
   {
     uint8_t t234[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[610] = BinaryenConst(the_module, BinaryenLiteralVec128(t234));
+    expressions[618] = BinaryenConst(the_module, BinaryenLiteralVec128(t234));
   }
-  expressions[611] = BinaryenBinary(the_module, 171, expressions[610], expressions[609]);
+  expressions[619] = BinaryenBinary(the_module, 171, expressions[618], expressions[617]);
   {
     uint8_t t235[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[612] = BinaryenConst(the_module, BinaryenLiteralVec128(t235));
+    expressions[620] = BinaryenConst(the_module, BinaryenLiteralVec128(t235));
   }
   {
     uint8_t t236[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[613] = BinaryenConst(the_module, BinaryenLiteralVec128(t236));
+    expressions[621] = BinaryenConst(the_module, BinaryenLiteralVec128(t236));
   }
-  expressions[614] = BinaryenBinary(the_module, 172, expressions[613], expressions[612]);
+  expressions[622] = BinaryenBinary(the_module, 172, expressions[621], expressions[620]);
   {
     uint8_t t237[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[615] = BinaryenConst(the_module, BinaryenLiteralVec128(t237));
+    expressions[623] = BinaryenConst(the_module, BinaryenLiteralVec128(t237));
   }
-  expressions[616] = BinaryenSIMDExtract(the_module, 0, expressions[615], 0);
+  expressions[624] = BinaryenSIMDExtract(the_module, 0, expressions[623], 0);
   {
     uint8_t t238[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[617] = BinaryenConst(the_module, BinaryenLiteralVec128(t238));
+    expressions[625] = BinaryenConst(the_module, BinaryenLiteralVec128(t238));
   }
-  expressions[618] = BinaryenSIMDExtract(the_module, 1, expressions[617], 0);
+  expressions[626] = BinaryenSIMDExtract(the_module, 1, expressions[625], 0);
   {
     uint8_t t239[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[619] = BinaryenConst(the_module, BinaryenLiteralVec128(t239));
+    expressions[627] = BinaryenConst(the_module, BinaryenLiteralVec128(t239));
   }
-  expressions[620] = BinaryenSIMDExtract(the_module, 2, expressions[619], 0);
+  expressions[628] = BinaryenSIMDExtract(the_module, 2, expressions[627], 0);
   {
     uint8_t t240[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[621] = BinaryenConst(the_module, BinaryenLiteralVec128(t240));
+    expressions[629] = BinaryenConst(the_module, BinaryenLiteralVec128(t240));
   }
-  expressions[622] = BinaryenSIMDExtract(the_module, 3, expressions[621], 0);
+  expressions[630] = BinaryenSIMDExtract(the_module, 3, expressions[629], 0);
   {
     uint8_t t241[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[623] = BinaryenConst(the_module, BinaryenLiteralVec128(t241));
+    expressions[631] = BinaryenConst(the_module, BinaryenLiteralVec128(t241));
   }
-  expressions[624] = BinaryenSIMDExtract(the_module, 4, expressions[623], 0);
+  expressions[632] = BinaryenSIMDExtract(the_module, 4, expressions[631], 0);
   {
     uint8_t t242[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[625] = BinaryenConst(the_module, BinaryenLiteralVec128(t242));
+    expressions[633] = BinaryenConst(the_module, BinaryenLiteralVec128(t242));
   }
-  expressions[626] = BinaryenSIMDExtract(the_module, 5, expressions[625], 0);
+  expressions[634] = BinaryenSIMDExtract(the_module, 5, expressions[633], 0);
   {
     uint8_t t243[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[627] = BinaryenConst(the_module, BinaryenLiteralVec128(t243));
+    expressions[635] = BinaryenConst(the_module, BinaryenLiteralVec128(t243));
   }
-  expressions[628] = BinaryenSIMDExtract(the_module, 6, expressions[627], 0);
+  expressions[636] = BinaryenSIMDExtract(the_module, 6, expressions[635], 0);
   {
     uint8_t t244[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[629] = BinaryenConst(the_module, BinaryenLiteralVec128(t244));
+    expressions[637] = BinaryenConst(the_module, BinaryenLiteralVec128(t244));
   }
-  expressions[630] = BinaryenSIMDExtract(the_module, 7, expressions[629], 0);
-  expressions[631] = BinaryenConst(the_module, BinaryenLiteralInt32(42));
+  expressions[638] = BinaryenSIMDExtract(the_module, 7, expressions[637], 0);
+  expressions[639] = BinaryenConst(the_module, BinaryenLiteralInt32(42));
   {
     uint8_t t245[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[632] = BinaryenConst(the_module, BinaryenLiteralVec128(t245));
+    expressions[640] = BinaryenConst(the_module, BinaryenLiteralVec128(t245));
   }
-  expressions[633] = BinaryenSIMDReplace(the_module, 0, expressions[632], 0, expressions[631]);
-  expressions[634] = BinaryenConst(the_module, BinaryenLiteralInt32(42));
+  expressions[641] = BinaryenSIMDReplace(the_module, 0, expressions[640], 0, expressions[639]);
+  expressions[642] = BinaryenConst(the_module, BinaryenLiteralInt32(42));
   {
     uint8_t t246[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[635] = BinaryenConst(the_module, BinaryenLiteralVec128(t246));
+    expressions[643] = BinaryenConst(the_module, BinaryenLiteralVec128(t246));
   }
-  expressions[636] = BinaryenSIMDReplace(the_module, 1, expressions[635], 0, expressions[634]);
-  expressions[637] = BinaryenConst(the_module, BinaryenLiteralInt32(42));
+  expressions[644] = BinaryenSIMDReplace(the_module, 1, expressions[643], 0, expressions[642]);
+  expressions[645] = BinaryenConst(the_module, BinaryenLiteralInt32(42));
   {
     uint8_t t247[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[638] = BinaryenConst(the_module, BinaryenLiteralVec128(t247));
+    expressions[646] = BinaryenConst(the_module, BinaryenLiteralVec128(t247));
   }
-  expressions[639] = BinaryenSIMDReplace(the_module, 2, expressions[638], 0, expressions[637]);
-  expressions[640] = BinaryenConst(the_module, BinaryenLiteralInt64(42));
+  expressions[647] = BinaryenSIMDReplace(the_module, 2, expressions[646], 0, expressions[645]);
+  expressions[648] = BinaryenConst(the_module, BinaryenLiteralInt64(42));
   {
     uint8_t t248[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[641] = BinaryenConst(the_module, BinaryenLiteralVec128(t248));
+    expressions[649] = BinaryenConst(the_module, BinaryenLiteralVec128(t248));
   }
-  expressions[642] = BinaryenSIMDReplace(the_module, 3, expressions[641], 0, expressions[640]);
-  expressions[643] = BinaryenConst(the_module, BinaryenLiteralFloat32(42));
+  expressions[650] = BinaryenSIMDReplace(the_module, 3, expressions[649], 0, expressions[648]);
+  expressions[651] = BinaryenConst(the_module, BinaryenLiteralFloat32(42));
   {
     uint8_t t249[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[644] = BinaryenConst(the_module, BinaryenLiteralVec128(t249));
+    expressions[652] = BinaryenConst(the_module, BinaryenLiteralVec128(t249));
   }
-  expressions[645] = BinaryenSIMDReplace(the_module, 4, expressions[644], 0, expressions[643]);
-  expressions[646] = BinaryenConst(the_module, BinaryenLiteralFloat64(42));
+  expressions[653] = BinaryenSIMDReplace(the_module, 4, expressions[652], 0, expressions[651]);
+  expressions[654] = BinaryenConst(the_module, BinaryenLiteralFloat64(42));
   {
     uint8_t t250[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[647] = BinaryenConst(the_module, BinaryenLiteralVec128(t250));
+    expressions[655] = BinaryenConst(the_module, BinaryenLiteralVec128(t250));
   }
-  expressions[648] = BinaryenSIMDReplace(the_module, 5, expressions[647], 0, expressions[646]);
+  expressions[656] = BinaryenSIMDReplace(the_module, 5, expressions[655], 0, expressions[654]);
   {
     uint8_t t251[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[649] = BinaryenConst(the_module, BinaryenLiteralVec128(t251));
+    expressions[657] = BinaryenConst(the_module, BinaryenLiteralVec128(t251));
   }
-  expressions[650] = BinaryenConst(the_module, BinaryenLiteralInt32(1));
-  expressions[651] = BinaryenSIMDShift(the_module, 0, expressions[649], expressions[650]);
+  expressions[658] = BinaryenConst(the_module, BinaryenLiteralInt32(1));
+  expressions[659] = BinaryenSIMDShift(the_module, 0, expressions[657], expressions[658]);
   {
     uint8_t t252[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[652] = BinaryenConst(the_module, BinaryenLiteralVec128(t252));
+    expressions[660] = BinaryenConst(the_module, BinaryenLiteralVec128(t252));
   }
-  expressions[653] = BinaryenConst(the_module, BinaryenLiteralInt32(1));
-  expressions[654] = BinaryenSIMDShift(the_module, 1, expressions[652], expressions[653]);
+  expressions[661] = BinaryenConst(the_module, BinaryenLiteralInt32(1));
+  expressions[662] = BinaryenSIMDShift(the_module, 1, expressions[660], expressions[661]);
   {
     uint8_t t253[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[655] = BinaryenConst(the_module, BinaryenLiteralVec128(t253));
+    expressions[663] = BinaryenConst(the_module, BinaryenLiteralVec128(t253));
   }
-  expressions[656] = BinaryenConst(the_module, BinaryenLiteralInt32(1));
-  expressions[657] = BinaryenSIMDShift(the_module, 2, expressions[655], expressions[656]);
+  expressions[664] = BinaryenConst(the_module, BinaryenLiteralInt32(1));
+  expressions[665] = BinaryenSIMDShift(the_module, 2, expressions[663], expressions[664]);
   {
     uint8_t t254[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[658] = BinaryenConst(the_module, BinaryenLiteralVec128(t254));
+    expressions[666] = BinaryenConst(the_module, BinaryenLiteralVec128(t254));
   }
-  expressions[659] = BinaryenConst(the_module, BinaryenLiteralInt32(1));
-  expressions[660] = BinaryenSIMDShift(the_module, 3, expressions[658], expressions[659]);
+  expressions[667] = BinaryenConst(the_module, BinaryenLiteralInt32(1));
+  expressions[668] = BinaryenSIMDShift(the_module, 3, expressions[666], expressions[667]);
   {
     uint8_t t255[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[661] = BinaryenConst(the_module, BinaryenLiteralVec128(t255));
+    expressions[669] = BinaryenConst(the_module, BinaryenLiteralVec128(t255));
   }
-  expressions[662] = BinaryenConst(the_module, BinaryenLiteralInt32(1));
-  expressions[663] = BinaryenSIMDShift(the_module, 4, expressions[661], expressions[662]);
+  expressions[670] = BinaryenConst(the_module, BinaryenLiteralInt32(1));
+  expressions[671] = BinaryenSIMDShift(the_module, 4, expressions[669], expressions[670]);
   {
     uint8_t t256[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[664] = BinaryenConst(the_module, BinaryenLiteralVec128(t256));
+    expressions[672] = BinaryenConst(the_module, BinaryenLiteralVec128(t256));
   }
-  expressions[665] = BinaryenConst(the_module, BinaryenLiteralInt32(1));
-  expressions[666] = BinaryenSIMDShift(the_module, 5, expressions[664], expressions[665]);
+  expressions[673] = BinaryenConst(the_module, BinaryenLiteralInt32(1));
+  expressions[674] = BinaryenSIMDShift(the_module, 5, expressions[672], expressions[673]);
   {
     uint8_t t257[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[667] = BinaryenConst(the_module, BinaryenLiteralVec128(t257));
+    expressions[675] = BinaryenConst(the_module, BinaryenLiteralVec128(t257));
   }
-  expressions[668] = BinaryenConst(the_module, BinaryenLiteralInt32(1));
-  expressions[669] = BinaryenSIMDShift(the_module, 6, expressions[667], expressions[668]);
+  expressions[676] = BinaryenConst(the_module, BinaryenLiteralInt32(1));
+  expressions[677] = BinaryenSIMDShift(the_module, 6, expressions[675], expressions[676]);
   {
     uint8_t t258[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[670] = BinaryenConst(the_module, BinaryenLiteralVec128(t258));
+    expressions[678] = BinaryenConst(the_module, BinaryenLiteralVec128(t258));
   }
-  expressions[671] = BinaryenConst(the_module, BinaryenLiteralInt32(1));
-  expressions[672] = BinaryenSIMDShift(the_module, 7, expressions[670], expressions[671]);
+  expressions[679] = BinaryenConst(the_module, BinaryenLiteralInt32(1));
+  expressions[680] = BinaryenSIMDShift(the_module, 7, expressions[678], expressions[679]);
   {
     uint8_t t259[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[673] = BinaryenConst(the_module, BinaryenLiteralVec128(t259));
+    expressions[681] = BinaryenConst(the_module, BinaryenLiteralVec128(t259));
   }
-  expressions[674] = BinaryenConst(the_module, BinaryenLiteralInt32(1));
-  expressions[675] = BinaryenSIMDShift(the_module, 8, expressions[673], expressions[674]);
+  expressions[682] = BinaryenConst(the_module, BinaryenLiteralInt32(1));
+  expressions[683] = BinaryenSIMDShift(the_module, 8, expressions[681], expressions[682]);
   {
     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));
+    expressions[684] = BinaryenConst(the_module, BinaryenLiteralVec128(t260));
   }
-  expressions[677] = BinaryenConst(the_module, BinaryenLiteralInt32(1));
-  expressions[678] = BinaryenSIMDShift(the_module, 9, expressions[676], expressions[677]);
+  expressions[685] = BinaryenConst(the_module, BinaryenLiteralInt32(1));
+  expressions[686] = BinaryenSIMDShift(the_module, 9, expressions[684], expressions[685]);
   {
     uint8_t t261[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[679] = BinaryenConst(the_module, BinaryenLiteralVec128(t261));
+    expressions[687] = BinaryenConst(the_module, BinaryenLiteralVec128(t261));
   }
-  expressions[680] = BinaryenConst(the_module, BinaryenLiteralInt32(1));
-  expressions[681] = BinaryenSIMDShift(the_module, 10, expressions[679], expressions[680]);
+  expressions[688] = BinaryenConst(the_module, BinaryenLiteralInt32(1));
+  expressions[689] = BinaryenSIMDShift(the_module, 10, expressions[687], expressions[688]);
   {
     uint8_t t262[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[682] = BinaryenConst(the_module, BinaryenLiteralVec128(t262));
-  }
-  expressions[683] = BinaryenConst(the_module, BinaryenLiteralInt32(1));
-  expressions[684] = BinaryenSIMDShift(the_module, 11, expressions[682], expressions[683]);
-  expressions[685] = BinaryenConst(the_module, BinaryenLiteralInt32(128));
-  expressions[686] = BinaryenSIMDLoad(the_module, 0, 0, 1, expressions[685]);
-  expressions[687] = BinaryenConst(the_module, BinaryenLiteralInt32(128));
-  expressions[688] = BinaryenSIMDLoad(the_module, 1, 16, 1, expressions[687]);
-  expressions[689] = BinaryenConst(the_module, BinaryenLiteralInt32(128));
-  expressions[690] = BinaryenSIMDLoad(the_module, 2, 16, 4, expressions[689]);
-  expressions[691] = BinaryenConst(the_module, BinaryenLiteralInt32(128));
-  expressions[692] = BinaryenSIMDLoad(the_module, 3, 0, 4, expressions[691]);
+    expressions[690] = BinaryenConst(the_module, BinaryenLiteralVec128(t262));
+  }
+  expressions[691] = BinaryenConst(the_module, BinaryenLiteralInt32(1));
+  expressions[692] = BinaryenSIMDShift(the_module, 11, expressions[690], expressions[691]);
   expressions[693] = BinaryenConst(the_module, BinaryenLiteralInt32(128));
-  expressions[694] = BinaryenSIMDLoad(the_module, 4, 0, 8, expressions[693]);
+  expressions[694] = BinaryenSIMDLoad(the_module, 0, 0, 1, expressions[693]);
   expressions[695] = BinaryenConst(the_module, BinaryenLiteralInt32(128));
-  expressions[696] = BinaryenSIMDLoad(the_module, 5, 0, 8, expressions[695]);
+  expressions[696] = BinaryenSIMDLoad(the_module, 1, 16, 1, expressions[695]);
   expressions[697] = BinaryenConst(the_module, BinaryenLiteralInt32(128));
-  expressions[698] = BinaryenSIMDLoad(the_module, 6, 0, 8, expressions[697]);
+  expressions[698] = BinaryenSIMDLoad(the_module, 2, 16, 4, expressions[697]);
   expressions[699] = BinaryenConst(the_module, BinaryenLiteralInt32(128));
-  expressions[700] = BinaryenSIMDLoad(the_module, 7, 0, 8, expressions[699]);
+  expressions[700] = BinaryenSIMDLoad(the_module, 3, 0, 4, expressions[699]);
   expressions[701] = BinaryenConst(the_module, BinaryenLiteralInt32(128));
-  expressions[702] = BinaryenSIMDLoad(the_module, 8, 0, 8, expressions[701]);
+  expressions[702] = BinaryenSIMDLoad(the_module, 4, 0, 8, expressions[701]);
   expressions[703] = BinaryenConst(the_module, BinaryenLiteralInt32(128));
-  expressions[704] = BinaryenSIMDLoad(the_module, 9, 0, 8, expressions[703]);
+  expressions[704] = BinaryenSIMDLoad(the_module, 5, 0, 8, expressions[703]);
+  expressions[705] = BinaryenConst(the_module, BinaryenLiteralInt32(128));
+  expressions[706] = BinaryenSIMDLoad(the_module, 6, 0, 8, expressions[705]);
+  expressions[707] = BinaryenConst(the_module, BinaryenLiteralInt32(128));
+  expressions[708] = BinaryenSIMDLoad(the_module, 7, 0, 8, expressions[707]);
+  expressions[709] = BinaryenConst(the_module, BinaryenLiteralInt32(128));
+  expressions[710] = BinaryenSIMDLoad(the_module, 8, 0, 8, expressions[709]);
+  expressions[711] = BinaryenConst(the_module, BinaryenLiteralInt32(128));
+  expressions[712] = BinaryenSIMDLoad(the_module, 9, 0, 8, expressions[711]);
   {
     uint8_t t263[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[705] = BinaryenConst(the_module, BinaryenLiteralVec128(t263));
+    expressions[713] = BinaryenConst(the_module, BinaryenLiteralVec128(t263));
   }
   {
     uint8_t t264[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[706] = BinaryenConst(the_module, BinaryenLiteralVec128(t264));
+    expressions[714] = BinaryenConst(the_module, BinaryenLiteralVec128(t264));
   }
   {
     uint8_t mask[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
-    expressions[707] = BinaryenSIMDShuffle(the_module, expressions[705], expressions[706], mask);
+    expressions[715] = BinaryenSIMDShuffle(the_module, expressions[713], expressions[714], mask);
   }
   {
     uint8_t t265[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[708] = BinaryenConst(the_module, BinaryenLiteralVec128(t265));
+    expressions[716] = 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[709] = BinaryenConst(the_module, BinaryenLiteralVec128(t266));
+    expressions[717] = 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[710] = BinaryenConst(the_module, BinaryenLiteralVec128(t267));
+    expressions[718] = BinaryenConst(the_module, BinaryenLiteralVec128(t267));
   }
-  expressions[711] = BinaryenSIMDTernary(the_module, 0, expressions[708], expressions[709], expressions[710]);
+  expressions[719] = BinaryenSIMDTernary(the_module, 0, expressions[716], expressions[717], expressions[718]);
   {
     uint8_t t268[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[712] = BinaryenConst(the_module, BinaryenLiteralVec128(t268));
+    expressions[720] = BinaryenConst(the_module, BinaryenLiteralVec128(t268));
   }
   {
     uint8_t t269[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[713] = BinaryenConst(the_module, BinaryenLiteralVec128(t269));
+    expressions[721] = BinaryenConst(the_module, BinaryenLiteralVec128(t269));
   }
   {
     uint8_t t270[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[714] = BinaryenConst(the_module, BinaryenLiteralVec128(t270));
+    expressions[722] = BinaryenConst(the_module, BinaryenLiteralVec128(t270));
   }
-  expressions[715] = BinaryenSIMDTernary(the_module, 1, expressions[712], expressions[713], expressions[714]);
+  expressions[723] = BinaryenSIMDTernary(the_module, 1, expressions[720], expressions[721], expressions[722]);
   {
     uint8_t t271[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[716] = BinaryenConst(the_module, BinaryenLiteralVec128(t271));
+    expressions[724] = BinaryenConst(the_module, BinaryenLiteralVec128(t271));
   }
   {
     uint8_t t272[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[717] = BinaryenConst(the_module, BinaryenLiteralVec128(t272));
+    expressions[725] = BinaryenConst(the_module, BinaryenLiteralVec128(t272));
   }
   {
     uint8_t t273[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[718] = BinaryenConst(the_module, BinaryenLiteralVec128(t273));
+    expressions[726] = BinaryenConst(the_module, BinaryenLiteralVec128(t273));
   }
-  expressions[719] = BinaryenSIMDTernary(the_module, 2, expressions[716], expressions[717], expressions[718]);
+  expressions[727] = BinaryenSIMDTernary(the_module, 2, expressions[724], expressions[725], expressions[726]);
   {
     uint8_t t274[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[720] = BinaryenConst(the_module, BinaryenLiteralVec128(t274));
+    expressions[728] = BinaryenConst(the_module, BinaryenLiteralVec128(t274));
   }
   {
     uint8_t t275[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[721] = BinaryenConst(the_module, BinaryenLiteralVec128(t275));
+    expressions[729] = BinaryenConst(the_module, BinaryenLiteralVec128(t275));
   }
   {
     uint8_t t276[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[722] = BinaryenConst(the_module, BinaryenLiteralVec128(t276));
+    expressions[730] = BinaryenConst(the_module, BinaryenLiteralVec128(t276));
   }
-  expressions[723] = BinaryenSIMDTernary(the_module, 3, expressions[720], expressions[721], expressions[722]);
+  expressions[731] = BinaryenSIMDTernary(the_module, 3, expressions[728], expressions[729], expressions[730]);
   {
     uint8_t t277[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[724] = BinaryenConst(the_module, BinaryenLiteralVec128(t277));
+    expressions[732] = BinaryenConst(the_module, BinaryenLiteralVec128(t277));
   }
   {
     uint8_t t278[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[725] = BinaryenConst(the_module, BinaryenLiteralVec128(t278));
+    expressions[733] = BinaryenConst(the_module, BinaryenLiteralVec128(t278));
   }
   {
     uint8_t t279[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[726] = BinaryenConst(the_module, BinaryenLiteralVec128(t279));
-  }
-  expressions[727] = BinaryenSIMDTernary(the_module, 4, expressions[724], expressions[725], expressions[726]);
-  expressions[728] = BinaryenConst(the_module, BinaryenLiteralInt32(1024));
-  expressions[729] = BinaryenConst(the_module, BinaryenLiteralInt32(0));
-  expressions[730] = BinaryenConst(the_module, BinaryenLiteralInt32(12));
-  expressions[731] = BinaryenMemoryInit(the_module, 0, expressions[728], expressions[729], expressions[730]);
-  expressions[732] = BinaryenDataDrop(the_module, 0);
-  expressions[733] = BinaryenConst(the_module, BinaryenLiteralInt32(2048));
-  expressions[734] = BinaryenConst(the_module, BinaryenLiteralInt32(1024));
-  expressions[735] = BinaryenConst(the_module, BinaryenLiteralInt32(12));
-  expressions[736] = BinaryenMemoryCopy(the_module, expressions[733], expressions[734], expressions[735]);
+    expressions[734] = BinaryenConst(the_module, BinaryenLiteralVec128(t279));
+  }
+  expressions[735] = BinaryenSIMDTernary(the_module, 4, expressions[732], expressions[733], expressions[734]);
+  expressions[736] = BinaryenConst(the_module, BinaryenLiteralInt32(1024));
   expressions[737] = BinaryenConst(the_module, BinaryenLiteralInt32(0));
-  expressions[738] = BinaryenConst(the_module, BinaryenLiteralInt32(42));
-  expressions[739] = BinaryenConst(the_module, BinaryenLiteralInt32(1024));
-  expressions[740] = BinaryenMemoryFill(the_module, expressions[737], expressions[738], expressions[739]);
+  expressions[738] = BinaryenConst(the_module, BinaryenLiteralInt32(12));
+  expressions[739] = BinaryenMemoryInit(the_module, 0, expressions[736], expressions[737], expressions[738]);
+  expressions[740] = BinaryenDataDrop(the_module, 0);
+  expressions[741] = BinaryenConst(the_module, BinaryenLiteralInt32(2048));
+  expressions[742] = BinaryenConst(the_module, BinaryenLiteralInt32(1024));
+  expressions[743] = BinaryenConst(the_module, BinaryenLiteralInt32(12));
+  expressions[744] = BinaryenMemoryCopy(the_module, expressions[741], expressions[742], expressions[743]);
+  expressions[745] = BinaryenConst(the_module, BinaryenLiteralInt32(0));
+  expressions[746] = BinaryenConst(the_module, BinaryenLiteralInt32(42));
+  expressions[747] = BinaryenConst(the_module, BinaryenLiteralInt32(1024));
+  expressions[748] = BinaryenMemoryFill(the_module, expressions[745], expressions[746], expressions[747]);
   {
     BinaryenExpressionRef children[] = { 0 };
-    expressions[741] = BinaryenBlock(the_module, NULL, children, 0, BinaryenTypeAuto());
-  }
-  expressions[742] = BinaryenIf(the_module, expressions[18], expressions[19], expressions[20]);
-  expressions[743] = BinaryenIf(the_module, expressions[21], expressions[22], expressions[0]);
-  expressions[744] = BinaryenConst(the_module, BinaryenLiteralInt32(0));
-  expressions[745] = BinaryenLoop(the_module, "in", expressions[744]);
-  expressions[746] = BinaryenConst(the_module, BinaryenLiteralInt32(0));
-  expressions[747] = BinaryenLoop(the_module, NULL, expressions[746]);
-  expressions[748] = BinaryenBreak(the_module, "the-value", expressions[23], expressions[24]);
-  expressions[749] = BinaryenConst(the_module, BinaryenLiteralInt32(2));
-  expressions[750] = BinaryenBreak(the_module, "the-nothing", expressions[749], expressions[0]);
-  expressions[751] = BinaryenConst(the_module, BinaryenLiteralInt32(3));
-  expressions[752] = BinaryenBreak(the_module, "the-value", expressions[0], expressions[751]);
-  expressions[753] = BinaryenBreak(the_module, "the-nothing", expressions[0], expressions[0]);
+    expressions[749] = BinaryenBlock(the_module, NULL, children, 0, BinaryenTypeAuto());
+  }
+  expressions[750] = BinaryenIf(the_module, expressions[26], expressions[27], expressions[28]);
+  expressions[751] = BinaryenIf(the_module, expressions[29], expressions[30], expressions[0]);
+  expressions[752] = BinaryenConst(the_module, BinaryenLiteralInt32(0));
+  expressions[753] = BinaryenLoop(the_module, "in", expressions[752]);
+  expressions[754] = BinaryenConst(the_module, BinaryenLiteralInt32(0));
+  expressions[755] = BinaryenLoop(the_module, NULL, expressions[754]);
+  expressions[756] = BinaryenBreak(the_module, "the-value", expressions[31], expressions[32]);
+  expressions[757] = BinaryenConst(the_module, BinaryenLiteralInt32(2));
+  expressions[758] = BinaryenBreak(the_module, "the-nothing", expressions[757], expressions[0]);
+  expressions[759] = BinaryenConst(the_module, BinaryenLiteralInt32(3));
+  expressions[760] = BinaryenBreak(the_module, "the-value", expressions[0], expressions[759]);
+  expressions[761] = BinaryenBreak(the_module, "the-nothing", expressions[0], expressions[0]);
   {
     const char* names[] = { "the-value" };
-    expressions[754] = BinaryenSwitch(the_module, names, 1, "the-value", expressions[25], expressions[26]);
+    expressions[762] = BinaryenSwitch(the_module, names, 1, "the-value", expressions[33], expressions[34]);
   }
-  expressions[755] = BinaryenConst(the_module, BinaryenLiteralInt32(2));
+  expressions[763] = BinaryenConst(the_module, BinaryenLiteralInt32(2));
   {
     const char* names[] = { "the-nothing" };
-    expressions[756] = BinaryenSwitch(the_module, names, 1, "the-nothing", expressions[755], expressions[0]);
+    expressions[764] = BinaryenSwitch(the_module, names, 1, "the-nothing", expressions[763], expressions[0]);
   }
   {
     BinaryenExpressionRef operands[] = { expressions[10], expressions[11], expressions[12], expressions[13] };
-    expressions[757] = BinaryenCall(the_module, "kitchen()sinker", operands, 4, 2);
+    expressions[765] = BinaryenCall(the_module, "kitchen()sinker", operands, 4, 2);
   }
-  expressions[758] = BinaryenUnary(the_module, 20, expressions[757]);
+  expressions[766] = BinaryenUnary(the_module, 20, expressions[765]);
   {
     BinaryenExpressionRef operands[] = { expressions[8], expressions[9] };
-    expressions[759] = BinaryenCall(the_module, "an-imported", operands, 2, 4);
+    expressions[767] = BinaryenCall(the_module, "an-imported", operands, 2, 4);
   }
-  expressions[760] = BinaryenUnary(the_module, 25, expressions[759]);
-  expressions[761] = BinaryenUnary(the_module, 20, expressions[760]);
-  expressions[762] = BinaryenConst(the_module, BinaryenLiteralInt32(2449));
+  expressions[768] = BinaryenUnary(the_module, 25, expressions[767]);
+  expressions[769] = BinaryenUnary(the_module, 20, expressions[768]);
+  expressions[770] = BinaryenConst(the_module, BinaryenLiteralInt32(2449));
   {
     BinaryenExpressionRef operands[] = { expressions[14], expressions[15], expressions[16], expressions[17] };
-    expressions[763] = BinaryenCallIndirect(the_module, expressions[762], operands, 4, 11, 2);
-  }
-  expressions[764] = BinaryenUnary(the_module, 20, expressions[763]);
-  expressions[765] = BinaryenLocalGet(the_module, 0, 2);
-  expressions[766] = BinaryenDrop(the_module, expressions[765]);
-  expressions[767] = BinaryenConst(the_module, BinaryenLiteralInt32(101));
-  expressions[768] = BinaryenLocalSet(the_module, 0, expressions[767]);
-  expressions[769] = BinaryenConst(the_module, BinaryenLiteralInt32(102));
-  expressions[770] = BinaryenLocalTee(the_module, 0, expressions[769], 2);
-  expressions[771] = BinaryenDrop(the_module, expressions[770]);
-  expressions[772] = BinaryenConst(the_module, BinaryenLiteralInt32(1));
-  expressions[773] = BinaryenLoad(the_module, 4, 0, 0, 0, 2, expressions[772]);
-  expressions[774] = BinaryenConst(the_module, BinaryenLiteralInt32(8));
-  expressions[775] = BinaryenLoad(the_module, 2, 1, 2, 1, 3, expressions[774]);
-  expressions[776] = BinaryenConst(the_module, BinaryenLiteralInt32(2));
-  expressions[777] = BinaryenLoad(the_module, 4, 0, 0, 0, 4, expressions[776]);
-  expressions[778] = BinaryenConst(the_module, BinaryenLiteralInt32(9));
-  expressions[779] = BinaryenLoad(the_module, 8, 0, 2, 8, 5, expressions[778]);
-  expressions[780] = BinaryenStore(the_module, 4, 0, 0, expressions[30], expressions[31], 2);
-  expressions[781] = BinaryenStore(the_module, 8, 2, 4, expressions[32], expressions[33], 3);
-  expressions[782] = BinaryenSelect(the_module, expressions[27], expressions[28], expressions[29], BinaryenTypeAuto());
-  expressions[783] = BinaryenConst(the_module, BinaryenLiteralInt32(1337));
-  expressions[784] = BinaryenReturn(the_module, expressions[783]);
+    expressions[771] = BinaryenCallIndirect(the_module, expressions[770], operands, 4, 11, 2);
+  }
+  expressions[772] = BinaryenUnary(the_module, 20, expressions[771]);
+  expressions[773] = BinaryenLocalGet(the_module, 0, 2);
+  expressions[774] = BinaryenDrop(the_module, expressions[773]);
+  expressions[775] = BinaryenConst(the_module, BinaryenLiteralInt32(101));
+  expressions[776] = BinaryenLocalSet(the_module, 0, expressions[775]);
+  expressions[777] = BinaryenConst(the_module, BinaryenLiteralInt32(102));
+  expressions[778] = BinaryenLocalTee(the_module, 0, expressions[777], 2);
+  expressions[779] = BinaryenDrop(the_module, expressions[778]);
+  expressions[780] = BinaryenConst(the_module, BinaryenLiteralInt32(1));
+  expressions[781] = BinaryenLoad(the_module, 4, 0, 0, 0, 2, expressions[780]);
+  expressions[782] = BinaryenConst(the_module, BinaryenLiteralInt32(8));
+  expressions[783] = BinaryenLoad(the_module, 2, 1, 2, 1, 3, expressions[782]);
+  expressions[784] = BinaryenConst(the_module, BinaryenLiteralInt32(2));
+  expressions[785] = BinaryenLoad(the_module, 4, 0, 0, 0, 4, expressions[784]);
+  expressions[786] = BinaryenConst(the_module, BinaryenLiteralInt32(9));
+  expressions[787] = BinaryenLoad(the_module, 8, 0, 2, 8, 5, expressions[786]);
+  expressions[788] = BinaryenStore(the_module, 4, 0, 0, expressions[38], expressions[39], 2);
+  expressions[789] = BinaryenStore(the_module, 8, 2, 4, expressions[40], expressions[41], 3);
+  expressions[790] = BinaryenSelect(the_module, expressions[35], expressions[36], expressions[37], BinaryenTypeAuto());
+  expressions[791] = BinaryenConst(the_module, BinaryenLiteralInt32(1337));
+  expressions[792] = BinaryenReturn(the_module, expressions[791]);
   {
     BinaryenExpressionRef operands[] = { expressions[10], expressions[11], expressions[12], expressions[13] };
-    expressions[785] = BinaryenReturnCall(the_module, "kitchen()sinker", operands, 4, 2);
+    expressions[793] = BinaryenReturnCall(the_module, "kitchen()sinker", operands, 4, 2);
   }
-  expressions[786] = BinaryenConst(the_module, BinaryenLiteralInt32(2449));
+  expressions[794] = BinaryenConst(the_module, BinaryenLiteralInt32(2449));
   {
     BinaryenExpressionRef operands[] = { expressions[14], expressions[15], expressions[16], expressions[17] };
-    expressions[787] = BinaryenReturnCallIndirect(the_module, expressions[786], operands, 4, 11, 2);
-  }
-  expressions[788] = BinaryenRefIsNull(the_module, expressions[34]);
-  expressions[789] = BinaryenRefIsNull(the_module, expressions[35]);
-  expressions[790] = BinaryenSelect(the_module, expressions[27], expressions[34], expressions[35], 7);
-  expressions[791] = BinaryenTry(the_module, expressions[37], expressions[45]);
-  expressions[792] = BinaryenAtomicLoad(the_module, 4, 0, 2, expressions[23]);
-  expressions[793] = BinaryenAtomicStore(the_module, 4, 0, expressions[23], expressions[792], 2);
-  expressions[794] = BinaryenAtomicWait(the_module, expressions[23], expressions[23], expressions[33], 2);
-  expressions[795] = BinaryenDrop(the_module, expressions[794]);
-  expressions[796] = BinaryenAtomicNotify(the_module, expressions[23], expressions[23]);
-  expressions[797] = BinaryenDrop(the_module, expressions[796]);
-  expressions[798] = BinaryenAtomicFence(the_module);
-  expressions[799] = BinaryenPop(the_module, 2);
-  expressions[800] = BinaryenPush(the_module, expressions[799]);
-  expressions[801] = BinaryenPop(the_module, 3);
-  expressions[802] = BinaryenPush(the_module, expressions[801]);
-  expressions[803] = BinaryenPop(the_module, 4);
-  expressions[804] = BinaryenPush(the_module, expressions[803]);
-  expressions[805] = BinaryenPop(the_module, 5);
-  expressions[806] = BinaryenPush(the_module, expressions[805]);
-  expressions[807] = BinaryenPop(the_module, 7);
-  expressions[808] = BinaryenPush(the_module, expressions[807]);
-  expressions[809] = BinaryenPop(the_module, 8);
-  expressions[810] = BinaryenPush(the_module, expressions[809]);
-  expressions[811] = BinaryenPop(the_module, 9);
-  expressions[812] = BinaryenPush(the_module, expressions[811]);
-  expressions[813] = BinaryenPop(the_module, 10);
-  expressions[814] = BinaryenPush(the_module, expressions[813]);
-  expressions[815] = BinaryenPop(the_module, 7);
-  expressions[816] = BinaryenPush(the_module, expressions[815]);
-  expressions[817] = BinaryenPop(the_module, 9);
-  expressions[818] = BinaryenPush(the_module, expressions[817]);
-  expressions[819] = BinaryenPop(the_module, 10);
-  expressions[820] = BinaryenPush(the_module, expressions[819]);
-  expressions[821] = BinaryenNop(the_module);
-  expressions[822] = BinaryenUnreachable(the_module);
-  BinaryenExpressionPrint(expressions[53]);
+    expressions[795] = BinaryenReturnCallIndirect(the_module, expressions[794], operands, 4, 11, 2);
+  }
+  expressions[796] = BinaryenRefIsNull(the_module, expressions[42]);
+  expressions[797] = BinaryenRefIsNull(the_module, expressions[43]);
+  expressions[798] = BinaryenSelect(the_module, expressions[35], expressions[42], expressions[43], 7);
+  expressions[799] = BinaryenTry(the_module, expressions[45], expressions[53]);
+  expressions[800] = BinaryenAtomicLoad(the_module, 4, 0, 2, expressions[31]);
+  expressions[801] = BinaryenAtomicStore(the_module, 4, 0, expressions[31], expressions[800], 2);
+  expressions[802] = BinaryenAtomicWait(the_module, expressions[31], expressions[31], expressions[41], 2);
+  expressions[803] = BinaryenDrop(the_module, expressions[802]);
+  expressions[804] = BinaryenAtomicNotify(the_module, expressions[31], expressions[31]);
+  expressions[805] = BinaryenDrop(the_module, expressions[804]);
+  expressions[806] = BinaryenAtomicFence(the_module);
+  {
+    BinaryenExpressionRef operands[] = { expressions[18], expressions[19], expressions[20], expressions[21] };
+    expressions[807] = BinaryenTupleMake(the_module, operands, 4);
+  }
+  {
+    BinaryenExpressionRef operands[] = { expressions[22], expressions[23], expressions[24], expressions[25] };
+    expressions[808] = BinaryenTupleMake(the_module, operands, 4);
+  }
+  expressions[809] = BinaryenTupleExtract(the_module, expressions[808], 2);
+  expressions[810] = BinaryenPop(the_module, 2);
+  expressions[811] = BinaryenPush(the_module, expressions[810]);
+  expressions[812] = BinaryenPop(the_module, 3);
+  expressions[813] = BinaryenPush(the_module, expressions[812]);
+  expressions[814] = BinaryenPop(the_module, 4);
+  expressions[815] = BinaryenPush(the_module, expressions[814]);
+  expressions[816] = BinaryenPop(the_module, 5);
+  expressions[817] = BinaryenPush(the_module, expressions[816]);
+  expressions[818] = BinaryenPop(the_module, 7);
+  expressions[819] = BinaryenPush(the_module, expressions[818]);
+  expressions[820] = BinaryenPop(the_module, 8);
+  expressions[821] = BinaryenPush(the_module, expressions[820]);
+  expressions[822] = BinaryenPop(the_module, 9);
+  expressions[823] = BinaryenPush(the_module, expressions[822]);
+  expressions[824] = BinaryenPop(the_module, 10);
+  expressions[825] = BinaryenPush(the_module, expressions[824]);
+  expressions[826] = BinaryenPop(the_module, 7);
+  expressions[827] = BinaryenPush(the_module, expressions[826]);
+  expressions[828] = BinaryenPop(the_module, 9);
+  expressions[829] = BinaryenPush(the_module, expressions[828]);
+  expressions[830] = BinaryenPop(the_module, 10);
+  expressions[831] = BinaryenPush(the_module, expressions[830]);
+  expressions[832] = BinaryenNop(the_module);
+  expressions[833] = BinaryenUnreachable(the_module);
+  BinaryenExpressionPrint(expressions[61]);
 (f32.neg
  (f32.const -33.61199951171875)
 )
   {
-    BinaryenExpressionRef children[] = { expressions[47], expressions[49], expressions[51], expressions[53], expressions[55], 
-       expressions[57], expressions[59], expressions[61], expressions[63], expressions[65], expressions[67], 
-       expressions[69], expressions[71], expressions[73], expressions[75], expressions[77], expressions[79], 
-       expressions[81], expressions[83], expressions[85], expressions[87], expressions[89], expressions[91], 
-       expressions[93], expressions[95], expressions[97], expressions[99], expressions[101], expressions[103], 
-       expressions[105], expressions[107], expressions[109], expressions[111], expressions[113], expressions[115], 
-       expressions[117], expressions[119], expressions[121], expressions[123], expressions[125], expressions[127], 
-       expressions[129], expressions[131], expressions[133], expressions[135], expressions[137], expressions[139], 
-       expressions[141], expressions[143], expressions[145], expressions[147], expressions[149], expressions[151], 
-       expressions[153], expressions[155], expressions[157], expressions[159], expressions[161], expressions[163], 
-       expressions[165], expressions[167], expressions[169], expressions[171], expressions[173], expressions[175], 
-       expressions[177], expressions[179], expressions[181], expressions[183], expressions[185], expressions[187], 
-       expressions[189], expressions[191], expressions[193], expressions[195], expressions[197], expressions[199], 
-       expressions[201], expressions[203], expressions[205], expressions[207], expressions[209], expressions[211], 
-       expressions[213], expressions[215], expressions[217], expressions[219], expressions[221], expressions[223], 
-       expressions[225], expressions[227], expressions[230], expressions[233], expressions[236], expressions[239], 
-       expressions[242], expressions[245], expressions[248], expressions[251], expressions[254], expressions[257], 
-       expressions[260], expressions[263], expressions[266], expressions[269], expressions[272], expressions[275], 
-       expressions[278], expressions[281], expressions[284], expressions[287], expressions[290], expressions[293], 
-       expressions[296], expressions[299], expressions[302], expressions[305], expressions[308], expressions[311], 
-       expressions[314], expressions[317], expressions[320], expressions[323], expressions[326], expressions[329], 
-       expressions[332], expressions[335], expressions[338], expressions[341], expressions[344], expressions[347], 
-       expressions[350], expressions[353], expressions[356], expressions[359], expressions[362], expressions[365], 
-       expressions[368], expressions[371], expressions[374], expressions[377], expressions[380], expressions[383], 
-       expressions[386], expressions[389], expressions[392], expressions[395], expressions[398], expressions[401], 
-       expressions[404], expressions[407], expressions[410], expressions[413], expressions[416], expressions[419], 
-       expressions[422], expressions[425], expressions[428], expressions[431], expressions[434], expressions[437], 
-       expressions[440], expressions[443], expressions[446], expressions[449], expressions[452], expressions[455], 
-       expressions[458], expressions[461], expressions[464], expressions[467], expressions[470], expressions[473], 
-       expressions[476], expressions[479], expressions[482], expressions[485], expressions[488], expressions[491], 
-       expressions[494], expressions[497], expressions[500], expressions[503], expressions[506], expressions[509], 
-       expressions[512], expressions[515], expressions[518], expressions[521], expressions[524], expressions[527], 
-       expressions[530], expressions[533], expressions[536], expressions[539], expressions[542], expressions[545], 
-       expressions[548], expressions[551], expressions[554], expressions[557], expressions[560], expressions[563], 
-       expressions[566], expressions[569], expressions[572], expressions[575], expressions[578], expressions[581], 
-       expressions[584], expressions[587], expressions[590], expressions[593], expressions[596], expressions[599], 
-       expressions[602], expressions[605], expressions[608], expressions[611], expressions[614], expressions[616], 
-       expressions[618], expressions[620], expressions[622], expressions[624], expressions[626], expressions[628], 
-       expressions[630], expressions[633], expressions[636], expressions[639], expressions[642], expressions[645], 
-       expressions[648], expressions[651], expressions[654], expressions[657], expressions[660], expressions[663], 
-       expressions[666], expressions[669], expressions[672], expressions[675], expressions[678], expressions[681], 
-       expressions[684], expressions[686], expressions[688], expressions[690], expressions[692], expressions[694], 
-       expressions[696], expressions[698], expressions[700], expressions[702], expressions[704], expressions[707], 
-       expressions[711], expressions[715], expressions[719], expressions[723], expressions[727], expressions[731], 
-       expressions[732], expressions[736], expressions[740], expressions[741], expressions[742], expressions[743], 
-       expressions[745], expressions[747], expressions[748], expressions[750], expressions[752], expressions[753], 
-       expressions[754], expressions[756], expressions[758], expressions[761], expressions[764], expressions[766], 
-       expressions[768], expressions[771], expressions[773], expressions[775], expressions[777], expressions[779], 
-       expressions[780], expressions[781], expressions[782], expressions[784], expressions[785], expressions[787], 
-       expressions[788], expressions[789], expressions[790], expressions[791], expressions[793], expressions[795], 
-       expressions[797], expressions[798], expressions[800], expressions[802], expressions[804], expressions[806], 
-       expressions[808], expressions[810], expressions[812], expressions[814], expressions[816], expressions[818], 
-       expressions[820], expressions[821], expressions[822] };
-    expressions[823] = BinaryenBlock(the_module, "the-value", children, 314, BinaryenTypeAuto());
-  }
-  expressions[824] = BinaryenDrop(the_module, expressions[823]);
-  {
-    BinaryenExpressionRef children[] = { expressions[824] };
-    expressions[825] = BinaryenBlock(the_module, "the-nothing", children, 1, BinaryenTypeAuto());
-  }
-  expressions[826] = BinaryenConst(the_module, BinaryenLiteralInt32(42));
-  {
-    BinaryenExpressionRef children[] = { expressions[825], expressions[826] };
-    expressions[827] = BinaryenBlock(the_module, "the-body", children, 2, BinaryenTypeAuto());
+    BinaryenExpressionRef children[] = { expressions[55], expressions[57], expressions[59], expressions[61], expressions[63], 
+       expressions[65], expressions[67], expressions[69], expressions[71], expressions[73], expressions[75], 
+       expressions[77], expressions[79], expressions[81], expressions[83], expressions[85], expressions[87], 
+       expressions[89], expressions[91], expressions[93], expressions[95], expressions[97], expressions[99], 
+       expressions[101], expressions[103], expressions[105], expressions[107], expressions[109], expressions[111], 
+       expressions[113], expressions[115], expressions[117], expressions[119], expressions[121], expressions[123], 
+       expressions[125], expressions[127], expressions[129], expressions[131], expressions[133], expressions[135], 
+       expressions[137], expressions[139], expressions[141], expressions[143], expressions[145], expressions[147], 
+       expressions[149], expressions[151], expressions[153], expressions[155], expressions[157], expressions[159], 
+       expressions[161], expressions[163], expressions[165], expressions[167], expressions[169], expressions[171], 
+       expressions[173], expressions[175], expressions[177], expressions[179], expressions[181], expressions[183], 
+       expressions[185], expressions[187], expressions[189], expressions[191], expressions[193], expressions[195], 
+       expressions[197], expressions[199], expressions[201], expressions[203], expressions[205], expressions[207], 
+       expressions[209], expressions[211], expressions[213], expressions[215], expressions[217], expressions[219], 
+       expressions[221], expressions[223], expressions[225], expressions[227], expressions[229], expressions[231], 
+       expressions[233], expressions[235], expressions[238], expressions[241], expressions[244], expressions[247], 
+       expressions[250], expressions[253], expressions[256], expressions[259], expressions[262], expressions[265], 
+       expressions[268], expressions[271], expressions[274], expressions[277], expressions[280], expressions[283], 
+       expressions[286], expressions[289], expressions[292], expressions[295], expressions[298], expressions[301], 
+       expressions[304], expressions[307], expressions[310], expressions[313], expressions[316], expressions[319], 
+       expressions[322], expressions[325], expressions[328], expressions[331], expressions[334], expressions[337], 
+       expressions[340], expressions[343], expressions[346], expressions[349], expressions[352], expressions[355], 
+       expressions[358], expressions[361], expressions[364], expressions[367], expressions[370], expressions[373], 
+       expressions[376], expressions[379], expressions[382], expressions[385], expressions[388], expressions[391], 
+       expressions[394], expressions[397], expressions[400], expressions[403], expressions[406], expressions[409], 
+       expressions[412], expressions[415], expressions[418], expressions[421], expressions[424], expressions[427], 
+       expressions[430], expressions[433], expressions[436], expressions[439], expressions[442], expressions[445], 
+       expressions[448], expressions[451], expressions[454], expressions[457], expressions[460], expressions[463], 
+       expressions[466], expressions[469], expressions[472], expressions[475], expressions[478], expressions[481], 
+       expressions[484], expressions[487], expressions[490], expressions[493], expressions[496], expressions[499], 
+       expressions[502], expressions[505], expressions[508], expressions[511], expressions[514], expressions[517], 
+       expressions[520], expressions[523], expressions[526], expressions[529], expressions[532], expressions[535], 
+       expressions[538], expressions[541], expressions[544], expressions[547], expressions[550], expressions[553], 
+       expressions[556], expressions[559], expressions[562], expressions[565], expressions[568], expressions[571], 
+       expressions[574], expressions[577], expressions[580], expressions[583], expressions[586], 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[624], 
+       expressions[626], expressions[628], expressions[630], expressions[632], expressions[634], expressions[636], 
+       expressions[638], expressions[641], expressions[644], expressions[647], expressions[650], expressions[653], 
+       expressions[656], expressions[659], expressions[662], expressions[665], expressions[668], expressions[671], 
+       expressions[674], expressions[677], expressions[680], expressions[683], expressions[686], expressions[689], 
+       expressions[692], expressions[694], expressions[696], expressions[698], expressions[700], expressions[702], 
+       expressions[704], expressions[706], expressions[708], expressions[710], expressions[712], expressions[715], 
+       expressions[719], expressions[723], expressions[727], expressions[731], expressions[735], expressions[739], 
+       expressions[740], expressions[744], expressions[748], expressions[749], expressions[750], expressions[751], 
+       expressions[753], expressions[755], expressions[756], expressions[758], expressions[760], expressions[761], 
+       expressions[762], expressions[764], expressions[766], expressions[769], expressions[772], expressions[774], 
+       expressions[776], expressions[779], expressions[781], expressions[783], expressions[785], expressions[787], 
+       expressions[788], expressions[789], expressions[790], expressions[792], expressions[793], expressions[795], 
+       expressions[796], expressions[797], expressions[798], expressions[799], expressions[801], expressions[803], 
+       expressions[805], expressions[806], expressions[807], expressions[809], expressions[811], expressions[813], 
+       expressions[815], expressions[817], expressions[819], expressions[821], expressions[823], expressions[825], 
+       expressions[827], expressions[829], expressions[831], expressions[832], expressions[833] };
+    expressions[834] = BinaryenBlock(the_module, "the-value", children, 316, BinaryenTypeAuto());
+  }
+  expressions[835] = BinaryenDrop(the_module, expressions[834]);
+  {
+    BinaryenExpressionRef children[] = { expressions[835] };
+    expressions[836] = BinaryenBlock(the_module, "the-nothing", children, 1, BinaryenTypeAuto());
+  }
+  expressions[837] = BinaryenConst(the_module, BinaryenLiteralInt32(42));
+  {
+    BinaryenExpressionRef children[] = { expressions[836], expressions[837] };
+    expressions[838] = BinaryenBlock(the_module, "the-body", children, 2, BinaryenTypeAuto());
   }
   {
     BinaryenType varTypes[] = { 2, 10 };
-    functions[0] = BinaryenAddFunction(the_module, "kitchen()sinker", 11, 2, varTypes, 2, expressions[827]);
+    functions[0] = BinaryenAddFunction(the_module, "kitchen()sinker", 11, 2, varTypes, 2, expressions[838]);
   }
-  expressions[828] = BinaryenConst(the_module, BinaryenLiteralInt32(7));
-  globals[0] = BinaryenAddGlobal(the_module, "a-global", 2, 0, expressions[828]);
-  expressions[829] = BinaryenConst(the_module, BinaryenLiteralFloat32(7.5));
-  globals[1] = BinaryenAddGlobal(the_module, "a-mutable-global", 4, 1, expressions[829]);
+  expressions[839] = BinaryenConst(the_module, BinaryenLiteralInt32(7));
+  globals[0] = BinaryenAddGlobal(the_module, "a-global", 2, 0, expressions[839]);
+  expressions[840] = BinaryenConst(the_module, BinaryenLiteralFloat32(7.5));
+  globals[1] = BinaryenAddGlobal(the_module, "a-mutable-global", 4, 1, expressions[840]);
   {
     BinaryenType t280[] = {2, 5};
     BinaryenTypeCreate(t280, 2); // 12
@@ -1798,25 +1815,25 @@ int main() {
   BinaryenAddFunctionImport(the_module, "an-imported", "module", "base", 12, 4);
   exports[0] = BinaryenAddFunctionExport(the_module, "kitchen()sinker", "kitchen_sinker");
   BinaryenFunctionGetName(functions[0]);
-  expressions[830] = BinaryenConst(the_module, BinaryenLiteralInt32(0));
+  expressions[841] = BinaryenConst(the_module, BinaryenLiteralInt32(0));
   {
     const char* funcNames[] = { "kitchen()sinker" };
-    BinaryenSetFunctionTable(the_module, 1, 1, funcNames, 1, expressions[830]);
+    BinaryenSetFunctionTable(the_module, 1, 1, funcNames, 1, expressions[841]);
   }
-  expressions[831] = BinaryenConst(the_module, BinaryenLiteralInt32(10));
+  expressions[842] = 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[831], expressions[0] };
+    BinaryenExpressionRef segmentOffsets[] = { expressions[842], expressions[0] };
     BinaryenIndex segmentSizes[] = { 12, 12 };
     BinaryenSetMemory(the_module, 1, 256, "mem", segments, segmentPassive, segmentOffsets, segmentSizes, 2, 1);
   }
-  expressions[832] = BinaryenNop(the_module);
+  expressions[843] = BinaryenNop(the_module);
   {
     BinaryenType varTypes[] = { 0 };
-    functions[1] = BinaryenAddFunction(the_module, "starter", 0, 0, varTypes, 0, expressions[832]);
+    functions[1] = BinaryenAddFunction(the_module, "starter", 0, 0, varTypes, 0, expressions[843]);
   }
   BinaryenSetStart(the_module, functions[1]);
   BinaryenModuleAutoDrop(the_module);
@@ -3528,6 +3545,24 @@ int main() {
        )
       )
       (atomic.fence)
+      (drop
+       (tuple.make
+        (i32.const 13)
+        (i64.const 37)
+        (f32.const 1.2999999523162842)
+        (f64.const 3.7)
+       )
+      )
+      (drop
+       (tuple.extract 2
+        (tuple.make
+         (i32.const 13)
+         (i64.const 37)
+         (f32.const 1.2999999523162842)
+         (f64.const 3.7)
+        )
+       )
+      )
       (push
        (i32.pop)
       )
@@ -6260,6 +6295,24 @@ BinaryenFeatureAll: 1023
        )
       )
       (atomic.fence)
+      (drop
+       (tuple.make
+        (i32.const 13)
+        (i64.const 37)
+        (f32.const 1.2999999523162842)
+        (f64.const 3.7)
+       )
+      )
+      (drop
+       (tuple.extract 2
+        (tuple.make
+         (i32.const 13)
+         (i64.const 37)
+         (f32.const 1.2999999523162842)
+         (f64.const 3.7)
+        )
+       )
+      )
       (push
        (i32.pop)
       )
diff --git a/test/example/c-api-kitchen-sink.txt.txt b/test/example/c-api-kitchen-sink.txt.txt
index 846679e84..574473790 100644
--- a/test/example/c-api-kitchen-sink.txt.txt
+++ b/test/example/c-api-kitchen-sink.txt.txt
@@ -1705,6 +1705,24 @@
        )
       )
       (atomic.fence)
+      (drop
+       (tuple.make
+        (i32.const 13)
+        (i64.const 37)
+        (f32.const 1.2999999523162842)
+        (f64.const 3.7)
+       )
+      )
+      (drop
+       (tuple.extract 2
+        (tuple.make
+         (i32.const 13)
+         (i64.const 37)
+         (f32.const 1.2999999523162842)
+         (f64.const 3.7)
+        )
+       )
+      )
       (push
        (i32.pop)
       )