Bug 1592783 - Update in-tree and spec-tests for trapping change. r=lth
authorRyan Hunt <rhunt@eqrion.net>
Tue, 05 Nov 2019 15:27:34 +0000
changeset 500652 70bd926c6ca95e796a9187a437993688ffae3c3d
parent 500651 801e6ae4efdeb516250c6800e31f969d337b8f40
child 500653 933f3452a368cddf7a67bf71e2956ee7cac9a718
push id114166
push userapavel@mozilla.com
push dateThu, 07 Nov 2019 10:04:01 +0000
treeherdermozilla-inbound@d271c572a9bc [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewerslth
bugs1592783
milestone72.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 1592783 - Update in-tree and spec-tests for trapping change. r=lth This commit relies on a patch to the spec interpreter/tests to also make the trapping change there [1] [2]. [1] https://github.com/eqrion/wasm-spec/tree/spidermonkey-tree-tests [2] https://github.com/eqrion/wasm-spec/commit/b467c3e4e32f17d1433628ea7f40793b57bd9663 Differential Revision: https://phabricator.services.mozilla.com/D51756
js/src/jit-test/tests/wasm/gc/tables-fill.js
js/src/jit-test/tests/wasm/import-export.js
js/src/jit-test/tests/wasm/passive-segs-partial-mem.js
js/src/jit-test/tests/wasm/passive-segs-partial-table.js
js/src/jit-test/tests/wasm/spec/bulk.wast.js
js/src/jit-test/tests/wasm/spec/memory_copy.wast.js
js/src/jit-test/tests/wasm/spec/memory_fill.wast.js
js/src/jit-test/tests/wasm/spec/memory_init.wast.js
js/src/jit-test/tests/wasm/spec/table_copy.wast.js
js/src/jit-test/tests/wasm/spec/table_init.wast.js
testing/web-platform/mozilla/tests/wasm/js/bulk.wast.js
testing/web-platform/mozilla/tests/wasm/js/memory_copy.wast.js
testing/web-platform/mozilla/tests/wasm/js/memory_fill.wast.js
testing/web-platform/mozilla/tests/wasm/js/memory_init.wast.js
testing/web-platform/mozilla/tests/wasm/js/table_copy.wast.js
testing/web-platform/mozilla/tests/wasm/js/table_init.wast.js
--- a/js/src/jit-test/tests/wasm/gc/tables-fill.js
+++ b/js/src/jit-test/tests/wasm/gc/tables-fill.js
@@ -50,16 +50,24 @@ function testTableFill(tbl_type, val_typ
 
   // Check that messing with table 0 above hasn't changed table 1.
   for (let i = 0; i < 10; i++) {
       assertEq(ins.exports.get1(i), null);
   }
 
   // Now a bunch of tests involving only table 1.
 
+  // Partly outside the table
+  assertErrorMessage(() => ins.exports.fill1(8, obj[5], 3),
+                     RangeError, /table index out of bounds/);
+
+  assertEq(ins.exports.get1(7), null);
+  assertEq(ins.exports.get1(8), null);
+  assertEq(ins.exports.get1(9), null);
+
   // Within the table
   assertEq(ins.exports.fill1(2, obj[0], 3), undefined);
   assertEq(ins.exports.get1(1), null);
   assertEq(ins.exports.get1(2), obj[0]);
   assertEq(ins.exports.get1(3), obj[0]);
   assertEq(ins.exports.get1(4), obj[0]);
   assertEq(ins.exports.get1(5), null);
 
@@ -86,24 +94,16 @@ function testTableFill(tbl_type, val_typ
   assertEq(ins.exports.fill1(9, null, 1), undefined);
   assertEq(ins.exports.get1(8), obj[3]);
   assertEq(ins.exports.get1(9), null);
 
   // Within the table
   assertEq(ins.exports.fill1(10, obj[4], 0), undefined);
   assertEq(ins.exports.get1(9), null);
 
-  // Partly outside the table
-  assertErrorMessage(() => ins.exports.fill1(8, obj[5], 3),
-                     RangeError, /table index out of bounds/);
-
-  assertEq(ins.exports.get1(7), null);
-  assertEq(ins.exports.get1(8), obj[5]);
-  assertEq(ins.exports.get1(9), obj[5]);
-
   // Boundary tests on table 1: at the edge of the table.
 
   // Length-zero fill1 at the edge of the table must succeed
   assertEq(ins.exports.fill1(10, null, 0), undefined);
 
   // Length-one fill1 at the edge of the table fails
   assertErrorMessage(() => ins.exports.fill1(10, null, 1),
                      RangeError, /table index out of bounds/);
--- a/js/src/jit-test/tests/wasm/import-export.js
+++ b/js/src/jit-test/tests/wasm/import-export.js
@@ -584,17 +584,17 @@ mem8[0] = 0;
 // Both element and data segments apply successfully without OOB
 
 var i = new Instance(m, {a:{mem, tbl, memOff:npages*64*1024-1, tblOff:1}});
 assertEq(mem8[0], 1);
 assertEq(mem8[npages*64*1024-1], 2);
 assertEq(tbl.get(0), i.exports.f);
 assertEq(tbl.get(1), i.exports.g);
 
-// Element segment applies partially and prevents subsequent elem segment and
+// Element segment doesn't apply and prevents subsequent elem segment and
 // data segment from being applied.
 
 if (wasmBulkMemSupported()) {
     let m = new Module(wasmTextToBinary(
         `(module
            (import "" "mem" (memory 1))
            (import "" "tbl" (table 3 funcref))
            (elem (i32.const 1) $f $g $h) ;; fails after $f and $g
@@ -604,39 +604,39 @@ if (wasmBulkMemSupported()) {
            (func $g)
            (func $h))`));
     let mem = new Memory({initial:1});
     let tbl = new Table({initial:3, element:"funcref"});
     assertErrorMessage(() => new Instance(m, {"":{mem, tbl}}),
                        LinkError,
                        /elem segment does not fit/);
     assertEq(tbl.get(0), null);
-    assertEq(typeof tbl.get(1), "function");
-    assertEq(typeof tbl.get(2), "function");
+    assertEq(tbl.get(1), null);
+    assertEq(tbl.get(2), null);
     let v = new Uint8Array(mem.buffer);
     assertEq(v[0], 0);
 }
 
-// Data segment applies partially and prevents subsequent data segment from
+// Data segment doesn't apply and prevents subsequent data segment from
 // being applied.
 
 if (wasmBulkMemSupported()) {
     let m = new Module(wasmTextToBinary(
         `(module
            (import "" "mem" (memory 1))
            (data (i32.const 65534) "\\01\\02\\03") ;; fails after 1 and 2
            (data (i32.const 0) "\\04")             ;; is not applied
          )`));
     let mem = new Memory({initial:1});
     assertErrorMessage(() => new Instance(m, {"":{mem}}),
                        LinkError,
                        /data segment does not fit/);
     let v = new Uint8Array(mem.buffer);
-    assertEq(v[65534], 1);
-    assertEq(v[65535], 2);
+    assertEq(v[65534], 0);
+    assertEq(v[65535], 0);
     assertEq(v[0], 0);
 }
 
 // Elem segments on imported tables
 
 var m = new Module(wasmTextToBinary(`
     (module
         (import "a" "b" (table 10 funcref))
--- a/js/src/jit-test/tests/wasm/passive-segs-partial-mem.js
+++ b/js/src/jit-test/tests/wasm/passive-segs-partial-mem.js
@@ -8,80 +8,77 @@ if (conf.debug &&
     // Will timeout, so just quit early.
     quit(0);
 }
 
 // Sundry test cases for the "partial write" bounds checking semantics.
 
 const PAGESIZE = 65536;
 
-// memory.fill: out of bounds, but should perform a partial fill.
+// memory.fill: out of bounds, should not perform writes
 //
 // Arithmetic overflow of memory offset + len should not affect the behavior, we
 // should still fill up to the limit.
 
 function mem_fill(min, max, shared, backup, write=backup*2) {
     let ins = wasmEvalText(
         `(module
            (memory (export "mem") ${min} ${max} ${shared})
            (func (export "run") (param $offs i32) (param $val i32) (param $len i32)
              (memory.fill (local.get $offs) (local.get $val) (local.get $len))))`);
-    // A fill past the end should throw *and* have filled all the way up to the end
+    // A fill past the end should throw *and* not have filled all the way up to
+    // the end
     let offs = min*PAGESIZE - backup;
     let val = 37;
     assertErrorMessage(() => ins.exports.run(offs, val, write),
                        WebAssembly.RuntimeError,
                        /index out of bounds/);
     let v = new Uint8Array(ins.exports.mem.buffer);
     for (let i=0; i < backup; i++)
-        assertEq(v[offs+i], val);
+        assertEq(v[offs+i], 0);
     for (let i=0; i < offs; i++)
         assertEq(v[i], 0);
 }
 
 mem_fill(1, 1, "", 256);
 mem_fill(1, 1, "", 257);
 mem_fill(1, 1, "", 257, 0xFFFFFFFF); // offs + len overflows 32-bit
 
 mem_fill(2, 4, "shared", 256);
 mem_fill(2, 4, "shared", 257);
 mem_fill(2, 4, "shared", 257, 0xFFFFFFFF); // offs + len overflows 32-bit
 
-// memory.init: out of bounds of the memory or the segment, but should perform
-// the operation up to the appropriate bound.
+// memory.init: out of bounds of the memory or the segment, and should not perform
+// the operation at all.
 //
 // Arithmetic overflow of memoffset + len or of bufferoffset + len should not
 // affect the behavior.
 
 // Note, the length of the data segment is 16.
 const mem_init_len = 16;
 
 function mem_init(min, max, shared, backup, write) {
     let ins = wasmEvalText(
         `(module
            (memory (export "mem") ${min} ${max} ${shared})
            (data "\\42\\42\\42\\42\\42\\42\\42\\42\\42\\42\\42\\42\\42\\42\\42\\42")
            (func (export "run") (param $offs i32) (param $len i32)
              (memory.init 0 (local.get $offs) (i32.const 0) (local.get $len))))`);
-    // A fill writing past the end of the memory should throw *and* have filled
+    // A fill writing past the end of the memory should throw *and* not have filled
     // all the way up to the end.
     //
-    // A fill reading past the end of the segment should throw *and* have filled
+    // A fill reading past the end of the segment should throw *and* not have filled
     // memory with as much data as was available.
     let offs = min*PAGESIZE - backup;
     assertErrorMessage(() => ins.exports.run(offs, write),
                        WebAssembly.RuntimeError,
                        /index out of bounds/);
     let v = new Uint8Array(ins.exports.mem.buffer);
-    for (let i=0; i < Math.min(backup, mem_init_len); i++)
-        assertEq(v[offs + i], 0x42);
-    for (let i=Math.min(backup, mem_init_len); i < backup; i++)
+    for (let i=0; i < min; i++)
         assertEq(v[offs + i], 0);
-    for (let i=0; i < offs; i++)
-        assertEq(v[i], 0);
 }
 
 // We exceed the bounds of the memory but not of the data segment
 mem_init(1, 1, "", Math.floor(mem_init_len/2), mem_init_len);
 mem_init(1, 1, "", Math.floor(mem_init_len/2)+1, mem_init_len);
 mem_init(2, 4, "shared", Math.floor(mem_init_len/2), mem_init_len);
 mem_init(2, 4, "shared", Math.floor(mem_init_len/2)+1, mem_init_len);
 
@@ -92,18 +89,18 @@ mem_init(2, 4, "shared", mem_init_len*4,
 mem_init(2, 4, "shared", mem_init_len*4-1, mem_init_len*2-1);
 
 // We arithmetically overflow the memory limit but not the segment limit
 mem_init(1, "", "", Math.floor(mem_init_len/2), 0xFFFFFF00);
 
 // We arithmetically overflow the segment limit but not the memory limit
 mem_init(1, "", "", PAGESIZE, 0xFFFFFFFC);
 
-// memory.copy: out of bounds of the memory for the source or target, but should
-// perform the operation up to the appropriate bound.  Major cases:
+// memory.copy: out of bounds of the memory for the source or target, and should
+// not perform at all.  Major cases:
 //
 // - non-overlapping regions
 // - overlapping regions with src >= dest
 // - overlapping regions with src == dest
 // - overlapping regions with src < dest
 // - arithmetic overflow on src addresses
 // - arithmetic overflow on target addresses
 //
@@ -120,58 +117,28 @@ function mem_copy(min, max, shared, srcO
            (func (export "run") (param $targetOffs i32) (param $srcOffs i32) (param $len i32)
              (memory.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len))))`);
 
     let v = new Uint8Array(ins.exports.mem.buffer);
 
     let copyDown = srcOffs < targetOffs;
     let targetAvail = v.length - targetOffs;
     let srcAvail = v.length - srcOffs;
-    let targetLim = targetOffs + Math.min(len, targetAvail, srcAvail);
     let srcLim = srcOffs + Math.min(len, targetAvail, srcAvail);
-    let immediateOOB = copyDown && (srcOffs + len > v.length || targetOffs + len > v.length);
 
     for (let i=srcOffs, j=0; i < srcLim; i++, j++)
         v[i] = j;
     assertErrorMessage(() => ins.exports.run(targetOffs, srcOffs, len),
                        WebAssembly.RuntimeError,
                        /index out of bounds/);
 
-    // :lth wants lambda-lifting and closure optimizations
-    var t = 0;
-    var s = 0;
-    var i = 0;
-    function checkTarget() {
-        if (i >= targetOffs && i < targetLim) {
-            assertEq(v[i], (t++) & 0xFF);
-            if (i >= srcOffs && i < srcLim)
-                s++;
-            return true;
-        }
-        return false;
-    }
-    function checkSource() {
+    for (var i=0, s=0; i < v.length; i++ ) {
         if (i >= srcOffs && i < srcLim) {
             assertEq(v[i], (s++) & 0xFF);
-            if (i >= targetOffs && i < targetLim)
-                t++;
-            return true;
-        }
-        return false;
-    }
-
-    for (i=0; i < v.length; i++ ) {
-        if (immediateOOB) {
-            if (checkSource())
-                continue;
-        } else {
-            if (copyDown && (checkSource() || checkTarget()))
-                continue;
-            if (!copyDown && (checkTarget() || checkSource()))
-                continue;
+            continue;
         }
         assertEq(v[i], 0);
     }
 }
 
 // OOB target address, nonoverlapping
 mem_copy(1, 1, "", 0, PAGESIZE-20, 40);
 mem_copy(1, 1, "", 0, PAGESIZE-21, 39);
--- a/js/src/jit-test/tests/wasm/passive-segs-partial-table.js
+++ b/js/src/jit-test/tests/wasm/passive-segs-partial-table.js
@@ -1,14 +1,14 @@
 // |jit-test| skip-if: !wasmBulkMemSupported()
 
 // Sundry test cases for the "partial write" bounds checking semantics.
 
-// table.init: out of bounds of the table or the element segment, but should
-// perform the operation up to the appropriate bound.
+// table.init: out of bounds of the table or the element segment, and should
+// not perform the operation at all.
 //
 // Arithmetic overflow of tableoffset + len or of segmentoffset + len should not
 // affect the behavior.
 
 // Note, the length of the element segment is 16.
 const tbl_init_len = 16;
 
 function tbl_init(min, max, backup, write, segoffs=0) {
@@ -39,41 +39,37 @@ function tbl_init(min, max, backup, writ
     //
     // A fill reading past the end of the segment should throw *and* have filled
     // table with as much data as was available.
     let offs = min - backup;
     assertErrorMessage(() => ins.exports.run(offs, write),
                        WebAssembly.RuntimeError,
                        /index out of bounds/);
     let tbl = ins.exports.tbl;
-    for (let i=0; i < Math.min(backup, tbl_init_len - segoffs); i++) {
-        assertEq(tbl.get(offs + i), ins.exports["f" + (i + segoffs)]);
+    for (let i=0; i < min; i++) {
+        assertEq(tbl.get(i), null);
     }
-    for (let i=Math.min(backup, tbl_init_len); i < backup; i++)
-        assertEq(tbl.get(offs + i), null);
-    for (let i=0; i < offs; i++)
-        assertEq(tbl.get(i), null);
 }
 
 // We exceed the bounds of the table but not of the element segment
 tbl_init(tbl_init_len*2, tbl_init_len*4, Math.floor(tbl_init_len/2), tbl_init_len);
 tbl_init(tbl_init_len*2, tbl_init_len*4, Math.floor(tbl_init_len/2)-1, tbl_init_len);
 
 // We exceed the bounds of the element segment but not the table
 tbl_init(tbl_init_len*10, tbl_init_len*20, tbl_init_len*4, tbl_init_len*2);
 tbl_init(tbl_init_len*10, tbl_init_len*20, tbl_init_len*4-1, tbl_init_len*2-1);
 
 // We arithmetically overflow the table limit but not the segment limit
 tbl_init(tbl_init_len*4, tbl_init_len*4, tbl_init_len, 0xFFFFFFF0);
 
 // We arithmetically overflow the segment limit but not the table limit
 tbl_init(tbl_init_len, tbl_init_len, tbl_init_len, 0xFFFFFFFC, Math.floor(tbl_init_len/2));
 
-// table.copy: out of bounds of the table for the source or target, but should
-// perform the operation up to the appropriate bound.  Major cases:
+// table.copy: out of bounds of the table for the source or target, and should
+// perform the operation at all.  Major cases:
 //
 // - non-overlapping regions
 // - overlapping regions with src > dest
 // - overlapping regions with src == dest
 // - overlapping regions with src < dest
 // - arithmetic overflow on src addresses
 // - arithmetic overflow on target addresses
 //
@@ -111,57 +107,28 @@ function tbl_copy(min, max, srcOffs, tar
            (func (export "run") (param $targetOffs i32) (param $srcOffs i32) (param $len i32)
              (table.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len))))`);
 
     let tbl = ins.exports.tbl;
 
     let copyDown = srcOffs < targetOffs;
     let targetAvail = tbl.length - targetOffs;
     let srcAvail = tbl.length - srcOffs;
-    let targetLim = targetOffs + Math.min(len, targetAvail, srcAvail);
     let srcLim = srcOffs + Math.min(len, targetAvail, srcAvail);
-    let immediateOOB = copyDown && (srcOffs + len > tbl.length || targetOffs + len > tbl.length);
 
     for (let i=srcOffs, j=0; i < srcLim; i++, j++)
         tbl.set(i, ins.exports["f" + j]);
     assertErrorMessage(() => ins.exports.run(targetOffs, srcOffs, len),
                        WebAssembly.RuntimeError,
                        /index out of bounds/);
 
-    var t = 0;
-    var s = 0;
-    var i = 0;
-    function checkTarget() {
-        if (i >= targetOffs && i < targetLim) {
-            assertEq(tbl.get(i), ins.exports["f" + (t++)]);
-            if (i >= srcOffs && i < srcLim)
-                s++;
-            return true;
-        }
-        return false;
-    }
-    function checkSource() {
+    for (var i=0, s=0; i < tbl.length; i++ ) {
         if (i >= srcOffs && i < srcLim) {
             assertEq(tbl.get(i), ins.exports["f" + (s++)]);
-            if (i >= targetOffs && i < targetLim)
-                t++;
-            return true;
-        }
-        return false;
-    }
-
-    for (i=0; i < tbl.length; i++ ) {
-        if (immediateOOB) {
-            if (checkSource())
-                continue;
-        } else {
-            if (copyDown && (checkSource() || checkTarget()))
-                continue;
-            if (!copyDown && (checkTarget() || checkSource()))
-                continue;
+            continue;
         }
         assertEq(tbl.get(i), null);
     }
 }
 
 // OOB target address, nonoverlapping
 tbl_copy(tbl_copy_len*2, tbl_copy_len*4, 0, Math.floor(1.5*tbl_copy_len), tbl_copy_len);
 tbl_copy(tbl_copy_len*2, tbl_copy_len*4, 0, Math.floor(1.5*tbl_copy_len)-1, tbl_copy_len-1);
--- a/js/src/jit-test/tests/wasm/spec/bulk.wast.js
+++ b/js/src/jit-test/tests/wasm/spec/bulk.wast.js
@@ -37,20 +37,20 @@ assert_return(() => call($3, "load8_u", 
 
 // bulk.wast:40
 run(() => call($3, "fill", [0, 0, 65_536]));
 
 // bulk.wast:43
 assert_trap(() => call($3, "fill", [65_280, 1, 257]));
 
 // bulk.wast:45
-assert_return(() => call($3, "load8_u", [65_280]), 1);
+assert_return(() => call($3, "load8_u", [65_280]), 0);
 
 // bulk.wast:46
-assert_return(() => call($3, "load8_u", [65_535]), 1);
+assert_return(() => call($3, "load8_u", [65_535]), 0);
 
 // bulk.wast:49
 run(() => call($3, "fill", [65_536, 0, 0]));
 
 // bulk.wast:52
 run(() => call($3, "fill", [65_537, 0, 0]));
 
 // bulk.wast:56
@@ -151,26 +151,26 @@ assert_return(() => call($5, "load8_u", 
 
 // bulk.wast:128
 assert_return(() => call($5, "load8_u", [1]), 204);
 
 // bulk.wast:129
 assert_return(() => call($5, "load8_u", [2]), 0);
 
 // bulk.wast:132
-run(() => call($5, "init", [65_532, 0, 4]));
-
-// bulk.wast:135
 assert_trap(() => call($5, "init", [65_534, 0, 3]));
 
-// bulk.wast:137
-assert_return(() => call($5, "load8_u", [65_534]), 170);
+// bulk.wast:134
+assert_return(() => call($5, "load8_u", [65_534]), 0);
+
+// bulk.wast:135
+assert_return(() => call($5, "load8_u", [65_535]), 0);
 
 // bulk.wast:138
-assert_return(() => call($5, "load8_u", [65_535]), 187);
+run(() => call($5, "init", [65_532, 0, 4]));
 
 // bulk.wast:141
 run(() => call($5, "init", [65_536, 0, 0]));
 
 // bulk.wast:142
 run(() => call($5, "init", [0, 4, 0]));
 
 // bulk.wast:145
@@ -198,118 +198,118 @@ assert_trap(() => call($6, "init_passive
 assert_trap(() => call($6, "drop_active", []));
 
 // bulk.wast:168
 assert_trap(() => call($6, "init_active", []));
 
 // bulk.wast:172
 let $7 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x90\x80\x80\x80\x00\x03\x60\x00\x01\x7f\x60\x03\x7f\x7f\x7f\x00\x60\x01\x7f\x01\x7f\x03\x85\x80\x80\x80\x00\x04\x00\x00\x01\x02\x04\x84\x80\x80\x80\x00\x01\x70\x00\x03\x07\x8f\x80\x80\x80\x00\x02\x04\x69\x6e\x69\x74\x00\x02\x04\x63\x61\x6c\x6c\x00\x03\x09\x90\x80\x80\x80\x00\x01\x05\x70\x04\xd2\x00\x0b\xd2\x01\x0b\xd2\x00\x0b\xd2\x01\x0b\x0a\xb0\x80\x80\x80\x00\x04\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x8c\x80\x80\x80\x00\x00\x20\x00\x20\x01\x20\x02\xfc\x0c\x00\x00\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x00\x0b");
 
-// bulk.wast:191
-run(() => call($7, "init", [0, 1, 2]));
-
 // bulk.wast:192
-assert_return(() => call($7, "call", [0]), 1);
-
-// bulk.wast:193
-assert_return(() => call($7, "call", [1]), 0);
+assert_trap(() => call($7, "init", [2, 0, 2]));
 
 // bulk.wast:194
 assert_trap(() => call($7, "call", [2]));
 
 // bulk.wast:197
-run(() => call($7, "init", [1, 2, 2]));
+run(() => call($7, "init", [0, 1, 2]));
+
+// bulk.wast:198
+assert_return(() => call($7, "call", [0]), 1);
+
+// bulk.wast:199
+assert_return(() => call($7, "call", [1]), 0);
 
 // bulk.wast:200
-assert_trap(() => call($7, "init", [2, 0, 2]));
+assert_trap(() => call($7, "call", [2]));
 
-// bulk.wast:202
-assert_return(() => call($7, "call", [2]), 0);
+// bulk.wast:203
+run(() => call($7, "init", [1, 2, 2]));
 
-// bulk.wast:205
+// bulk.wast:206
 run(() => call($7, "init", [3, 0, 0]));
 
-// bulk.wast:206
+// bulk.wast:207
 run(() => call($7, "init", [0, 4, 0]));
 
-// bulk.wast:209
+// bulk.wast:210
 run(() => call($7, "init", [4, 0, 0]));
 
-// bulk.wast:210
+// bulk.wast:211
 run(() => call($7, "init", [0, 5, 0]));
 
-// bulk.wast:214
+// bulk.wast:215
 let $8 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x86\x80\x80\x80\x00\x05\x00\x00\x00\x00\x00\x04\x84\x80\x80\x80\x00\x01\x70\x00\x01\x07\xbb\x80\x80\x80\x00\x04\x0c\x64\x72\x6f\x70\x5f\x70\x61\x73\x73\x69\x76\x65\x00\x01\x0c\x69\x6e\x69\x74\x5f\x70\x61\x73\x73\x69\x76\x65\x00\x02\x0b\x64\x72\x6f\x70\x5f\x61\x63\x74\x69\x76\x65\x00\x03\x0b\x69\x6e\x69\x74\x5f\x61\x63\x74\x69\x76\x65\x00\x04\x09\x8d\x80\x80\x80\x00\x02\x05\x70\x01\xd2\x00\x0b\x00\x41\x00\x0b\x01\x00\x0a\xbe\x80\x80\x80\x00\x05\x82\x80\x80\x80\x00\x00\x0b\x85\x80\x80\x80\x00\x00\xfc\x0d\x00\x0b\x8c\x80\x80\x80\x00\x00\x41\x00\x41\x00\x41\x00\xfc\x0c\x00\x00\x0b\x85\x80\x80\x80\x00\x00\xfc\x0d\x01\x0b\x8c\x80\x80\x80\x00\x00\x41\x00\x41\x00\x41\x00\xfc\x0c\x01\x00\x0b");
 
-// bulk.wast:229
+// bulk.wast:230
 run(() => call($8, "init_passive", []));
 
-// bulk.wast:230
+// bulk.wast:231
 run(() => call($8, "drop_passive", []));
 
-// bulk.wast:231
-assert_trap(() => call($8, "drop_passive", []));
-
 // bulk.wast:232
-assert_trap(() => call($8, "init_passive", []));
+assert_trap(() => call($8, "drop_passive", []));
 
 // bulk.wast:233
-assert_trap(() => call($8, "drop_active", []));
+assert_trap(() => call($8, "init_passive", []));
 
 // bulk.wast:234
+assert_trap(() => call($8, "drop_active", []));
+
+// bulk.wast:235
 assert_trap(() => call($8, "init_active", []));
 
-// bulk.wast:238
+// bulk.wast:239
 let $9 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x90\x80\x80\x80\x00\x03\x60\x00\x01\x7f\x60\x03\x7f\x7f\x7f\x00\x60\x01\x7f\x01\x7f\x03\x86\x80\x80\x80\x00\x05\x00\x00\x00\x01\x02\x04\x84\x80\x80\x80\x00\x01\x70\x00\x0a\x07\x8f\x80\x80\x80\x00\x02\x04\x63\x6f\x70\x79\x00\x03\x04\x63\x61\x6c\x6c\x00\x04\x09\x89\x80\x80\x80\x00\x01\x00\x41\x00\x0b\x03\x00\x01\x02\x0a\xb9\x80\x80\x80\x00\x05\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x8c\x80\x80\x80\x00\x00\x20\x00\x20\x01\x20\x02\xfc\x0e\x00\x00\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x00\x0b");
 
-// bulk.wast:257
+// bulk.wast:258
 run(() => call($9, "copy", [3, 0, 3]));
 
-// bulk.wast:259
+// bulk.wast:260
 assert_return(() => call($9, "call", [3]), 0);
 
-// bulk.wast:260
+// bulk.wast:261
 assert_return(() => call($9, "call", [4]), 1);
 
-// bulk.wast:261
+// bulk.wast:262
 assert_return(() => call($9, "call", [5]), 2);
 
-// bulk.wast:264
+// bulk.wast:265
 run(() => call($9, "copy", [0, 1, 3]));
 
-// bulk.wast:266
-assert_return(() => call($9, "call", [0]), 1);
-
 // bulk.wast:267
-assert_return(() => call($9, "call", [1]), 2);
+assert_return(() => call($9, "call", [0]), 1);
 
 // bulk.wast:268
+assert_return(() => call($9, "call", [1]), 2);
+
+// bulk.wast:269
 assert_return(() => call($9, "call", [2]), 0);
 
-// bulk.wast:271
+// bulk.wast:272
 run(() => call($9, "copy", [2, 0, 3]));
 
-// bulk.wast:273
+// bulk.wast:274
 assert_return(() => call($9, "call", [2]), 1);
 
-// bulk.wast:274
+// bulk.wast:275
 assert_return(() => call($9, "call", [3]), 2);
 
-// bulk.wast:275
+// bulk.wast:276
 assert_return(() => call($9, "call", [4]), 0);
 
-// bulk.wast:278
-run(() => call($9, "copy", [6, 8, 2]));
-
 // bulk.wast:279
-run(() => call($9, "copy", [8, 6, 2]));
+run(() => call($9, "copy", [6, 8, 2]));
 
-// bulk.wast:282
-run(() => call($9, "copy", [10, 0, 0]));
+// bulk.wast:280
+run(() => call($9, "copy", [8, 6, 2]));
 
 // bulk.wast:283
+run(() => call($9, "copy", [10, 0, 0]));
+
+// bulk.wast:284
 run(() => call($9, "copy", [0, 10, 0]));
 
-// bulk.wast:286
+// bulk.wast:287
 run(() => call($9, "copy", [11, 0, 0]));
 
-// bulk.wast:287
+// bulk.wast:288
 run(() => call($9, "copy", [0, 11, 0]));
--- a/js/src/jit-test/tests/wasm/spec/memory_copy.wast.js
+++ b/js/src/jit-test/tests/wasm/spec/memory_copy.wast.js
@@ -2878,10740 +2878,10467 @@ assert_return(() => call($10, "load8_u",
 
 // memory_copy.wast:1064
 let $11 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8c\x80\x80\x80\x00\x02\x60\x03\x7f\x7f\x7f\x00\x60\x01\x7f\x01\x7f\x03\x83\x80\x80\x80\x00\x02\x00\x01\x05\x84\x80\x80\x80\x00\x01\x01\x01\x01\x07\x97\x80\x80\x80\x00\x03\x03\x6d\x65\x6d\x02\x00\x03\x72\x75\x6e\x00\x00\x07\x6c\x6f\x61\x64\x38\x5f\x75\x00\x01\x0a\x9e\x80\x80\x80\x00\x02\x8c\x80\x80\x80\x00\x00\x20\x00\x20\x01\x20\x02\xfc\x0a\x00\x00\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x2d\x00\x00\x0b\x0b\x9c\x80\x80\x80\x00\x01\x00\x41\xec\xff\x03\x0b\x14\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10\x11\x12\x13");
 
 // memory_copy.wast:1072
 assert_trap(() => call($11, "run", [0, 65_516, 40]));
 
 // memory_copy.wast:1075
-assert_return(() => call($11, "load8_u", [0]), 0);
+assert_return(() => call($11, "load8_u", [198]), 0);
 
 // memory_copy.wast:1076
-assert_return(() => call($11, "load8_u", [1]), 1);
+assert_return(() => call($11, "load8_u", [397]), 0);
 
 // memory_copy.wast:1077
-assert_return(() => call($11, "load8_u", [2]), 2);
+assert_return(() => call($11, "load8_u", [596]), 0);
 
 // memory_copy.wast:1078
-assert_return(() => call($11, "load8_u", [3]), 3);
+assert_return(() => call($11, "load8_u", [795]), 0);
 
 // memory_copy.wast:1079
-assert_return(() => call($11, "load8_u", [4]), 4);
+assert_return(() => call($11, "load8_u", [994]), 0);
 
 // memory_copy.wast:1080
-assert_return(() => call($11, "load8_u", [5]), 5);
+assert_return(() => call($11, "load8_u", [1_193]), 0);
 
 // memory_copy.wast:1081
-assert_return(() => call($11, "load8_u", [6]), 6);
+assert_return(() => call($11, "load8_u", [1_392]), 0);
 
 // memory_copy.wast:1082
-assert_return(() => call($11, "load8_u", [7]), 7);
+assert_return(() => call($11, "load8_u", [1_591]), 0);
 
 // memory_copy.wast:1083
-assert_return(() => call($11, "load8_u", [8]), 8);
+assert_return(() => call($11, "load8_u", [1_790]), 0);
 
 // memory_copy.wast:1084
-assert_return(() => call($11, "load8_u", [9]), 9);
+assert_return(() => call($11, "load8_u", [1_989]), 0);
 
 // memory_copy.wast:1085
-assert_return(() => call($11, "load8_u", [10]), 10);
+assert_return(() => call($11, "load8_u", [2_188]), 0);
 
 // memory_copy.wast:1086
-assert_return(() => call($11, "load8_u", [11]), 11);
+assert_return(() => call($11, "load8_u", [2_387]), 0);
 
 // memory_copy.wast:1087
-assert_return(() => call($11, "load8_u", [12]), 12);
+assert_return(() => call($11, "load8_u", [2_586]), 0);
 
 // memory_copy.wast:1088
-assert_return(() => call($11, "load8_u", [13]), 13);
+assert_return(() => call($11, "load8_u", [2_785]), 0);
 
 // memory_copy.wast:1089
-assert_return(() => call($11, "load8_u", [14]), 14);
+assert_return(() => call($11, "load8_u", [2_984]), 0);
 
 // memory_copy.wast:1090
-assert_return(() => call($11, "load8_u", [15]), 15);
+assert_return(() => call($11, "load8_u", [3_183]), 0);
 
 // memory_copy.wast:1091
-assert_return(() => call($11, "load8_u", [16]), 16);
+assert_return(() => call($11, "load8_u", [3_382]), 0);
 
 // memory_copy.wast:1092
-assert_return(() => call($11, "load8_u", [17]), 17);
+assert_return(() => call($11, "load8_u", [3_581]), 0);
 
 // memory_copy.wast:1093
-assert_return(() => call($11, "load8_u", [18]), 18);
+assert_return(() => call($11, "load8_u", [3_780]), 0);
 
 // memory_copy.wast:1094
-assert_return(() => call($11, "load8_u", [19]), 19);
+assert_return(() => call($11, "load8_u", [3_979]), 0);
 
 // memory_copy.wast:1095
-assert_return(() => call($11, "load8_u", [218]), 0);
+assert_return(() => call($11, "load8_u", [4_178]), 0);
 
 // memory_copy.wast:1096
-assert_return(() => call($11, "load8_u", [417]), 0);
+assert_return(() => call($11, "load8_u", [4_377]), 0);
 
 // memory_copy.wast:1097
-assert_return(() => call($11, "load8_u", [616]), 0);
+assert_return(() => call($11, "load8_u", [4_576]), 0);
 
 // memory_copy.wast:1098
-assert_return(() => call($11, "load8_u", [815]), 0);
+assert_return(() => call($11, "load8_u", [4_775]), 0);
 
 // memory_copy.wast:1099
-assert_return(() => call($11, "load8_u", [1_014]), 0);
+assert_return(() => call($11, "load8_u", [4_974]), 0);
 
 // memory_copy.wast:1100
-assert_return(() => call($11, "load8_u", [1_213]), 0);
+assert_return(() => call($11, "load8_u", [5_173]), 0);
 
 // memory_copy.wast:1101
-assert_return(() => call($11, "load8_u", [1_412]), 0);
+assert_return(() => call($11, "load8_u", [5_372]), 0);
 
 // memory_copy.wast:1102
-assert_return(() => call($11, "load8_u", [1_611]), 0);
+assert_return(() => call($11, "load8_u", [5_571]), 0);
 
 // memory_copy.wast:1103
-assert_return(() => call($11, "load8_u", [1_810]), 0);
+assert_return(() => call($11, "load8_u", [5_770]), 0);
 
 // memory_copy.wast:1104
-assert_return(() => call($11, "load8_u", [2_009]), 0);
+assert_return(() => call($11, "load8_u", [5_969]), 0);
 
 // memory_copy.wast:1105
-assert_return(() => call($11, "load8_u", [2_208]), 0);
+assert_return(() => call($11, "load8_u", [6_168]), 0);
 
 // memory_copy.wast:1106
-assert_return(() => call($11, "load8_u", [2_407]), 0);
+assert_return(() => call($11, "load8_u", [6_367]), 0);
 
 // memory_copy.wast:1107
-assert_return(() => call($11, "load8_u", [2_606]), 0);
+assert_return(() => call($11, "load8_u", [6_566]), 0);
 
 // memory_copy.wast:1108
-assert_return(() => call($11, "load8_u", [2_805]), 0);
+assert_return(() => call($11, "load8_u", [6_765]), 0);
 
 // memory_copy.wast:1109
-assert_return(() => call($11, "load8_u", [3_004]), 0);
+assert_return(() => call($11, "load8_u", [6_964]), 0);
 
 // memory_copy.wast:1110
-assert_return(() => call($11, "load8_u", [3_203]), 0);
+assert_return(() => call($11, "load8_u", [7_163]), 0);
 
 // memory_copy.wast:1111
-assert_return(() => call($11, "load8_u", [3_402]), 0);
+assert_return(() => call($11, "load8_u", [7_362]), 0);
 
 // memory_copy.wast:1112
-assert_return(() => call($11, "load8_u", [3_601]), 0);
+assert_return(() => call($11, "load8_u", [7_561]), 0);
 
 // memory_copy.wast:1113
-assert_return(() => call($11, "load8_u", [3_800]), 0);
+assert_return(() => call($11, "load8_u", [7_760]), 0);
 
 // memory_copy.wast:1114
-assert_return(() => call($11, "load8_u", [3_999]), 0);
+assert_return(() => call($11, "load8_u", [7_959]), 0);
 
 // memory_copy.wast:1115
-assert_return(() => call($11, "load8_u", [4_198]), 0);
+assert_return(() => call($11, "load8_u", [8_158]), 0);
 
 // memory_copy.wast:1116
-assert_return(() => call($11, "load8_u", [4_397]), 0);
+assert_return(() => call($11, "load8_u", [8_357]), 0);
 
 // memory_copy.wast:1117
-assert_return(() => call($11, "load8_u", [4_596]), 0);
+assert_return(() => call($11, "load8_u", [8_556]), 0);
 
 // memory_copy.wast:1118
-assert_return(() => call($11, "load8_u", [4_795]), 0);
+assert_return(() => call($11, "load8_u", [8_755]), 0);
 
 // memory_copy.wast:1119
-assert_return(() => call($11, "load8_u", [4_994]), 0);
+assert_return(() => call($11, "load8_u", [8_954]), 0);
 
 // memory_copy.wast:1120
-assert_return(() => call($11, "load8_u", [5_193]), 0);
+assert_return(() => call($11, "load8_u", [9_153]), 0);
 
 // memory_copy.wast:1121
-assert_return(() => call($11, "load8_u", [5_392]), 0);
+assert_return(() => call($11, "load8_u", [9_352]), 0);
 
 // memory_copy.wast:1122
-assert_return(() => call($11, "load8_u", [5_591]), 0);
+assert_return(() => call($11, "load8_u", [9_551]), 0);
 
 // memory_copy.wast:1123
-assert_return(() => call($11, "load8_u", [5_790]), 0);
+assert_return(() => call($11, "load8_u", [9_750]), 0);
 
 // memory_copy.wast:1124
-assert_return(() => call($11, "load8_u", [5_989]), 0);
+assert_return(() => call($11, "load8_u", [9_949]), 0);
 
 // memory_copy.wast:1125
-assert_return(() => call($11, "load8_u", [6_188]), 0);
+assert_return(() => call($11, "load8_u", [10_148]), 0);
 
 // memory_copy.wast:1126
-assert_return(() => call($11, "load8_u", [6_387]), 0);
+assert_return(() => call($11, "load8_u", [10_347]), 0);
 
 // memory_copy.wast:1127
-assert_return(() => call($11, "load8_u", [6_586]), 0);
+assert_return(() => call($11, "load8_u", [10_546]), 0);
 
 // memory_copy.wast:1128
-assert_return(() => call($11, "load8_u", [6_785]), 0);
+assert_return(() => call($11, "load8_u", [10_745]), 0);
 
 // memory_copy.wast:1129
-assert_return(() => call($11, "load8_u", [6_984]), 0);
+assert_return(() => call($11, "load8_u", [10_944]), 0);
 
 // memory_copy.wast:1130
-assert_return(() => call($11, "load8_u", [7_183]), 0);
+assert_return(() => call($11, "load8_u", [11_143]), 0);
 
 // memory_copy.wast:1131
-assert_return(() => call($11, "load8_u", [7_382]), 0);
+assert_return(() => call($11, "load8_u", [11_342]), 0);
 
 // memory_copy.wast:1132
-assert_return(() => call($11, "load8_u", [7_581]), 0);
+assert_return(() => call($11, "load8_u", [11_541]), 0);
 
 // memory_copy.wast:1133
-assert_return(() => call($11, "load8_u", [7_780]), 0);
+assert_return(() => call($11, "load8_u", [11_740]), 0);
 
 // memory_copy.wast:1134
-assert_return(() => call($11, "load8_u", [7_979]), 0);
+assert_return(() => call($11, "load8_u", [11_939]), 0);
 
 // memory_copy.wast:1135
-assert_return(() => call($11, "load8_u", [8_178]), 0);
+assert_return(() => call($11, "load8_u", [12_138]), 0);
 
 // memory_copy.wast:1136
-assert_return(() => call($11, "load8_u", [8_377]), 0);
+assert_return(() => call($11, "load8_u", [12_337]), 0);
 
 // memory_copy.wast:1137
-assert_return(() => call($11, "load8_u", [8_576]), 0);
+assert_return(() => call($11, "load8_u", [12_536]), 0);
 
 // memory_copy.wast:1138
-assert_return(() => call($11, "load8_u", [8_775]), 0);
+assert_return(() => call($11, "load8_u", [12_735]), 0);
 
 // memory_copy.wast:1139
-assert_return(() => call($11, "load8_u", [8_974]), 0);
+assert_return(() => call($11, "load8_u", [12_934]), 0);
 
 // memory_copy.wast:1140
-assert_return(() => call($11, "load8_u", [9_173]), 0);
+assert_return(() => call($11, "load8_u", [13_133]), 0);
 
 // memory_copy.wast:1141
-assert_return(() => call($11, "load8_u", [9_372]), 0);
+assert_return(() => call($11, "load8_u", [13_332]), 0);
 
 // memory_copy.wast:1142
-assert_return(() => call($11, "load8_u", [9_571]), 0);
+assert_return(() => call($11, "load8_u", [13_531]), 0);
 
 // memory_copy.wast:1143
-assert_return(() => call($11, "load8_u", [9_770]), 0);
+assert_return(() => call($11, "load8_u", [13_730]), 0);
 
 // memory_copy.wast:1144
-assert_return(() => call($11, "load8_u", [9_969]), 0);
+assert_return(() => call($11, "load8_u", [13_929]), 0);
 
 // memory_copy.wast:1145
-assert_return(() => call($11, "load8_u", [10_168]), 0);
+assert_return(() => call($11, "load8_u", [14_128]), 0);
 
 // memory_copy.wast:1146
-assert_return(() => call($11, "load8_u", [10_367]), 0);
+assert_return(() => call($11, "load8_u", [14_327]), 0);
 
 // memory_copy.wast:1147
-assert_return(() => call($11, "load8_u", [10_566]), 0);
+assert_return(() => call($11, "load8_u", [14_526]), 0);
 
 // memory_copy.wast:1148
-assert_return(() => call($11, "load8_u", [10_765]), 0);
+assert_return(() => call($11, "load8_u", [14_725]), 0);
 
 // memory_copy.wast:1149
-assert_return(() => call($11, "load8_u", [10_964]), 0);
+assert_return(() => call($11, "load8_u", [14_924]), 0);
 
 // memory_copy.wast:1150
-assert_return(() => call($11, "load8_u", [11_163]), 0);
+assert_return(() => call($11, "load8_u", [15_123]), 0);
 
 // memory_copy.wast:1151
-assert_return(() => call($11, "load8_u", [11_362]), 0);
+assert_return(() => call($11, "load8_u", [15_322]), 0);
 
 // memory_copy.wast:1152
-assert_return(() => call($11, "load8_u", [11_561]), 0);
+assert_return(() => call($11, "load8_u", [15_521]), 0);
 
 // memory_copy.wast:1153
-assert_return(() => call($11, "load8_u", [11_760]), 0);
+assert_return(() => call($11, "load8_u", [15_720]), 0);
 
 // memory_copy.wast:1154
-assert_return(() => call($11, "load8_u", [11_959]), 0);
+assert_return(() => call($11, "load8_u", [15_919]), 0);
 
 // memory_copy.wast:1155
-assert_return(() => call($11, "load8_u", [12_158]), 0);
+assert_return(() => call($11, "load8_u", [16_118]), 0);
 
 // memory_copy.wast:1156
-assert_return(() => call($11, "load8_u", [12_357]), 0);
+assert_return(() => call($11, "load8_u", [16_317]), 0);
 
 // memory_copy.wast:1157
-assert_return(() => call($11, "load8_u", [12_556]), 0);
+assert_return(() => call($11, "load8_u", [16_516]), 0);
 
 // memory_copy.wast:1158
-assert_return(() => call($11, "load8_u", [12_755]), 0);
+assert_return(() => call($11, "load8_u", [16_715]), 0);
 
 // memory_copy.wast:1159
-assert_return(() => call($11, "load8_u", [12_954]), 0);
+assert_return(() => call($11, "load8_u", [16_914]), 0);
 
 // memory_copy.wast:1160
-assert_return(() => call($11, "load8_u", [13_153]), 0);
+assert_return(() => call($11, "load8_u", [17_113]), 0);
 
 // memory_copy.wast:1161
-assert_return(() => call($11, "load8_u", [13_352]), 0);
+assert_return(() => call($11, "load8_u", [17_312]), 0);
 
 // memory_copy.wast:1162
-assert_return(() => call($11, "load8_u", [13_551]), 0);
+assert_return(() => call($11, "load8_u", [17_511]), 0);
 
 // memory_copy.wast:1163
-assert_return(() => call($11, "load8_u", [13_750]), 0);
+assert_return(() => call($11, "load8_u", [17_710]), 0);
 
 // memory_copy.wast:1164
-assert_return(() => call($11, "load8_u", [13_949]), 0);
+assert_return(() => call($11, "load8_u", [17_909]), 0);
 
 // memory_copy.wast:1165
-assert_return(() => call($11, "load8_u", [14_148]), 0);
+assert_return(() => call($11, "load8_u", [18_108]), 0);
 
 // memory_copy.wast:1166
-assert_return(() => call($11, "load8_u", [14_347]), 0);
+assert_return(() => call($11, "load8_u", [18_307]), 0);
 
 // memory_copy.wast:1167
-assert_return(() => call($11, "load8_u", [14_546]), 0);
+assert_return(() => call($11, "load8_u", [18_506]), 0);
 
 // memory_copy.wast:1168
-assert_return(() => call($11, "load8_u", [14_745]), 0);
+assert_return(() => call($11, "load8_u", [18_705]), 0);
 
 // memory_copy.wast:1169
-assert_return(() => call($11, "load8_u", [14_944]), 0);
+assert_return(() => call($11, "load8_u", [18_904]), 0);
 
 // memory_copy.wast:1170
-assert_return(() => call($11, "load8_u", [15_143]), 0);
+assert_return(() => call($11, "load8_u", [19_103]), 0);
 
 // memory_copy.wast:1171
-assert_return(() => call($11, "load8_u", [15_342]), 0);
+assert_return(() => call($11, "load8_u", [19_302]), 0);
 
 // memory_copy.wast:1172
-assert_return(() => call($11, "load8_u", [15_541]), 0);
+assert_return(() => call($11, "load8_u", [19_501]), 0);
 
 // memory_copy.wast:1173
-assert_return(() => call($11, "load8_u", [15_740]), 0);
+assert_return(() => call($11, "load8_u", [19_700]), 0);
 
 // memory_copy.wast:1174
-assert_return(() => call($11, "load8_u", [15_939]), 0);
+assert_return(() => call($11, "load8_u", [19_899]), 0);
 
 // memory_copy.wast:1175
-assert_return(() => call($11, "load8_u", [16_138]), 0);
+assert_return(() => call($11, "load8_u", [20_098]), 0);
 
 // memory_copy.wast:1176
-assert_return(() => call($11, "load8_u", [16_337]), 0);
+assert_return(() => call($11, "load8_u", [20_297]), 0);
 
 // memory_copy.wast:1177
-assert_return(() => call($11, "load8_u", [16_536]), 0);
+assert_return(() => call($11, "load8_u", [20_496]), 0);
 
 // memory_copy.wast:1178
-assert_return(() => call($11, "load8_u", [16_735]), 0);
+assert_return(() => call($11, "load8_u", [20_695]), 0);
 
 // memory_copy.wast:1179
-assert_return(() => call($11, "load8_u", [16_934]), 0);
+assert_return(() => call($11, "load8_u", [20_894]), 0);
 
 // memory_copy.wast:1180
-assert_return(() => call($11, "load8_u", [17_133]), 0);
+assert_return(() => call($11, "load8_u", [21_093]), 0);
 
 // memory_copy.wast:1181
-assert_return(() => call($11, "load8_u", [17_332]), 0);
+assert_return(() => call($11, "load8_u", [21_292]), 0);
 
 // memory_copy.wast:1182
-assert_return(() => call($11, "load8_u", [17_531]), 0);
+assert_return(() => call($11, "load8_u", [21_491]), 0);
 
 // memory_copy.wast:1183
-assert_return(() => call($11, "load8_u", [17_730]), 0);
+assert_return(() => call($11, "load8_u", [21_690]), 0);
 
 // memory_copy.wast:1184
-assert_return(() => call($11, "load8_u", [17_929]), 0);
+assert_return(() => call($11, "load8_u", [21_889]), 0);
 
 // memory_copy.wast:1185
-assert_return(() => call($11, "load8_u", [18_128]), 0);
+assert_return(() => call($11, "load8_u", [22_088]), 0);
 
 // memory_copy.wast:1186
-assert_return(() => call($11, "load8_u", [18_327]), 0);
+assert_return(() => call($11, "load8_u", [22_287]), 0);
 
 // memory_copy.wast:1187
-assert_return(() => call($11, "load8_u", [18_526]), 0);
+assert_return(() => call($11, "load8_u", [22_486]), 0);
 
 // memory_copy.wast:1188
-assert_return(() => call($11, "load8_u", [18_725]), 0);
+assert_return(() => call($11, "load8_u", [22_685]), 0);
 
 // memory_copy.wast:1189
-assert_return(() => call($11, "load8_u", [18_924]), 0);
+assert_return(() => call($11, "load8_u", [22_884]), 0);
 
 // memory_copy.wast:1190
-assert_return(() => call($11, "load8_u", [19_123]), 0);
+assert_return(() => call($11, "load8_u", [23_083]), 0);
 
 // memory_copy.wast:1191
-assert_return(() => call($11, "load8_u", [19_322]), 0);
+assert_return(() => call($11, "load8_u", [23_282]), 0);
 
 // memory_copy.wast:1192
-assert_return(() => call($11, "load8_u", [19_521]), 0);
+assert_return(() => call($11, "load8_u", [23_481]), 0);
 
 // memory_copy.wast:1193
-assert_return(() => call($11, "load8_u", [19_720]), 0);
+assert_return(() => call($11, "load8_u", [23_680]), 0);
 
 // memory_copy.wast:1194
-assert_return(() => call($11, "load8_u", [19_919]), 0);
+assert_return(() => call($11, "load8_u", [23_879]), 0);
 
 // memory_copy.wast:1195
-assert_return(() => call($11, "load8_u", [20_118]), 0);
+assert_return(() => call($11, "load8_u", [24_078]), 0);
 
 // memory_copy.wast:1196
-assert_return(() => call($11, "load8_u", [20_317]), 0);
+assert_return(() => call($11, "load8_u", [24_277]), 0);
 
 // memory_copy.wast:1197
-assert_return(() => call($11, "load8_u", [20_516]), 0);
+assert_return(() => call($11, "load8_u", [24_476]), 0);
 
 // memory_copy.wast:1198
-assert_return(() => call($11, "load8_u", [20_715]), 0);
+assert_return(() => call($11, "load8_u", [24_675]), 0);
 
 // memory_copy.wast:1199
-assert_return(() => call($11, "load8_u", [20_914]), 0);
+assert_return(() => call($11, "load8_u", [24_874]), 0);
 
 // memory_copy.wast:1200
-assert_return(() => call($11, "load8_u", [21_113]), 0);
+assert_return(() => call($11, "load8_u", [25_073]), 0);
 
 // memory_copy.wast:1201
-assert_return(() => call($11, "load8_u", [21_312]), 0);
+assert_return(() => call($11, "load8_u", [25_272]), 0);
 
 // memory_copy.wast:1202
-assert_return(() => call($11, "load8_u", [21_511]), 0);
+assert_return(() => call($11, "load8_u", [25_471]), 0);
 
 // memory_copy.wast:1203
-assert_return(() => call($11, "load8_u", [21_710]), 0);
+assert_return(() => call($11, "load8_u", [25_670]), 0);
 
 // memory_copy.wast:1204
-assert_return(() => call($11, "load8_u", [21_909]), 0);
+assert_return(() => call($11, "load8_u", [25_869]), 0);
 
 // memory_copy.wast:1205
-assert_return(() => call($11, "load8_u", [22_108]), 0);
+assert_return(() => call($11, "load8_u", [26_068]), 0);
 
 // memory_copy.wast:1206
-assert_return(() => call($11, "load8_u", [22_307]), 0);
+assert_return(() => call($11, "load8_u", [26_267]), 0);
 
 // memory_copy.wast:1207
-assert_return(() => call($11, "load8_u", [22_506]), 0);
+assert_return(() => call($11, "load8_u", [26_466]), 0);
 
 // memory_copy.wast:1208
-assert_return(() => call($11, "load8_u", [22_705]), 0);
+assert_return(() => call($11, "load8_u", [26_665]), 0);
 
 // memory_copy.wast:1209
-assert_return(() => call($11, "load8_u", [22_904]), 0);
+assert_return(() => call($11, "load8_u", [26_864]), 0);
 
 // memory_copy.wast:1210
-assert_return(() => call($11, "load8_u", [23_103]), 0);
+assert_return(() => call($11, "load8_u", [27_063]), 0);
 
 // memory_copy.wast:1211
-assert_return(() => call($11, "load8_u", [23_302]), 0);
+assert_return(() => call($11, "load8_u", [27_262]), 0);
 
 // memory_copy.wast:1212
-assert_return(() => call($11, "load8_u", [23_501]), 0);
+assert_return(() => call($11, "load8_u", [27_461]), 0);
 
 // memory_copy.wast:1213
-assert_return(() => call($11, "load8_u", [23_700]), 0);
+assert_return(() => call($11, "load8_u", [27_660]), 0);
 
 // memory_copy.wast:1214
-assert_return(() => call($11, "load8_u", [23_899]), 0);
+assert_return(() => call($11, "load8_u", [27_859]), 0);
 
 // memory_copy.wast:1215
-assert_return(() => call($11, "load8_u", [24_098]), 0);
+assert_return(() => call($11, "load8_u", [28_058]), 0);
 
 // memory_copy.wast:1216
-assert_return(() => call($11, "load8_u", [24_297]), 0);
+assert_return(() => call($11, "load8_u", [28_257]), 0);
 
 // memory_copy.wast:1217
-assert_return(() => call($11, "load8_u", [24_496]), 0);
+assert_return(() => call($11, "load8_u", [28_456]), 0);
 
 // memory_copy.wast:1218
-assert_return(() => call($11, "load8_u", [24_695]), 0);
+assert_return(() => call($11, "load8_u", [28_655]), 0);
 
 // memory_copy.wast:1219
-assert_return(() => call($11, "load8_u", [24_894]), 0);
+assert_return(() => call($11, "load8_u", [28_854]), 0);
 
 // memory_copy.wast:1220
-assert_return(() => call($11, "load8_u", [25_093]), 0);
+assert_return(() => call($11, "load8_u", [29_053]), 0);
 
 // memory_copy.wast:1221
-assert_return(() => call($11, "load8_u", [25_292]), 0);
+assert_return(() => call($11, "load8_u", [29_252]), 0);
 
 // memory_copy.wast:1222
-assert_return(() => call($11, "load8_u", [25_491]), 0);
+assert_return(() => call($11, "load8_u", [29_451]), 0);
 
 // memory_copy.wast:1223
-assert_return(() => call($11, "load8_u", [25_690]), 0);
+assert_return(() => call($11, "load8_u", [29_650]), 0);
 
 // memory_copy.wast:1224
-assert_return(() => call($11, "load8_u", [25_889]), 0);
+assert_return(() => call($11, "load8_u", [29_849]), 0);
 
 // memory_copy.wast:1225
-assert_return(() => call($11, "load8_u", [26_088]), 0);
+assert_return(() => call($11, "load8_u", [30_048]), 0);
 
 // memory_copy.wast:1226
-assert_return(() => call($11, "load8_u", [26_287]), 0);
+assert_return(() => call($11, "load8_u", [30_247]), 0);
 
 // memory_copy.wast:1227
-assert_return(() => call($11, "load8_u", [26_486]), 0);
+assert_return(() => call($11, "load8_u", [30_446]), 0);
 
 // memory_copy.wast:1228
-assert_return(() => call($11, "load8_u", [26_685]), 0);
+assert_return(() => call($11, "load8_u", [30_645]), 0);
 
 // memory_copy.wast:1229
-assert_return(() => call($11, "load8_u", [26_884]), 0);
+assert_return(() => call($11, "load8_u", [30_844]), 0);
 
 // memory_copy.wast:1230
-assert_return(() => call($11, "load8_u", [27_083]), 0);
+assert_return(() => call($11, "load8_u", [31_043]), 0);
 
 // memory_copy.wast:1231
-assert_return(() => call($11, "load8_u", [27_282]), 0);
+assert_return(() => call($11, "load8_u", [31_242]), 0);
 
 // memory_copy.wast:1232
-assert_return(() => call($11, "load8_u", [27_481]), 0);
+assert_return(() => call($11, "load8_u", [31_441]), 0);
 
 // memory_copy.wast:1233
-assert_return(() => call($11, "load8_u", [27_680]), 0);
+assert_return(() => call($11, "load8_u", [31_640]), 0);
 
 // memory_copy.wast:1234
-assert_return(() => call($11, "load8_u", [27_879]), 0);
+assert_return(() => call($11, "load8_u", [31_839]), 0);
 
 // memory_copy.wast:1235
-assert_return(() => call($11, "load8_u", [28_078]), 0);
+assert_return(() => call($11, "load8_u", [32_038]), 0);
 
 // memory_copy.wast:1236
-assert_return(() => call($11, "load8_u", [28_277]), 0);
+assert_return(() => call($11, "load8_u", [32_237]), 0);
 
 // memory_copy.wast:1237
-assert_return(() => call($11, "load8_u", [28_476]), 0);
+assert_return(() => call($11, "load8_u", [32_436]), 0);
 
 // memory_copy.wast:1238
-assert_return(() => call($11, "load8_u", [28_675]), 0);
+assert_return(() => call($11, "load8_u", [32_635]), 0);
 
 // memory_copy.wast:1239
-assert_return(() => call($11, "load8_u", [28_874]), 0);
+assert_return(() => call($11, "load8_u", [32_834]), 0);
 
 // memory_copy.wast:1240
-assert_return(() => call($11, "load8_u", [29_073]), 0);
+assert_return(() => call($11, "load8_u", [33_033]), 0);
 
 // memory_copy.wast:1241
-assert_return(() => call($11, "load8_u", [29_272]), 0);
+assert_return(() => call($11, "load8_u", [33_232]), 0);
 
 // memory_copy.wast:1242
-assert_return(() => call($11, "load8_u", [29_471]), 0);
+assert_return(() => call($11, "load8_u", [33_431]), 0);
 
 // memory_copy.wast:1243
-assert_return(() => call($11, "load8_u", [29_670]), 0);
+assert_return(() => call($11, "load8_u", [33_630]), 0);
 
 // memory_copy.wast:1244
-assert_return(() => call($11, "load8_u", [29_869]), 0);
+assert_return(() => call($11, "load8_u", [33_829]), 0);
 
 // memory_copy.wast:1245
-assert_return(() => call($11, "load8_u", [30_068]), 0);
+assert_return(() => call($11, "load8_u", [34_028]), 0);
 
 // memory_copy.wast:1246
-assert_return(() => call($11, "load8_u", [30_267]), 0);
+assert_return(() => call($11, "load8_u", [34_227]), 0);
 
 // memory_copy.wast:1247
-assert_return(() => call($11, "load8_u", [30_466]), 0);
+assert_return(() => call($11, "load8_u", [34_426]), 0);
 
 // memory_copy.wast:1248
-assert_return(() => call($11, "load8_u", [30_665]), 0);
+assert_return(() => call($11, "load8_u", [34_625]), 0);
 
 // memory_copy.wast:1249
-assert_return(() => call($11, "load8_u", [30_864]), 0);
+assert_return(() => call($11, "load8_u", [34_824]), 0);
 
 // memory_copy.wast:1250
-assert_return(() => call($11, "load8_u", [31_063]), 0);
+assert_return(() => call($11, "load8_u", [35_023]), 0);
 
 // memory_copy.wast:1251
-assert_return(() => call($11, "load8_u", [31_262]), 0);
+assert_return(() => call($11, "load8_u", [35_222]), 0);
 
 // memory_copy.wast:1252
-assert_return(() => call($11, "load8_u", [31_461]), 0);
+assert_return(() => call($11, "load8_u", [35_421]), 0);
 
 // memory_copy.wast:1253
-assert_return(() => call($11, "load8_u", [31_660]), 0);
+assert_return(() => call($11, "load8_u", [35_620]), 0);
 
 // memory_copy.wast:1254
-assert_return(() => call($11, "load8_u", [31_859]), 0);
+assert_return(() => call($11, "load8_u", [35_819]), 0);
 
 // memory_copy.wast:1255
-assert_return(() => call($11, "load8_u", [32_058]), 0);
+assert_return(() => call($11, "load8_u", [36_018]), 0);
 
 // memory_copy.wast:1256
-assert_return(() => call($11, "load8_u", [32_257]), 0);
+assert_return(() => call($11, "load8_u", [36_217]), 0);
 
 // memory_copy.wast:1257
-assert_return(() => call($11, "load8_u", [32_456]), 0);
+assert_return(() => call($11, "load8_u", [36_416]), 0);
 
 // memory_copy.wast:1258
-assert_return(() => call($11, "load8_u", [32_655]), 0);
+assert_return(() => call($11, "load8_u", [36_615]), 0);
 
 // memory_copy.wast:1259
-assert_return(() => call($11, "load8_u", [32_854]), 0);
+assert_return(() => call($11, "load8_u", [36_814]), 0);
 
 // memory_copy.wast:1260
-assert_return(() => call($11, "load8_u", [33_053]), 0);
+assert_return(() => call($11, "load8_u", [37_013]), 0);
 
 // memory_copy.wast:1261
-assert_return(() => call($11, "load8_u", [33_252]), 0);
+assert_return(() => call($11, "load8_u", [37_212]), 0);
 
 // memory_copy.wast:1262
-assert_return(() => call($11, "load8_u", [33_451]), 0);
+assert_return(() => call($11, "load8_u", [37_411]), 0);
 
 // memory_copy.wast:1263
-assert_return(() => call($11, "load8_u", [33_650]), 0);
+assert_return(() => call($11, "load8_u", [37_610]), 0);
 
 // memory_copy.wast:1264
-assert_return(() => call($11, "load8_u", [33_849]), 0);
+assert_return(() => call($11, "load8_u", [37_809]), 0);
 
 // memory_copy.wast:1265
-assert_return(() => call($11, "load8_u", [34_048]), 0);
+assert_return(() => call($11, "load8_u", [38_008]), 0);
 
 // memory_copy.wast:1266
-assert_return(() => call($11, "load8_u", [34_247]), 0);
+assert_return(() => call($11, "load8_u", [38_207]), 0);
 
 // memory_copy.wast:1267
-assert_return(() => call($11, "load8_u", [34_446]), 0);
+assert_return(() => call($11, "load8_u", [38_406]), 0);
 
 // memory_copy.wast:1268
-assert_return(() => call($11, "load8_u", [34_645]), 0);
+assert_return(() => call($11, "load8_u", [38_605]), 0);
 
 // memory_copy.wast:1269
-assert_return(() => call($11, "load8_u", [34_844]), 0);
+assert_return(() => call($11, "load8_u", [38_804]), 0);
 
 // memory_copy.wast:1270
-assert_return(() => call($11, "load8_u", [35_043]), 0);
+assert_return(() => call($11, "load8_u", [39_003]), 0);
 
 // memory_copy.wast:1271
-assert_return(() => call($11, "load8_u", [35_242]), 0);
+assert_return(() => call($11, "load8_u", [39_202]), 0);
 
 // memory_copy.wast:1272
-assert_return(() => call($11, "load8_u", [35_441]), 0);
+assert_return(() => call($11, "load8_u", [39_401]), 0);
 
 // memory_copy.wast:1273
-assert_return(() => call($11, "load8_u", [35_640]), 0);
+assert_return(() => call($11, "load8_u", [39_600]), 0);
 
 // memory_copy.wast:1274
-assert_return(() => call($11, "load8_u", [35_839]), 0);
+assert_return(() => call($11, "load8_u", [39_799]), 0);
 
 // memory_copy.wast:1275
-assert_return(() => call($11, "load8_u", [36_038]), 0);
+assert_return(() => call($11, "load8_u", [39_998]), 0);
 
 // memory_copy.wast:1276
-assert_return(() => call($11, "load8_u", [36_237]), 0);
+assert_return(() => call($11, "load8_u", [40_197]), 0);
 
 // memory_copy.wast:1277
-assert_return(() => call($11, "load8_u", [36_436]), 0);
+assert_return(() => call($11, "load8_u", [40_396]), 0);
 
 // memory_copy.wast:1278
-assert_return(() => call($11, "load8_u", [36_635]), 0);
+assert_return(() => call($11, "load8_u", [40_595]), 0);
 
 // memory_copy.wast:1279
-assert_return(() => call($11, "load8_u", [36_834]), 0);
+assert_return(() => call($11, "load8_u", [40_794]), 0);
 
 // memory_copy.wast:1280
-assert_return(() => call($11, "load8_u", [37_033]), 0);
+assert_return(() => call($11, "load8_u", [40_993]), 0);
 
 // memory_copy.wast:1281
-assert_return(() => call($11, "load8_u", [37_232]), 0);
+assert_return(() => call($11, "load8_u", [41_192]), 0);
 
 // memory_copy.wast:1282
-assert_return(() => call($11, "load8_u", [37_431]), 0);
+assert_return(() => call($11, "load8_u", [41_391]), 0);
 
 // memory_copy.wast:1283
-assert_return(() => call($11, "load8_u", [37_630]), 0);
+assert_return(() => call($11, "load8_u", [41_590]), 0);
 
 // memory_copy.wast:1284
-assert_return(() => call($11, "load8_u", [37_829]), 0);
+assert_return(() => call($11, "load8_u", [41_789]), 0);
 
 // memory_copy.wast:1285
-assert_return(() => call($11, "load8_u", [38_028]), 0);
+assert_return(() => call($11, "load8_u", [41_988]), 0);
 
 // memory_copy.wast:1286
-assert_return(() => call($11, "load8_u", [38_227]), 0);
+assert_return(() => call($11, "load8_u", [42_187]), 0);
 
 // memory_copy.wast:1287
-assert_return(() => call($11, "load8_u", [38_426]), 0);
+assert_return(() => call($11, "load8_u", [42_386]), 0);
 
 // memory_copy.wast:1288
-assert_return(() => call($11, "load8_u", [38_625]), 0);
+assert_return(() => call($11, "load8_u", [42_585]), 0);
 
 // memory_copy.wast:1289
-assert_return(() => call($11, "load8_u", [38_824]), 0);
+assert_return(() => call($11, "load8_u", [42_784]), 0);
 
 // memory_copy.wast:1290
-assert_return(() => call($11, "load8_u", [39_023]), 0);
+assert_return(() => call($11, "load8_u", [42_983]), 0);
 
 // memory_copy.wast:1291
-assert_return(() => call($11, "load8_u", [39_222]), 0);
+assert_return(() => call($11, "load8_u", [43_182]), 0);
 
 // memory_copy.wast:1292
-assert_return(() => call($11, "load8_u", [39_421]), 0);
+assert_return(() => call($11, "load8_u", [43_381]), 0);
 
 // memory_copy.wast:1293
-assert_return(() => call($11, "load8_u", [39_620]), 0);
+assert_return(() => call($11, "load8_u", [43_580]), 0);
 
 // memory_copy.wast:1294
-assert_return(() => call($11, "load8_u", [39_819]), 0);
+assert_return(() => call($11, "load8_u", [43_779]), 0);
 
 // memory_copy.wast:1295
-assert_return(() => call($11, "load8_u", [40_018]), 0);
+assert_return(() => call($11, "load8_u", [43_978]), 0);
 
 // memory_copy.wast:1296
-assert_return(() => call($11, "load8_u", [40_217]), 0);
+assert_return(() => call($11, "load8_u", [44_177]), 0);
 
 // memory_copy.wast:1297
-assert_return(() => call($11, "load8_u", [40_416]), 0);
+assert_return(() => call($11, "load8_u", [44_376]), 0);
 
 // memory_copy.wast:1298
-assert_return(() => call($11, "load8_u", [40_615]), 0);
+assert_return(() => call($11, "load8_u", [44_575]), 0);
 
 // memory_copy.wast:1299
-assert_return(() => call($11, "load8_u", [40_814]), 0);
+assert_return(() => call($11, "load8_u", [44_774]), 0);
 
 // memory_copy.wast:1300
-assert_return(() => call($11, "load8_u", [41_013]), 0);
+assert_return(() => call($11, "load8_u", [44_973]), 0);
 
 // memory_copy.wast:1301
-assert_return(() => call($11, "load8_u", [41_212]), 0);
+assert_return(() => call($11, "load8_u", [45_172]), 0);
 
 // memory_copy.wast:1302
-assert_return(() => call($11, "load8_u", [41_411]), 0);
+assert_return(() => call($11, "load8_u", [45_371]), 0);
 
 // memory_copy.wast:1303
-assert_return(() => call($11, "load8_u", [41_610]), 0);
+assert_return(() => call($11, "load8_u", [45_570]), 0);
 
 // memory_copy.wast:1304
-assert_return(() => call($11, "load8_u", [41_809]), 0);
+assert_return(() => call($11, "load8_u", [45_769]), 0);
 
 // memory_copy.wast:1305
-assert_return(() => call($11, "load8_u", [42_008]), 0);
+assert_return(() => call($11, "load8_u", [45_968]), 0);
 
 // memory_copy.wast:1306
-assert_return(() => call($11, "load8_u", [42_207]), 0);
+assert_return(() => call($11, "load8_u", [46_167]), 0);
 
 // memory_copy.wast:1307
-assert_return(() => call($11, "load8_u", [42_406]), 0);
+assert_return(() => call($11, "load8_u", [46_366]), 0);
 
 // memory_copy.wast:1308
-assert_return(() => call($11, "load8_u", [42_605]), 0);
+assert_return(() => call($11, "load8_u", [46_565]), 0);
 
 // memory_copy.wast:1309
-assert_return(() => call($11, "load8_u", [42_804]), 0);
+assert_return(() => call($11, "load8_u", [46_764]), 0);
 
 // memory_copy.wast:1310
-assert_return(() => call($11, "load8_u", [43_003]), 0);
+assert_return(() => call($11, "load8_u", [46_963]), 0);
 
 // memory_copy.wast:1311
-assert_return(() => call($11, "load8_u", [43_202]), 0);
+assert_return(() => call($11, "load8_u", [47_162]), 0);
 
 // memory_copy.wast:1312
-assert_return(() => call($11, "load8_u", [43_401]), 0);
+assert_return(() => call($11, "load8_u", [47_361]), 0);
 
 // memory_copy.wast:1313
-assert_return(() => call($11, "load8_u", [43_600]), 0);
+assert_return(() => call($11, "load8_u", [47_560]), 0);
 
 // memory_copy.wast:1314
-assert_return(() => call($11, "load8_u", [43_799]), 0);
+assert_return(() => call($11, "load8_u", [47_759]), 0);
 
 // memory_copy.wast:1315
-assert_return(() => call($11, "load8_u", [43_998]), 0);
+assert_return(() => call($11, "load8_u", [47_958]), 0);
 
 // memory_copy.wast:1316
-assert_return(() => call($11, "load8_u", [44_197]), 0);
+assert_return(() => call($11, "load8_u", [48_157]), 0);
 
 // memory_copy.wast:1317
-assert_return(() => call($11, "load8_u", [44_396]), 0);
+assert_return(() => call($11, "load8_u", [48_356]), 0);
 
 // memory_copy.wast:1318
-assert_return(() => call($11, "load8_u", [44_595]), 0);
+assert_return(() => call($11, "load8_u", [48_555]), 0);
 
 // memory_copy.wast:1319
-assert_return(() => call($11, "load8_u", [44_794]), 0);
+assert_return(() => call($11, "load8_u", [48_754]), 0);
 
 // memory_copy.wast:1320
-assert_return(() => call($11, "load8_u", [44_993]), 0);
+assert_return(() => call($11, "load8_u", [48_953]), 0);
 
 // memory_copy.wast:1321
-assert_return(() => call($11, "load8_u", [45_192]), 0);
+assert_return(() => call($11, "load8_u", [49_152]), 0);
 
 // memory_copy.wast:1322
-assert_return(() => call($11, "load8_u", [45_391]), 0);
+assert_return(() => call($11, "load8_u", [49_351]), 0);
 
 // memory_copy.wast:1323
-assert_return(() => call($11, "load8_u", [45_590]), 0);
+assert_return(() => call($11, "load8_u", [49_550]), 0);
 
 // memory_copy.wast:1324
-assert_return(() => call($11, "load8_u", [45_789]), 0);
+assert_return(() => call($11, "load8_u", [49_749]), 0);
 
 // memory_copy.wast:1325
-assert_return(() => call($11, "load8_u", [45_988]), 0);
+assert_return(() => call($11, "load8_u", [49_948]), 0);
 
 // memory_copy.wast:1326
-assert_return(() => call($11, "load8_u", [46_187]), 0);
+assert_return(() => call($11, "load8_u", [50_147]), 0);
 
 // memory_copy.wast:1327
-assert_return(() => call($11, "load8_u", [46_386]), 0);
+assert_return(() => call($11, "load8_u", [50_346]), 0);
 
 // memory_copy.wast:1328
-assert_return(() => call($11, "load8_u", [46_585]), 0);
+assert_return(() => call($11, "load8_u", [50_545]), 0);
 
 // memory_copy.wast:1329
-assert_return(() => call($11, "load8_u", [46_784]), 0);
+assert_return(() => call($11, "load8_u", [50_744]), 0);
 
 // memory_copy.wast:1330
-assert_return(() => call($11, "load8_u", [46_983]), 0);
+assert_return(() => call($11, "load8_u", [50_943]), 0);
 
 // memory_copy.wast:1331
-assert_return(() => call($11, "load8_u", [47_182]), 0);
+assert_return(() => call($11, "load8_u", [51_142]), 0);
 
 // memory_copy.wast:1332
-assert_return(() => call($11, "load8_u", [47_381]), 0);
+assert_return(() => call($11, "load8_u", [51_341]), 0);
 
 // memory_copy.wast:1333
-assert_return(() => call($11, "load8_u", [47_580]), 0);
+assert_return(() => call($11, "load8_u", [51_540]), 0);
 
 // memory_copy.wast:1334
-assert_return(() => call($11, "load8_u", [47_779]), 0);
+assert_return(() => call($11, "load8_u", [51_739]), 0);
 
 // memory_copy.wast:1335
-assert_return(() => call($11, "load8_u", [47_978]), 0);
+assert_return(() => call($11, "load8_u", [51_938]), 0);
 
 // memory_copy.wast:1336
-assert_return(() => call($11, "load8_u", [48_177]), 0);
+assert_return(() => call($11, "load8_u", [52_137]), 0);
 
 // memory_copy.wast:1337
-assert_return(() => call($11, "load8_u", [48_376]), 0);
+assert_return(() => call($11, "load8_u", [52_336]), 0);
 
 // memory_copy.wast:1338
-assert_return(() => call($11, "load8_u", [48_575]), 0);
+assert_return(() => call($11, "load8_u", [52_535]), 0);
 
 // memory_copy.wast:1339
-assert_return(() => call($11, "load8_u", [48_774]), 0);
+assert_return(() => call($11, "load8_u", [52_734]), 0);
 
 // memory_copy.wast:1340
-assert_return(() => call($11, "load8_u", [48_973]), 0);
+assert_return(() => call($11, "load8_u", [52_933]), 0);
 
 // memory_copy.wast:1341
-assert_return(() => call($11, "load8_u", [49_172]), 0);
+assert_return(() => call($11, "load8_u", [53_132]), 0);
 
 // memory_copy.wast:1342
-assert_return(() => call($11, "load8_u", [49_371]), 0);
+assert_return(() => call($11, "load8_u", [53_331]), 0);
 
 // memory_copy.wast:1343
-assert_return(() => call($11, "load8_u", [49_570]), 0);
+assert_return(() => call($11, "load8_u", [53_530]), 0);
 
 // memory_copy.wast:1344
-assert_return(() => call($11, "load8_u", [49_769]), 0);
+assert_return(() => call($11, "load8_u", [53_729]), 0);
 
 // memory_copy.wast:1345
-assert_return(() => call($11, "load8_u", [49_968]), 0);
+assert_return(() => call($11, "load8_u", [53_928]), 0);
 
 // memory_copy.wast:1346
-assert_return(() => call($11, "load8_u", [50_167]), 0);
+assert_return(() => call($11, "load8_u", [54_127]), 0);
 
 // memory_copy.wast:1347
-assert_return(() => call($11, "load8_u", [50_366]), 0);
+assert_return(() => call($11, "load8_u", [54_326]), 0);
 
 // memory_copy.wast:1348
-assert_return(() => call($11, "load8_u", [50_565]), 0);
+assert_return(() => call($11, "load8_u", [54_525]), 0);
 
 // memory_copy.wast:1349
-assert_return(() => call($11, "load8_u", [50_764]), 0);
+assert_return(() => call($11, "load8_u", [54_724]), 0);
 
 // memory_copy.wast:1350
-assert_return(() => call($11, "load8_u", [50_963]), 0);
+assert_return(() => call($11, "load8_u", [54_923]), 0);
 
 // memory_copy.wast:1351
-assert_return(() => call($11, "load8_u", [51_162]), 0);
+assert_return(() => call($11, "load8_u", [55_122]), 0);
 
 // memory_copy.wast:1352
-assert_return(() => call($11, "load8_u", [51_361]), 0);
+assert_return(() => call($11, "load8_u", [55_321]), 0);
 
 // memory_copy.wast:1353
-assert_return(() => call($11, "load8_u", [51_560]), 0);
+assert_return(() => call($11, "load8_u", [55_520]), 0);
 
 // memory_copy.wast:1354
-assert_return(() => call($11, "load8_u", [51_759]), 0);
+assert_return(() => call($11, "load8_u", [55_719]), 0);
 
 // memory_copy.wast:1355
-assert_return(() => call($11, "load8_u", [51_958]), 0);
+assert_return(() => call($11, "load8_u", [55_918]), 0);
 
 // memory_copy.wast:1356
-assert_return(() => call($11, "load8_u", [52_157]), 0);
+assert_return(() => call($11, "load8_u", [56_117]), 0);
 
 // memory_copy.wast:1357
-assert_return(() => call($11, "load8_u", [52_356]), 0);
+assert_return(() => call($11, "load8_u", [56_316]), 0);
 
 // memory_copy.wast:1358
-assert_return(() => call($11, "load8_u", [52_555]), 0);
+assert_return(() => call($11, "load8_u", [56_515]), 0);
 
 // memory_copy.wast:1359
-assert_return(() => call($11, "load8_u", [52_754]), 0);
+assert_return(() => call($11, "load8_u", [56_714]), 0);
 
 // memory_copy.wast:1360
-assert_return(() => call($11, "load8_u", [52_953]), 0);
+assert_return(() => call($11, "load8_u", [56_913]), 0);
 
 // memory_copy.wast:1361
-assert_return(() => call($11, "load8_u", [53_152]), 0);
+assert_return(() => call($11, "load8_u", [57_112]), 0);
 
 // memory_copy.wast:1362
-assert_return(() => call($11, "load8_u", [53_351]), 0);
+assert_return(() => call($11, "load8_u", [57_311]), 0);
 
 // memory_copy.wast:1363
-assert_return(() => call($11, "load8_u", [53_550]), 0);
+assert_return(() => call($11, "load8_u", [57_510]), 0);
 
 // memory_copy.wast:1364
-assert_return(() => call($11, "load8_u", [53_749]), 0);
+assert_return(() => call($11, "load8_u", [57_709]), 0);
 
 // memory_copy.wast:1365
-assert_return(() => call($11, "load8_u", [53_948]), 0);
+assert_return(() => call($11, "load8_u", [57_908]), 0);
 
 // memory_copy.wast:1366
-assert_return(() => call($11, "load8_u", [54_147]), 0);
+assert_return(() => call($11, "load8_u", [58_107]), 0);
 
 // memory_copy.wast:1367
-assert_return(() => call($11, "load8_u", [54_346]), 0);
+assert_return(() => call($11, "load8_u", [58_306]), 0);
 
 // memory_copy.wast:1368
-assert_return(() => call($11, "load8_u", [54_545]), 0);
+assert_return(() => call($11, "load8_u", [58_505]), 0);
 
 // memory_copy.wast:1369
-assert_return(() => call($11, "load8_u", [54_744]), 0);
+assert_return(() => call($11, "load8_u", [58_704]), 0);
 
 // memory_copy.wast:1370
-assert_return(() => call($11, "load8_u", [54_943]), 0);
+assert_return(() => call($11, "load8_u", [58_903]), 0);
 
 // memory_copy.wast:1371
-assert_return(() => call($11, "load8_u", [55_142]), 0);
+assert_return(() => call($11, "load8_u", [59_102]), 0);
 
 // memory_copy.wast:1372
-assert_return(() => call($11, "load8_u", [55_341]), 0);
+assert_return(() => call($11, "load8_u", [59_301]), 0);
 
 // memory_copy.wast:1373
-assert_return(() => call($11, "load8_u", [55_540]), 0);
+assert_return(() => call($11, "load8_u", [59_500]), 0);
 
 // memory_copy.wast:1374
-assert_return(() => call($11, "load8_u", [55_739]), 0);
+assert_return(() => call($11, "load8_u", [59_699]), 0);
 
 // memory_copy.wast:1375
-assert_return(() => call($11, "load8_u", [55_938]), 0);
+assert_return(() => call($11, "load8_u", [59_898]), 0);
 
 // memory_copy.wast:1376
-assert_return(() => call($11, "load8_u", [56_137]), 0);
+assert_return(() => call($11, "load8_u", [60_097]), 0);
 
 // memory_copy.wast:1377
-assert_return(() => call($11, "load8_u", [56_336]), 0);
+assert_return(() => call($11, "load8_u", [60_296]), 0);
 
 // memory_copy.wast:1378
-assert_return(() => call($11, "load8_u", [56_535]), 0);
+assert_return(() => call($11, "load8_u", [60_495]), 0);
 
 // memory_copy.wast:1379
-assert_return(() => call($11, "load8_u", [56_734]), 0);
+assert_return(() => call($11, "load8_u", [60_694]), 0);
 
 // memory_copy.wast:1380
-assert_return(() => call($11, "load8_u", [56_933]), 0);
+assert_return(() => call($11, "load8_u", [60_893]), 0);
 
 // memory_copy.wast:1381
-assert_return(() => call($11, "load8_u", [57_132]), 0);
+assert_return(() => call($11, "load8_u", [61_092]), 0);
 
 // memory_copy.wast:1382
-assert_return(() => call($11, "load8_u", [57_331]), 0);
+assert_return(() => call($11, "load8_u", [61_291]), 0);
 
 // memory_copy.wast:1383
-assert_return(() => call($11, "load8_u", [57_530]), 0);
+assert_return(() => call($11, "load8_u", [61_490]), 0);
 
 // memory_copy.wast:1384
-assert_return(() => call($11, "load8_u", [57_729]), 0);
+assert_return(() => call($11, "load8_u", [61_689]), 0);
 
 // memory_copy.wast:1385
-assert_return(() => call($11, "load8_u", [57_928]), 0);
+assert_return(() => call($11, "load8_u", [61_888]), 0);
 
 // memory_copy.wast:1386
-assert_return(() => call($11, "load8_u", [58_127]), 0);
+assert_return(() => call($11, "load8_u", [62_087]), 0);
 
 // memory_copy.wast:1387
-assert_return(() => call($11, "load8_u", [58_326]), 0);
+assert_return(() => call($11, "load8_u", [62_286]), 0);
 
 // memory_copy.wast:1388
-assert_return(() => call($11, "load8_u", [58_525]), 0);
+assert_return(() => call($11, "load8_u", [62_485]), 0);
 
 // memory_copy.wast:1389
-assert_return(() => call($11, "load8_u", [58_724]), 0);
+assert_return(() => call($11, "load8_u", [62_684]), 0);
 
 // memory_copy.wast:1390
-assert_return(() => call($11, "load8_u", [58_923]), 0);
+assert_return(() => call($11, "load8_u", [62_883]), 0);
 
 // memory_copy.wast:1391
-assert_return(() => call($11, "load8_u", [59_122]), 0);
+assert_return(() => call($11, "load8_u", [63_082]), 0);
 
 // memory_copy.wast:1392
-assert_return(() => call($11, "load8_u", [59_321]), 0);
+assert_return(() => call($11, "load8_u", [63_281]), 0);
 
 // memory_copy.wast:1393
-assert_return(() => call($11, "load8_u", [59_520]), 0);
+assert_return(() => call($11, "load8_u", [63_480]), 0);
 
 // memory_copy.wast:1394
-assert_return(() => call($11, "load8_u", [59_719]), 0);
+assert_return(() => call($11, "load8_u", [63_679]), 0);
 
 // memory_copy.wast:1395
-assert_return(() => call($11, "load8_u", [59_918]), 0);
+assert_return(() => call($11, "load8_u", [63_878]), 0);
 
 // memory_copy.wast:1396
-assert_return(() => call($11, "load8_u", [60_117]), 0);
+assert_return(() => call($11, "load8_u", [64_077]), 0);
 
 // memory_copy.wast:1397
-assert_return(() => call($11, "load8_u", [60_316]), 0);
+assert_return(() => call($11, "load8_u", [64_276]), 0);
 
 // memory_copy.wast:1398
-assert_return(() => call($11, "load8_u", [60_515]), 0);
+assert_return(() => call($11, "load8_u", [64_475]), 0);
 
 // memory_copy.wast:1399
-assert_return(() => call($11, "load8_u", [60_714]), 0);
+assert_return(() => call($11, "load8_u", [64_674]), 0);
 
 // memory_copy.wast:1400
-assert_return(() => call($11, "load8_u", [60_913]), 0);
+assert_return(() => call($11, "load8_u", [64_873]), 0);
 
 // memory_copy.wast:1401
-assert_return(() => call($11, "load8_u", [61_112]), 0);
+assert_return(() => call($11, "load8_u", [65_072]), 0);
 
 // memory_copy.wast:1402
-assert_return(() => call($11, "load8_u", [61_311]), 0);
+assert_return(() => call($11, "load8_u", [65_271]), 0);
 
 // memory_copy.wast:1403
-assert_return(() => call($11, "load8_u", [61_510]), 0);
+assert_return(() => call($11, "load8_u", [65_470]), 0);
 
 // memory_copy.wast:1404
-assert_return(() => call($11, "load8_u", [61_709]), 0);
+assert_return(() => call($11, "load8_u", [65_516]), 0);
 
 // memory_copy.wast:1405
-assert_return(() => call($11, "load8_u", [61_908]), 0);
+assert_return(() => call($11, "load8_u", [65_517]), 1);
 
 // memory_copy.wast:1406
-assert_return(() => call($11, "load8_u", [62_107]), 0);
+assert_return(() => call($11, "load8_u", [65_518]), 2);
 
 // memory_copy.wast:1407
-assert_return(() => call($11, "load8_u", [62_306]), 0);
+assert_return(() => call($11, "load8_u", [65_519]), 3);
 
 // memory_copy.wast:1408
-assert_return(() => call($11, "load8_u", [62_505]), 0);
+assert_return(() => call($11, "load8_u", [65_520]), 4);
 
 // memory_copy.wast:1409
-assert_return(() => call($11, "load8_u", [62_704]), 0);
+assert_return(() => call($11, "load8_u", [65_521]), 5);
 
 // memory_copy.wast:1410
-assert_return(() => call($11, "load8_u", [62_903]), 0);
+assert_return(() => call($11, "load8_u", [65_522]), 6);
 
 // memory_copy.wast:1411
-assert_return(() => call($11, "load8_u", [63_102]), 0);
+assert_return(() => call($11, "load8_u", [65_523]), 7);
 
 // memory_copy.wast:1412
-assert_return(() => call($11, "load8_u", [63_301]), 0);
+assert_return(() => call($11, "load8_u", [65_524]), 8);
 
 // memory_copy.wast:1413
-assert_return(() => call($11, "load8_u", [63_500]), 0);
+assert_return(() => call($11, "load8_u", [65_525]), 9);
 
 // memory_copy.wast:1414
-assert_return(() => call($11, "load8_u", [63_699]), 0);
+assert_return(() => call($11, "load8_u", [65_526]), 10);
 
 // memory_copy.wast:1415
-assert_return(() => call($11, "load8_u", [63_898]), 0);
+assert_return(() => call($11, "load8_u", [65_527]), 11);
 
 // memory_copy.wast:1416
-assert_return(() => call($11, "load8_u", [64_097]), 0);
+assert_return(() => call($11, "load8_u", [65_528]), 12);
 
 // memory_copy.wast:1417
-assert_return(() => call($11, "load8_u", [64_296]), 0);
+assert_return(() => call($11, "load8_u", [65_529]), 13);
 
 // memory_copy.wast:1418
-assert_return(() => call($11, "load8_u", [64_495]), 0);
+assert_return(() => call($11, "load8_u", [65_530]), 14);
 
 // memory_copy.wast:1419
-assert_return(() => call($11, "load8_u", [64_694]), 0);
+assert_return(() => call($11, "load8_u", [65_531]), 15);
 
 // memory_copy.wast:1420
-assert_return(() => call($11, "load8_u", [64_893]), 0);
+assert_return(() => call($11, "load8_u", [65_532]), 16);
 
 // memory_copy.wast:1421
-assert_return(() => call($11, "load8_u", [65_092]), 0);
+assert_return(() => call($11, "load8_u", [65_533]), 17);
 
 // memory_copy.wast:1422
-assert_return(() => call($11, "load8_u", [65_291]), 0);
+assert_return(() => call($11, "load8_u", [65_534]), 18);
 
 // memory_copy.wast:1423
-assert_return(() => call($11, "load8_u", [65_490]), 0);
-
-// memory_copy.wast:1424
-assert_return(() => call($11, "load8_u", [65_516]), 0);
+assert_return(() => call($11, "load8_u", [65_535]), 19);
 
 // memory_copy.wast:1425
-assert_return(() => call($11, "load8_u", [65_517]), 1);
-
-// memory_copy.wast:1426
-assert_return(() => call($11, "load8_u", [65_518]), 2);
-
-// memory_copy.wast:1427
-assert_return(() => call($11, "load8_u", [65_519]), 3);
-
-// memory_copy.wast:1428
-assert_return(() => call($11, "load8_u", [65_520]), 4);
-
-// memory_copy.wast:1429
-assert_return(() => call($11, "load8_u", [65_521]), 5);
-
-// memory_copy.wast:1430
-assert_return(() => call($11, "load8_u", [65_522]), 6);
-
-// memory_copy.wast:1431
-assert_return(() => call($11, "load8_u", [65_523]), 7);
-
-// memory_copy.wast:1432
-assert_return(() => call($11, "load8_u", [65_524]), 8);
+let $12 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8c\x80\x80\x80\x00\x02\x60\x03\x7f\x7f\x7f\x00\x60\x01\x7f\x01\x7f\x03\x83\x80\x80\x80\x00\x02\x00\x01\x05\x84\x80\x80\x80\x00\x01\x01\x01\x01\x07\x97\x80\x80\x80\x00\x03\x03\x6d\x65\x6d\x02\x00\x03\x72\x75\x6e\x00\x00\x07\x6c\x6f\x61\x64\x38\x5f\x75\x00\x01\x0a\x9e\x80\x80\x80\x00\x02\x8c\x80\x80\x80\x00\x00\x20\x00\x20\x01\x20\x02\xfc\x0a\x00\x00\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x2d\x00\x00\x0b\x0b\x9d\x80\x80\x80\x00\x01\x00\x41\xeb\xff\x03\x0b\x15\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10\x11\x12\x13\x14");
 
 // memory_copy.wast:1433
-assert_return(() => call($11, "load8_u", [65_525]), 9);
-
-// memory_copy.wast:1434
-assert_return(() => call($11, "load8_u", [65_526]), 10);
-
-// memory_copy.wast:1435
-assert_return(() => call($11, "load8_u", [65_527]), 11);
+assert_trap(() => call($12, "run", [0, 65_515, 39]));
 
 // memory_copy.wast:1436
-assert_return(() => call($11, "load8_u", [65_528]), 12);
+assert_return(() => call($12, "load8_u", [198]), 0);
 
 // memory_copy.wast:1437
-assert_return(() => call($11, "load8_u", [65_529]), 13);
+assert_return(() => call($12, "load8_u", [397]), 0);
 
 // memory_copy.wast:1438
-assert_return(() => call($11, "load8_u", [65_530]), 14);
+assert_return(() => call($12, "load8_u", [596]), 0);
 
 // memory_copy.wast:1439
-assert_return(() => call($11, "load8_u", [65_531]), 15);
+assert_return(() => call($12, "load8_u", [795]), 0);
 
 // memory_copy.wast:1440
-assert_return(() => call($11, "load8_u", [65_532]), 16);
+assert_return(() => call($12, "load8_u", [994]), 0);
 
 // memory_copy.wast:1441
-assert_return(() => call($11, "load8_u", [65_533]), 17);
+assert_return(() => call($12, "load8_u", [1_193]), 0);
 
 // memory_copy.wast:1442
-assert_return(() => call($11, "load8_u", [65_534]), 18);
+assert_return(() => call($12, "load8_u", [1_392]), 0);
 
 // memory_copy.wast:1443
-assert_return(() => call($11, "load8_u", [65_535]), 19);
+assert_return(() => call($12, "load8_u", [1_591]), 0);
+
+// memory_copy.wast:1444
+assert_return(() => call($12, "load8_u", [1_790]), 0);
 
 // memory_copy.wast:1445
-let $12 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8c\x80\x80\x80\x00\x02\x60\x03\x7f\x7f\x7f\x00\x60\x01\x7f\x01\x7f\x03\x83\x80\x80\x80\x00\x02\x00\x01\x05\x84\x80\x80\x80\x00\x01\x01\x01\x01\x07\x97\x80\x80\x80\x00\x03\x03\x6d\x65\x6d\x02\x00\x03\x72\x75\x6e\x00\x00\x07\x6c\x6f\x61\x64\x38\x5f\x75\x00\x01\x0a\x9e\x80\x80\x80\x00\x02\x8c\x80\x80\x80\x00\x00\x20\x00\x20\x01\x20\x02\xfc\x0a\x00\x00\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x2d\x00\x00\x0b\x0b\x9d\x80\x80\x80\x00\x01\x00\x41\xeb\xff\x03\x0b\x15\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10\x11\x12\x13\x14");
+assert_return(() => call($12, "load8_u", [1_989]), 0);
+
+// memory_copy.wast:1446
+assert_return(() => call($12, "load8_u", [2_188]), 0);
+
+// memory_copy.wast:1447
+assert_return(() => call($12, "load8_u", [2_387]), 0);
+
+// memory_copy.wast:1448
+assert_return(() => call($12, "load8_u", [2_586]), 0);
+
+// memory_copy.wast:1449
+assert_return(() => call($12, "load8_u", [2_785]), 0);
+
+// memory_copy.wast:1450
+assert_return(() => call($12, "load8_u", [2_984]), 0);
+
+// memory_copy.wast:1451
+assert_return(() => call($12, "load8_u", [3_183]), 0);
+
+// memory_copy.wast:1452
+assert_return(() => call($12, "load8_u", [3_382]), 0);
 
 // memory_copy.wast:1453
-assert_trap(() => call($12, "run", [0, 65_515, 39]));
+assert_return(() => call($12, "load8_u", [3_581]), 0);
+
+// memory_copy.wast:1454
+assert_return(() => call($12, "load8_u", [3_780]), 0);
+
+// memory_copy.wast:1455
+assert_return(() => call($12, "load8_u", [3_979]), 0);
 
 // memory_copy.wast:1456
-assert_return(() => call($12, "load8_u", [0]), 0);
+assert_return(() => call($12, "load8_u", [4_178]), 0);
 
 // memory_copy.wast:1457
-assert_return(() => call($12, "load8_u", [1]), 1);
+assert_return(() => call($12, "load8_u", [4_377]), 0);
 
 // memory_copy.wast:1458
-assert_return(() => call($12, "load8_u", [2]), 2);
+assert_return(() => call($12, "load8_u", [4_576]), 0);
 
 // memory_copy.wast:1459
-assert_return(() => call($12, "load8_u", [3]), 3);
+assert_return(() => call($12, "load8_u", [4_775]), 0);
 
 // memory_copy.wast:1460
-assert_return(() => call($12, "load8_u", [4]), 4);
+assert_return(() => call($12, "load8_u", [4_974]), 0);
 
 // memory_copy.wast:1461
-assert_return(() => call($12, "load8_u", [5]), 5);
+assert_return(() => call($12, "load8_u", [5_173]), 0);
 
 // memory_copy.wast:1462
-assert_return(() => call($12, "load8_u", [6]), 6);
+assert_return(() => call($12, "load8_u", [5_372]), 0);
 
 // memory_copy.wast:1463
-assert_return(() => call($12, "load8_u", [7]), 7);
+assert_return(() => call($12, "load8_u", [5_571]), 0);
 
 // memory_copy.wast:1464
-assert_return(() => call($12, "load8_u", [8]), 8);
+assert_return(() => call($12, "load8_u", [5_770]), 0);
 
 // memory_copy.wast:1465
-assert_return(() => call($12, "load8_u", [9]), 9);
+assert_return(() => call($12, "load8_u", [5_969]), 0);
 
 // memory_copy.wast:1466
-assert_return(() => call($12, "load8_u", [10]), 10);
+assert_return(() => call($12, "load8_u", [6_168]), 0);
 
 // memory_copy.wast:1467
-assert_return(() => call($12, "load8_u", [11]), 11);
+assert_return(() => call($12, "load8_u", [6_367]), 0);
 
 // memory_copy.wast:1468
-assert_return(() => call($12, "load8_u", [12]), 12);
+assert_return(() => call($12, "load8_u", [6_566]), 0);
 
 // memory_copy.wast:1469
-assert_return(() => call($12, "load8_u", [13]), 13);
+assert_return(() => call($12, "load8_u", [6_765]), 0);
 
 // memory_copy.wast:1470
-assert_return(() => call($12, "load8_u", [14]), 14);
+assert_return(() => call($12, "load8_u", [6_964]), 0);
 
 // memory_copy.wast:1471
-assert_return(() => call($12, "load8_u", [15]), 15);
+assert_return(() => call($12, "load8_u", [7_163]), 0);
 
 // memory_copy.wast:1472
-assert_return(() => call($12, "load8_u", [16]), 16);
+assert_return(() => call($12, "load8_u", [7_362]), 0);
 
 // memory_copy.wast:1473
-assert_return(() => call($12, "load8_u", [17]), 17);
+assert_return(() => call($12, "load8_u", [7_561]), 0);
 
 // memory_copy.wast:1474
-assert_return(() => call($12, "load8_u", [18]), 18);
+assert_return(() => call($12, "load8_u", [7_760]), 0);
 
 // memory_copy.wast:1475
-assert_return(() => call($12, "load8_u", [19]), 19);
+assert_return(() => call($12, "load8_u", [7_959]), 0);
 
 // memory_copy.wast:1476
-assert_return(() => call($12, "load8_u", [20]), 20);
+assert_return(() => call($12, "load8_u", [8_158]), 0);
 
 // memory_copy.wast:1477
-assert_return(() => call($12, "load8_u", [219]), 0);
+assert_return(() => call($12, "load8_u", [8_357]), 0);
 
 // memory_copy.wast:1478
-assert_return(() => call($12, "load8_u", [418]), 0);
+assert_return(() => call($12, "load8_u", [8_556]), 0);
 
 // memory_copy.wast:1479
-assert_return(() => call($12, "load8_u", [617]), 0);
+assert_return(() => call($12, "load8_u", [8_755]), 0);
 
 // memory_copy.wast:1480
-assert_return(() => call($12, "load8_u", [816]), 0);
+assert_return(() => call($12, "load8_u", [8_954]), 0);
 
 // memory_copy.wast:1481
-assert_return(() => call($12, "load8_u", [1_015]), 0);
+assert_return(() => call($12, "load8_u", [9_153]), 0);
 
 // memory_copy.wast:1482
-assert_return(() => call($12, "load8_u", [1_214]), 0);
+assert_return(() => call($12, "load8_u", [9_352]), 0);
 
 // memory_copy.wast:1483
-assert_return(() => call($12, "load8_u", [1_413]), 0);
+assert_return(() => call($12, "load8_u", [9_551]), 0);
 
 // memory_copy.wast:1484
-assert_return(() => call($12, "load8_u", [1_612]), 0);
+assert_return(() => call($12, "load8_u", [9_750]), 0);
 
 // memory_copy.wast:1485
-assert_return(() => call($12, "load8_u", [1_811]), 0);
+assert_return(() => call($12, "load8_u", [9_949]), 0);
 
 // memory_copy.wast:1486
-assert_return(() => call($12, "load8_u", [2_010]), 0);
+assert_return(() => call($12, "load8_u", [10_148]), 0);
 
 // memory_copy.wast:1487
-assert_return(() => call($12, "load8_u", [2_209]), 0);
+assert_return(() => call($12, "load8_u", [10_347]), 0);
 
 // memory_copy.wast:1488
-assert_return(() => call($12, "load8_u", [2_408]), 0);
+assert_return(() => call($12, "load8_u", [10_546]), 0);
 
 // memory_copy.wast:1489
-assert_return(() => call($12, "load8_u", [2_607]), 0);
+assert_return(() => call($12, "load8_u", [10_745]), 0);
 
 // memory_copy.wast:1490
-assert_return(() => call($12, "load8_u", [2_806]), 0);
+assert_return(() => call($12, "load8_u", [10_944]), 0);
 
 // memory_copy.wast:1491
-assert_return(() => call($12, "load8_u", [3_005]), 0);
+assert_return(() => call($12, "load8_u", [11_143]), 0);
 
 // memory_copy.wast:1492
-assert_return(() => call($12, "load8_u", [3_204]), 0);
+assert_return(() => call($12, "load8_u", [11_342]), 0);
 
 // memory_copy.wast:1493
-assert_return(() => call($12, "load8_u", [3_403]), 0);
+assert_return(() => call($12, "load8_u", [11_541]), 0);
 
 // memory_copy.wast:1494
-assert_return(() => call($12, "load8_u", [3_602]), 0);
+assert_return(() => call($12, "load8_u", [11_740]), 0);
 
 // memory_copy.wast:1495
-assert_return(() => call($12, "load8_u", [3_801]), 0);
+assert_return(() => call($12, "load8_u", [11_939]), 0);
 
 // memory_copy.wast:1496
-assert_return(() => call($12, "load8_u", [4_000]), 0);
+assert_return(() => call($12, "load8_u", [12_138]), 0);
 
 // memory_copy.wast:1497
-assert_return(() => call($12, "load8_u", [4_199]), 0);
+assert_return(() => call($12, "load8_u", [12_337]), 0);
 
 // memory_copy.wast:1498
-assert_return(() => call($12, "load8_u", [4_398]), 0);
+assert_return(() => call($12, "load8_u", [12_536]), 0);
 
 // memory_copy.wast:1499
-assert_return(() => call($12, "load8_u", [4_597]), 0);
+assert_return(() => call($12, "load8_u", [12_735]), 0);
 
 // memory_copy.wast:1500
-assert_return(() => call($12, "load8_u", [4_796]), 0);
+assert_return(() => call($12, "load8_u", [12_934]), 0);
 
 // memory_copy.wast:1501
-assert_return(() => call($12, "load8_u", [4_995]), 0);
+assert_return(() => call($12, "load8_u", [13_133]), 0);
 
 // memory_copy.wast:1502
-assert_return(() => call($12, "load8_u", [5_194]), 0);
+assert_return(() => call($12, "load8_u", [13_332]), 0);
 
 // memory_copy.wast:1503
-assert_return(() => call($12, "load8_u", [5_393]), 0);
+assert_return(() => call($12, "load8_u", [13_531]), 0);
 
 // memory_copy.wast:1504
-assert_return(() => call($12, "load8_u", [5_592]), 0);
+assert_return(() => call($12, "load8_u", [13_730]), 0);
 
 // memory_copy.wast:1505
-assert_return(() => call($12, "load8_u", [5_791]), 0);
+assert_return(() => call($12, "load8_u", [13_929]), 0);
 
 // memory_copy.wast:1506
-assert_return(() => call($12, "load8_u", [5_990]), 0);
+assert_return(() => call($12, "load8_u", [14_128]), 0);
 
 // memory_copy.wast:1507
-assert_return(() => call($12, "load8_u", [6_189]), 0);
+assert_return(() => call($12, "load8_u", [14_327]), 0);
 
 // memory_copy.wast:1508
-assert_return(() => call($12, "load8_u", [6_388]), 0);
+assert_return(() => call($12, "load8_u", [14_526]), 0);
 
 // memory_copy.wast:1509
-assert_return(() => call($12, "load8_u", [6_587]), 0);
+assert_return(() => call($12, "load8_u", [14_725]), 0);
 
 // memory_copy.wast:1510
-assert_return(() => call($12, "load8_u", [6_786]), 0);
+assert_return(() => call($12, "load8_u", [14_924]), 0);
 
 // memory_copy.wast:1511
-assert_return(() => call($12, "load8_u", [6_985]), 0);
+assert_return(() => call($12, "load8_u", [15_123]), 0);
 
 // memory_copy.wast:1512
-assert_return(() => call($12, "load8_u", [7_184]), 0);
+assert_return(() => call($12, "load8_u", [15_322]), 0);
 
 // memory_copy.wast:1513
-assert_return(() => call($12, "load8_u", [7_383]), 0);
+assert_return(() => call($12, "load8_u", [15_521]), 0);
 
 // memory_copy.wast:1514
-assert_return(() => call($12, "load8_u", [7_582]), 0);
+assert_return(() => call($12, "load8_u", [15_720]), 0);
 
 // memory_copy.wast:1515
-assert_return(() => call($12, "load8_u", [7_781]), 0);
+assert_return(() => call($12, "load8_u", [15_919]), 0);
 
 // memory_copy.wast:1516
-assert_return(() => call($12, "load8_u", [7_980]), 0);
+assert_return(() => call($12, "load8_u", [16_118]), 0);
 
 // memory_copy.wast:1517
-assert_return(() => call($12, "load8_u", [8_179]), 0);
+assert_return(() => call($12, "load8_u", [16_317]), 0);
 
 // memory_copy.wast:1518
-assert_return(() => call($12, "load8_u", [8_378]), 0);
+assert_return(() => call($12, "load8_u", [16_516]), 0);
 
 // memory_copy.wast:1519
-assert_return(() => call($12, "load8_u", [8_577]), 0);
+assert_return(() => call($12, "load8_u", [16_715]), 0);
 
 // memory_copy.wast:1520
-assert_return(() => call($12, "load8_u", [8_776]), 0);
+assert_return(() => call($12, "load8_u", [16_914]), 0);
 
 // memory_copy.wast:1521
-assert_return(() => call($12, "load8_u", [8_975]), 0);
+assert_return(() => call($12, "load8_u", [17_113]), 0);
 
 // memory_copy.wast:1522
-assert_return(() => call($12, "load8_u", [9_174]), 0);
+assert_return(() => call($12, "load8_u", [17_312]), 0);
 
 // memory_copy.wast:1523
-assert_return(() => call($12, "load8_u", [9_373]), 0);
+assert_return(() => call($12, "load8_u", [17_511]), 0);
 
 // memory_copy.wast:1524
-assert_return(() => call($12, "load8_u", [9_572]), 0);
+assert_return(() => call($12, "load8_u", [17_710]), 0);
 
 // memory_copy.wast:1525
-assert_return(() => call($12, "load8_u", [9_771]), 0);
+assert_return(() => call($12, "load8_u", [17_909]), 0);
 
 // memory_copy.wast:1526
-assert_return(() => call($12, "load8_u", [9_970]), 0);
+assert_return(() => call($12, "load8_u", [18_108]), 0);
 
 // memory_copy.wast:1527
-assert_return(() => call($12, "load8_u", [10_169]), 0);
+assert_return(() => call($12, "load8_u", [18_307]), 0);
 
 // memory_copy.wast:1528
-assert_return(() => call($12, "load8_u", [10_368]), 0);
+assert_return(() => call($12, "load8_u", [18_506]), 0);
 
 // memory_copy.wast:1529
-assert_return(() => call($12, "load8_u", [10_567]), 0);
+assert_return(() => call($12, "load8_u", [18_705]), 0);
 
 // memory_copy.wast:1530
-assert_return(() => call($12, "load8_u", [10_766]), 0);
+assert_return(() => call($12, "load8_u", [18_904]), 0);
 
 // memory_copy.wast:1531
-assert_return(() => call($12, "load8_u", [10_965]), 0);
+assert_return(() => call($12, "load8_u", [19_103]), 0);
 
 // memory_copy.wast:1532
-assert_return(() => call($12, "load8_u", [11_164]), 0);
+assert_return(() => call($12, "load8_u", [19_302]), 0);
 
 // memory_copy.wast:1533
-assert_return(() => call($12, "load8_u", [11_363]), 0);
+assert_return(() => call($12, "load8_u", [19_501]), 0);
 
 // memory_copy.wast:1534
-assert_return(() => call($12, "load8_u", [11_562]), 0);
+assert_return(() => call($12, "load8_u", [19_700]), 0);
 
 // memory_copy.wast:1535
-assert_return(() => call($12, "load8_u", [11_761]), 0);
+assert_return(() => call($12, "load8_u", [19_899]), 0);
 
 // memory_copy.wast:1536
-assert_return(() => call($12, "load8_u", [11_960]), 0);
+assert_return(() => call($12, "load8_u", [20_098]), 0);
 
 // memory_copy.wast:1537
-assert_return(() => call($12, "load8_u", [12_159]), 0);
+assert_return(() => call($12, "load8_u", [20_297]), 0);
 
 // memory_copy.wast:1538
-assert_return(() => call($12, "load8_u", [12_358]), 0);
+assert_return(() => call($12, "load8_u", [20_496]), 0);
 
 // memory_copy.wast:1539
-assert_return(() => call($12, "load8_u", [12_557]), 0);
+assert_return(() => call($12, "load8_u", [20_695]), 0);
 
 // memory_copy.wast:1540
-assert_return(() => call($12, "load8_u", [12_756]), 0);
+assert_return(() => call($12, "load8_u", [20_894]), 0);
 
 // memory_copy.wast:1541
-assert_return(() => call($12, "load8_u", [12_955]), 0);
+assert_return(() => call($12, "load8_u", [21_093]), 0);
 
 // memory_copy.wast:1542
-assert_return(() => call($12, "load8_u", [13_154]), 0);
+assert_return(() => call($12, "load8_u", [21_292]), 0);
 
 // memory_copy.wast:1543
-assert_return(() => call($12, "load8_u", [13_353]), 0);
+assert_return(() => call($12, "load8_u", [21_491]), 0);
 
 // memory_copy.wast:1544
-assert_return(() => call($12, "load8_u", [13_552]), 0);
+assert_return(() => call($12, "load8_u", [21_690]), 0);
 
 // memory_copy.wast:1545
-assert_return(() => call($12, "load8_u", [13_751]), 0);
+assert_return(() => call($12, "load8_u", [21_889]), 0);
 
 // memory_copy.wast:1546
-assert_return(() => call($12, "load8_u", [13_950]), 0);
+assert_return(() => call($12, "load8_u", [22_088]), 0);
 
 // memory_copy.wast:1547
-assert_return(() => call($12, "load8_u", [14_149]), 0);
+assert_return(() => call($12, "load8_u", [22_287]), 0);
 
 // memory_copy.wast:1548
-assert_return(() => call($12, "load8_u", [14_348]), 0);
+assert_return(() => call($12, "load8_u", [22_486]), 0);
 
 // memory_copy.wast:1549
-assert_return(() => call($12, "load8_u", [14_547]), 0);
+assert_return(() => call($12, "load8_u", [22_685]), 0);
 
 // memory_copy.wast:1550
-assert_return(() => call($12, "load8_u", [14_746]), 0);
+assert_return(() => call($12, "load8_u", [22_884]), 0);
 
 // memory_copy.wast:1551
-assert_return(() => call($12, "load8_u", [14_945]), 0);
+assert_return(() => call($12, "load8_u", [23_083]), 0);
 
 // memory_copy.wast:1552
-assert_return(() => call($12, "load8_u", [15_144]), 0);
+assert_return(() => call($12, "load8_u", [23_282]), 0);
 
 // memory_copy.wast:1553
-assert_return(() => call($12, "load8_u", [15_343]), 0);
+assert_return(() => call($12, "load8_u", [23_481]), 0);
 
 // memory_copy.wast:1554
-assert_return(() => call($12, "load8_u", [15_542]), 0);
+assert_return(() => call($12, "load8_u", [23_680]), 0);
 
 // memory_copy.wast:1555
-assert_return(() => call($12, "load8_u", [15_741]), 0);
+assert_return(() => call($12, "load8_u", [23_879]), 0);
 
 // memory_copy.wast:1556
-assert_return(() => call($12, "load8_u", [15_940]), 0);
+assert_return(() => call($12, "load8_u", [24_078]), 0);
 
 // memory_copy.wast:1557
-assert_return(() => call($12, "load8_u", [16_139]), 0);
+assert_return(() => call($12, "load8_u", [24_277]), 0);
 
 // memory_copy.wast:1558
-assert_return(() => call($12, "load8_u", [16_338]), 0);
+assert_return(() => call($12, "load8_u", [24_476]), 0);
 
 // memory_copy.wast:1559
-assert_return(() => call($12, "load8_u", [16_537]), 0);
+assert_return(() => call($12, "load8_u", [24_675]), 0);
 
 // memory_copy.wast:1560
-assert_return(() => call($12, "load8_u", [16_736]), 0);
+assert_return(() => call($12, "load8_u", [24_874]), 0);
 
 // memory_copy.wast:1561
-assert_return(() => call($12, "load8_u", [16_935]), 0);
+assert_return(() => call($12, "load8_u", [25_073]), 0);
 
 // memory_copy.wast:1562
-assert_return(() => call($12, "load8_u", [17_134]), 0);
+assert_return(() => call($12, "load8_u", [25_272]), 0);
 
 // memory_copy.wast:1563
-assert_return(() => call($12, "load8_u", [17_333]), 0);
+assert_return(() => call($12, "load8_u", [25_471]), 0);
 
 // memory_copy.wast:1564
-assert_return(() => call($12, "load8_u", [17_532]), 0);
+assert_return(() => call($12, "load8_u", [25_670]), 0);
 
 // memory_copy.wast:1565
-assert_return(() => call($12, "load8_u", [17_731]), 0);
+assert_return(() => call($12, "load8_u", [25_869]), 0);
 
 // memory_copy.wast:1566
-assert_return(() => call($12, "load8_u", [17_930]), 0);
+assert_return(() => call($12, "load8_u", [26_068]), 0);
 
 // memory_copy.wast:1567
-assert_return(() => call($12, "load8_u", [18_129]), 0);
+assert_return(() => call($12, "load8_u", [26_267]), 0);
 
 // memory_copy.wast:1568
-assert_return(() => call($12, "load8_u", [18_328]), 0);
+assert_return(() => call($12, "load8_u", [26_466]), 0);
 
 // memory_copy.wast:1569
-assert_return(() => call($12, "load8_u", [18_527]), 0);
+assert_return(() => call($12, "load8_u", [26_665]), 0);
 
 // memory_copy.wast:1570
-assert_return(() => call($12, "load8_u", [18_726]), 0);
+assert_return(() => call($12, "load8_u", [26_864]), 0);
 
 // memory_copy.wast:1571
-assert_return(() => call($12, "load8_u", [18_925]), 0);
+assert_return(() => call($12, "load8_u", [27_063]), 0);
 
 // memory_copy.wast:1572
-assert_return(() => call($12, "load8_u", [19_124]), 0);
+assert_return(() => call($12, "load8_u", [27_262]), 0);
 
 // memory_copy.wast:1573
-assert_return(() => call($12, "load8_u", [19_323]), 0);
+assert_return(() => call($12, "load8_u", [27_461]), 0);
 
 // memory_copy.wast:1574
-assert_return(() => call($12, "load8_u", [19_522]), 0);
+assert_return(() => call($12, "load8_u", [27_660]), 0);
 
 // memory_copy.wast:1575
-assert_return(() => call($12, "load8_u", [19_721]), 0);
+assert_return(() => call($12, "load8_u", [27_859]), 0);
 
 // memory_copy.wast:1576
-assert_return(() => call($12, "load8_u", [19_920]), 0);
+assert_return(() => call($12, "load8_u", [28_058]), 0);
 
 // memory_copy.wast:1577
-assert_return(() => call($12, "load8_u", [20_119]), 0);
+assert_return(() => call($12, "load8_u", [28_257]), 0);
 
 // memory_copy.wast:1578
-assert_return(() => call($12, "load8_u", [20_318]), 0);
+assert_return(() => call($12, "load8_u", [28_456]), 0);
 
 // memory_copy.wast:1579
-assert_return(() => call($12, "load8_u", [20_517]), 0);
+assert_return(() => call($12, "load8_u", [28_655]), 0);
 
 // memory_copy.wast:1580
-assert_return(() => call($12, "load8_u", [20_716]), 0);
+assert_return(() => call($12, "load8_u", [28_854]), 0);
 
 // memory_copy.wast:1581
-assert_return(() => call($12, "load8_u", [20_915]), 0);
+assert_return(() => call($12, "load8_u", [29_053]), 0);
 
 // memory_copy.wast:1582
-assert_return(() => call($12, "load8_u", [21_114]), 0);
+assert_return(() => call($12, "load8_u", [29_252]), 0);
 
 // memory_copy.wast:1583
-assert_return(() => call($12, "load8_u", [21_313]), 0);
+assert_return(() => call($12, "load8_u", [29_451]), 0);
 
 // memory_copy.wast:1584
-assert_return(() => call($12, "load8_u", [21_512]), 0);
+assert_return(() => call($12, "load8_u", [29_650]), 0);
 
 // memory_copy.wast:1585
-assert_return(() => call($12, "load8_u", [21_711]), 0);
+assert_return(() => call($12, "load8_u", [29_849]), 0);
 
 // memory_copy.wast:1586
-assert_return(() => call($12, "load8_u", [21_910]), 0);
+assert_return(() => call($12, "load8_u", [30_048]), 0);
 
 // memory_copy.wast:1587
-assert_return(() => call($12, "load8_u", [22_109]), 0);
+assert_return(() => call($12, "load8_u", [30_247]), 0);
 
 // memory_copy.wast:1588
-assert_return(() => call($12, "load8_u", [22_308]), 0);
+assert_return(() => call($12, "load8_u", [30_446]), 0);
 
 // memory_copy.wast:1589
-assert_return(() => call($12, "load8_u", [22_507]), 0);
+assert_return(() => call($12, "load8_u", [30_645]), 0);
 
 // memory_copy.wast:1590
-assert_return(() => call($12, "load8_u", [22_706]), 0);
+assert_return(() => call($12, "load8_u", [30_844]), 0);
 
 // memory_copy.wast:1591
-assert_return(() => call($12, "load8_u", [22_905]), 0);
+assert_return(() => call($12, "load8_u", [31_043]), 0);
 
 // memory_copy.wast:1592
-assert_return(() => call($12, "load8_u", [23_104]), 0);
+assert_return(() => call($12, "load8_u", [31_242]), 0);
 
 // memory_copy.wast:1593
-assert_return(() => call($12, "load8_u", [23_303]), 0);
+assert_return(() => call($12, "load8_u", [31_441]), 0);
 
 // memory_copy.wast:1594
-assert_return(() => call($12, "load8_u", [23_502]), 0);
+assert_return(() => call($12, "load8_u", [31_640]), 0);
 
 // memory_copy.wast:1595
-assert_return(() => call($12, "load8_u", [23_701]), 0);
+assert_return(() => call($12, "load8_u", [31_839]), 0);
 
 // memory_copy.wast:1596
-assert_return(() => call($12, "load8_u", [23_900]), 0);
+assert_return(() => call($12, "load8_u", [32_038]), 0);
 
 // memory_copy.wast:1597
-assert_return(() => call($12, "load8_u", [24_099]), 0);
+assert_return(() => call($12, "load8_u", [32_237]), 0);
 
 // memory_copy.wast:1598
-assert_return(() => call($12, "load8_u", [24_298]), 0);
+assert_return(() => call($12, "load8_u", [32_436]), 0);
 
 // memory_copy.wast:1599
-assert_return(() => call($12, "load8_u", [24_497]), 0);
+assert_return(() => call($12, "load8_u", [32_635]), 0);
 
 // memory_copy.wast:1600
-assert_return(() => call($12, "load8_u", [24_696]), 0);
+assert_return(() => call($12, "load8_u", [32_834]), 0);
 
 // memory_copy.wast:1601
-assert_return(() => call($12, "load8_u", [24_895]), 0);
+assert_return(() => call($12, "load8_u", [33_033]), 0);
 
 // memory_copy.wast:1602
-assert_return(() => call($12, "load8_u", [25_094]), 0);
+assert_return(() => call($12, "load8_u", [33_232]), 0);
 
 // memory_copy.wast:1603
-assert_return(() => call($12, "load8_u", [25_293]), 0);
+assert_return(() => call($12, "load8_u", [33_431]), 0);
 
 // memory_copy.wast:1604
-assert_return(() => call($12, "load8_u", [25_492]), 0);
+assert_return(() => call($12, "load8_u", [33_630]), 0);
 
 // memory_copy.wast:1605
-assert_return(() => call($12, "load8_u", [25_691]), 0);
+assert_return(() => call($12, "load8_u", [33_829]), 0);
 
 // memory_copy.wast:1606
-assert_return(() => call($12, "load8_u", [25_890]), 0);
+assert_return(() => call($12, "load8_u", [34_028]), 0);
 
 // memory_copy.wast:1607
-assert_return(() => call($12, "load8_u", [26_089]), 0);
+assert_return(() => call($12, "load8_u", [34_227]), 0);
 
 // memory_copy.wast:1608
-assert_return(() => call($12, "load8_u", [26_288]), 0);
+assert_return(() => call($12, "load8_u", [34_426]), 0);
 
 // memory_copy.wast:1609
-assert_return(() => call($12, "load8_u", [26_487]), 0);
+assert_return(() => call($12, "load8_u", [34_625]), 0);
 
 // memory_copy.wast:1610
-assert_return(() => call($12, "load8_u", [26_686]), 0);
+assert_return(() => call($12, "load8_u", [34_824]), 0);
 
 // memory_copy.wast:1611
-assert_return(() => call($12, "load8_u", [26_885]), 0);
+assert_return(() => call($12, "load8_u", [35_023]), 0);
 
 // memory_copy.wast:1612
-assert_return(() => call($12, "load8_u", [27_084]), 0);
+assert_return(() => call($12, "load8_u", [35_222]), 0);
 
 // memory_copy.wast:1613
-assert_return(() => call($12, "load8_u", [27_283]), 0);
+assert_return(() => call($12, "load8_u", [35_421]), 0);
 
 // memory_copy.wast:1614
-assert_return(() => call($12, "load8_u", [27_482]), 0);
+assert_return(() => call($12, "load8_u", [35_620]), 0);
 
 // memory_copy.wast:1615
-assert_return(() => call($12, "load8_u", [27_681]), 0);
+assert_return(() => call($12, "load8_u", [35_819]), 0);
 
 // memory_copy.wast:1616
-assert_return(() => call($12, "load8_u", [27_880]), 0);
+assert_return(() => call($12, "load8_u", [36_018]), 0);
 
 // memory_copy.wast:1617
-assert_return(() => call($12, "load8_u", [28_079]), 0);
+assert_return(() => call($12, "load8_u", [36_217]), 0);
 
 // memory_copy.wast:1618
-assert_return(() => call($12, "load8_u", [28_278]), 0);
+assert_return(() => call($12, "load8_u", [36_416]), 0);
 
 // memory_copy.wast:1619
-assert_return(() => call($12, "load8_u", [28_477]), 0);
+assert_return(() => call($12, "load8_u", [36_615]), 0);
 
 // memory_copy.wast:1620
-assert_return(() => call($12, "load8_u", [28_676]), 0);
+assert_return(() => call($12, "load8_u", [36_814]), 0);
 
 // memory_copy.wast:1621
-assert_return(() => call($12, "load8_u", [28_875]), 0);
+assert_return(() => call($12, "load8_u", [37_013]), 0);
 
 // memory_copy.wast:1622
-assert_return(() => call($12, "load8_u", [29_074]), 0);
+assert_return(() => call($12, "load8_u", [37_212]), 0);
 
 // memory_copy.wast:1623
-assert_return(() => call($12, "load8_u", [29_273]), 0);
+assert_return(() => call($12, "load8_u", [37_411]), 0);
 
 // memory_copy.wast:1624
-assert_return(() => call($12, "load8_u", [29_472]), 0);
+assert_return(() => call($12, "load8_u", [37_610]), 0);
 
 // memory_copy.wast:1625
-assert_return(() => call($12, "load8_u", [29_671]), 0);
+assert_return(() => call($12, "load8_u", [37_809]), 0);
 
 // memory_copy.wast:1626
-assert_return(() => call($12, "load8_u", [29_870]), 0);
+assert_return(() => call($12, "load8_u", [38_008]), 0);
 
 // memory_copy.wast:1627
-assert_return(() => call($12, "load8_u", [30_069]), 0);
+assert_return(() => call($12, "load8_u", [38_207]), 0);
 
 // memory_copy.wast:1628
-assert_return(() => call($12, "load8_u", [30_268]), 0);
+assert_return(() => call($12, "load8_u", [38_406]), 0);
 
 // memory_copy.wast:1629
-assert_return(() => call($12, "load8_u", [30_467]), 0);
+assert_return(() => call($12, "load8_u", [38_605]), 0);
 
 // memory_copy.wast:1630
-assert_return(() => call($12, "load8_u", [30_666]), 0);
+assert_return(() => call($12, "load8_u", [38_804]), 0);
 
 // memory_copy.wast:1631
-assert_return(() => call($12, "load8_u", [30_865]), 0);
+assert_return(() => call($12, "load8_u", [39_003]), 0);
 
 // memory_copy.wast:1632
-assert_return(() => call($12, "load8_u", [31_064]), 0);
+assert_return(() => call($12, "load8_u", [39_202]), 0);
 
 // memory_copy.wast:1633
-assert_return(() => call($12, "load8_u", [31_263]), 0);
+assert_return(() => call($12, "load8_u", [39_401]), 0);
 
 // memory_copy.wast:1634
-assert_return(() => call($12, "load8_u", [31_462]), 0);
+assert_return(() => call($12, "load8_u", [39_600]), 0);
 
 // memory_copy.wast:1635
-assert_return(() => call($12, "load8_u", [31_661]), 0);
+assert_return(() => call($12, "load8_u", [39_799]), 0);
 
 // memory_copy.wast:1636
-assert_return(() => call($12, "load8_u", [31_860]), 0);
+assert_return(() => call($12, "load8_u", [39_998]), 0);
 
 // memory_copy.wast:1637
-assert_return(() => call($12, "load8_u", [32_059]), 0);
+assert_return(() => call($12, "load8_u", [40_197]), 0);
 
 // memory_copy.wast:1638
-assert_return(() => call($12, "load8_u", [32_258]), 0);
+assert_return(() => call($12, "load8_u", [40_396]), 0);
 
 // memory_copy.wast:1639
-assert_return(() => call($12, "load8_u", [32_457]), 0);
+assert_return(() => call($12, "load8_u", [40_595]), 0);
 
 // memory_copy.wast:1640
-assert_return(() => call($12, "load8_u", [32_656]), 0);
+assert_return(() => call($12, "load8_u", [40_794]), 0);
 
 // memory_copy.wast:1641
-assert_return(() => call($12, "load8_u", [32_855]), 0);
+assert_return(() => call($12, "load8_u", [40_993]), 0);
 
 // memory_copy.wast:1642
-assert_return(() => call($12, "load8_u", [33_054]), 0);
+assert_return(() => call($12, "load8_u", [41_192]), 0);
 
 // memory_copy.wast:1643
-assert_return(() => call($12, "load8_u", [33_253]), 0);
+assert_return(() => call($12, "load8_u", [41_391]), 0);
 
 // memory_copy.wast:1644
-assert_return(() => call($12, "load8_u", [33_452]), 0);
+assert_return(() => call($12, "load8_u", [41_590]), 0);
 
 // memory_copy.wast:1645
-assert_return(() => call($12, "load8_u", [33_651]), 0);
+assert_return(() => call($12, "load8_u", [41_789]), 0);
 
 // memory_copy.wast:1646
-assert_return(() => call($12, "load8_u", [33_850]), 0);
+assert_return(() => call($12, "load8_u", [41_988]), 0);
 
 // memory_copy.wast:1647
-assert_return(() => call($12, "load8_u", [34_049]), 0);
+assert_return(() => call($12, "load8_u", [42_187]), 0);
 
 // memory_copy.wast:1648
-assert_return(() => call($12, "load8_u", [34_248]), 0);
+assert_return(() => call($12, "load8_u", [42_386]), 0);
 
 // memory_copy.wast:1649
-assert_return(() => call($12, "load8_u", [34_447]), 0);
+assert_return(() => call($12, "load8_u", [42_585]), 0);
 
 // memory_copy.wast:1650
-assert_return(() => call($12, "load8_u", [34_646]), 0);
+assert_return(() => call($12, "load8_u", [42_784]), 0);
 
 // memory_copy.wast:1651
-assert_return(() => call($12, "load8_u", [34_845]), 0);
+assert_return(() => call($12, "load8_u", [42_983]), 0);
 
 // memory_copy.wast:1652
-assert_return(() => call($12, "load8_u", [35_044]), 0);
+assert_return(() => call($12, "load8_u", [43_182]), 0);
 
 // memory_copy.wast:1653
-assert_return(() => call($12, "load8_u", [35_243]), 0);
+assert_return(() => call($12, "load8_u", [43_381]), 0);
 
 // memory_copy.wast:1654
-assert_return(() => call($12, "load8_u", [35_442]), 0);
+assert_return(() => call($12, "load8_u", [43_580]), 0);
 
 // memory_copy.wast:1655
-assert_return(() => call($12, "load8_u", [35_641]), 0);
+assert_return(() => call($12, "load8_u", [43_779]), 0);
 
 // memory_copy.wast:1656
-assert_return(() => call($12, "load8_u", [35_840]), 0);
+assert_return(() => call($12, "load8_u", [43_978]), 0);
 
 // memory_copy.wast:1657
-assert_return(() => call($12, "load8_u", [36_039]), 0);
+assert_return(() => call($12, "load8_u", [44_177]), 0);
 
 // memory_copy.wast:1658
-assert_return(() => call($12, "load8_u", [36_238]), 0);
+assert_return(() => call($12, "load8_u", [44_376]), 0);
 
 // memory_copy.wast:1659
-assert_return(() => call($12, "load8_u", [36_437]), 0);
+assert_return(() => call($12, "load8_u", [44_575]), 0);
 
 // memory_copy.wast:1660
-assert_return(() => call($12, "load8_u", [36_636]), 0);
+assert_return(() => call($12, "load8_u", [44_774]), 0);
 
 // memory_copy.wast:1661
-assert_return(() => call($12, "load8_u", [36_835]), 0);
+assert_return(() => call($12, "load8_u", [44_973]), 0);
 
 // memory_copy.wast:1662
-assert_return(() => call($12, "load8_u", [37_034]), 0);
+assert_return(() => call($12, "load8_u", [45_172]), 0);
 
 // memory_copy.wast:1663
-assert_return(() => call($12, "load8_u", [37_233]), 0);
+assert_return(() => call($12, "load8_u", [45_371]), 0);
 
 // memory_copy.wast:1664
-assert_return(() => call($12, "load8_u", [37_432]), 0);
+assert_return(() => call($12, "load8_u", [45_570]), 0);
 
 // memory_copy.wast:1665
-assert_return(() => call($12, "load8_u", [37_631]), 0);
+assert_return(() => call($12, "load8_u", [45_769]), 0);
 
 // memory_copy.wast:1666
-assert_return(() => call($12, "load8_u", [37_830]), 0);
+assert_return(() => call($12, "load8_u", [45_968]), 0);
 
 // memory_copy.wast:1667
-assert_return(() => call($12, "load8_u", [38_029]), 0);
+assert_return(() => call($12, "load8_u", [46_167]), 0);
 
 // memory_copy.wast:1668
-assert_return(() => call($12, "load8_u", [38_228]), 0);
+assert_return(() => call($12, "load8_u", [46_366]), 0);
 
 // memory_copy.wast:1669
-assert_return(() => call($12, "load8_u", [38_427]), 0);
+assert_return(() => call($12, "load8_u", [46_565]), 0);
 
 // memory_copy.wast:1670
-assert_return(() => call($12, "load8_u", [38_626]), 0);
+assert_return(() => call($12, "load8_u", [46_764]), 0);
 
 // memory_copy.wast:1671
-assert_return(() => call($12, "load8_u", [38_825]), 0);
+assert_return(() => call($12, "load8_u", [46_963]), 0);
 
 // memory_copy.wast:1672
-assert_return(() => call($12, "load8_u", [39_024]), 0);
+assert_return(() => call($12, "load8_u", [47_162]), 0);
 
 // memory_copy.wast:1673
-assert_return(() => call($12, "load8_u", [39_223]), 0);
+assert_return(() => call($12, "load8_u", [47_361]), 0);
 
 // memory_copy.wast:1674
-assert_return(() => call($12, "load8_u", [39_422]), 0);
+assert_return(() => call($12, "load8_u", [47_560]), 0);
 
 // memory_copy.wast:1675
-assert_return(() => call($12, "load8_u", [39_621]), 0);
+assert_return(() => call($12, "load8_u", [47_759]), 0);
 
 // memory_copy.wast:1676
-assert_return(() => call($12, "load8_u", [39_820]), 0);
+assert_return(() => call($12, "load8_u", [47_958]), 0);
 
 // memory_copy.wast:1677
-assert_return(() => call($12, "load8_u", [40_019]), 0);
+assert_return(() => call($12, "load8_u", [48_157]), 0);
 
 // memory_copy.wast:1678
-assert_return(() => call($12, "load8_u", [40_218]), 0);
+assert_return(() => call($12, "load8_u", [48_356]), 0);
 
 // memory_copy.wast:1679
-assert_return(() => call($12, "load8_u", [40_417]), 0);
+assert_return(() => call($12, "load8_u", [48_555]), 0);
 
 // memory_copy.wast:1680
-assert_return(() => call($12, "load8_u", [40_616]), 0);
+assert_return(() => call($12, "load8_u", [48_754]), 0);
 
 // memory_copy.wast:1681
-assert_return(() => call($12, "load8_u", [40_815]), 0);
+assert_return(() => call($12, "load8_u", [48_953]), 0);
 
 // memory_copy.wast:1682
-assert_return(() => call($12, "load8_u", [41_014]), 0);
+assert_return(() => call($12, "load8_u", [49_152]), 0);
 
 // memory_copy.wast:1683
-assert_return(() => call($12, "load8_u", [41_213]), 0);
+assert_return(() => call($12, "load8_u", [49_351]), 0);
 
 // memory_copy.wast:1684
-assert_return(() => call($12, "load8_u", [41_412]), 0);
+assert_return(() => call($12, "load8_u", [49_550]), 0);
 
 // memory_copy.wast:1685
-assert_return(() => call($12, "load8_u", [41_611]), 0);
+assert_return(() => call($12, "load8_u", [49_749]), 0);
 
 // memory_copy.wast:1686
-assert_return(() => call($12, "load8_u", [41_810]), 0);
+assert_return(() => call($12, "load8_u", [49_948]), 0);
 
 // memory_copy.wast:1687
-assert_return(() => call($12, "load8_u", [42_009]), 0);
+assert_return(() => call($12, "load8_u", [50_147]), 0);
 
 // memory_copy.wast:1688
-assert_return(() => call($12, "load8_u", [42_208]), 0);
+assert_return(() => call($12, "load8_u", [50_346]), 0);
 
 // memory_copy.wast:1689
-assert_return(() => call($12, "load8_u", [42_407]), 0);
+assert_return(() => call($12, "load8_u", [50_545]), 0);
 
 // memory_copy.wast:1690
-assert_return(() => call($12, "load8_u", [42_606]), 0);
+assert_return(() => call($12, "load8_u", [50_744]), 0);
 
 // memory_copy.wast:1691
-assert_return(() => call($12, "load8_u", [42_805]), 0);
+assert_return(() => call($12, "load8_u", [50_943]), 0);
 
 // memory_copy.wast:1692
-assert_return(() => call($12, "load8_u", [43_004]), 0);
+assert_return(() => call($12, "load8_u", [51_142]), 0);
 
 // memory_copy.wast:1693
-assert_return(() => call($12, "load8_u", [43_203]), 0);
+assert_return(() => call($12, "load8_u", [51_341]), 0);
 
 // memory_copy.wast:1694
-assert_return(() => call($12, "load8_u", [43_402]), 0);
+assert_return(() => call($12, "load8_u", [51_540]), 0);
 
 // memory_copy.wast:1695
-assert_return(() => call($12, "load8_u", [43_601]), 0);
+assert_return(() => call($12, "load8_u", [51_739]), 0);
 
 // memory_copy.wast:1696
-assert_return(() => call($12, "load8_u", [43_800]), 0);
+assert_return(() => call($12, "load8_u", [51_938]), 0);
 
 // memory_copy.wast:1697
-assert_return(() => call($12, "load8_u", [43_999]), 0);
+assert_return(() => call($12, "load8_u", [52_137]), 0);
 
 // memory_copy.wast:1698
-assert_return(() => call($12, "load8_u", [44_198]), 0);
+assert_return(() => call($12, "load8_u", [52_336]), 0);
 
 // memory_copy.wast:1699
-assert_return(() => call($12, "load8_u", [44_397]), 0);
+assert_return(() => call($12, "load8_u", [52_535]), 0);
 
 // memory_copy.wast:1700
-assert_return(() => call($12, "load8_u", [44_596]), 0);
+assert_return(() => call($12, "load8_u", [52_734]), 0);
 
 // memory_copy.wast:1701
-assert_return(() => call($12, "load8_u", [44_795]), 0);
+assert_return(() => call($12, "load8_u", [52_933]), 0);
 
 // memory_copy.wast:1702
-assert_return(() => call($12, "load8_u", [44_994]), 0);
+assert_return(() => call($12, "load8_u", [53_132]), 0);
 
 // memory_copy.wast:1703
-assert_return(() => call($12, "load8_u", [45_193]), 0);
+assert_return(() => call($12, "load8_u", [53_331]), 0);
 
 // memory_copy.wast:1704
-assert_return(() => call($12, "load8_u", [45_392]), 0);
+assert_return(() => call($12, "load8_u", [53_530]), 0);
 
 // memory_copy.wast:1705
-assert_return(() => call($12, "load8_u", [45_591]), 0);
+assert_return(() => call($12, "load8_u", [53_729]), 0);
 
 // memory_copy.wast:1706
-assert_return(() => call($12, "load8_u", [45_790]), 0);
+assert_return(() => call($12, "load8_u", [53_928]), 0);
 
 // memory_copy.wast:1707
-assert_return(() => call($12, "load8_u", [45_989]), 0);
+assert_return(() => call($12, "load8_u", [54_127]), 0);
 
 // memory_copy.wast:1708
-assert_return(() => call($12, "load8_u", [46_188]), 0);
+assert_return(() => call($12, "load8_u", [54_326]), 0);
 
 // memory_copy.wast:1709
-assert_return(() => call($12, "load8_u", [46_387]), 0);
+assert_return(() => call($12, "load8_u", [54_525]), 0);
 
 // memory_copy.wast:1710
-assert_return(() => call($12, "load8_u", [46_586]), 0);
+assert_return(() => call($12, "load8_u", [54_724]), 0);
 
 // memory_copy.wast:1711
-assert_return(() => call($12, "load8_u", [46_785]), 0);
+assert_return(() => call($12, "load8_u", [54_923]), 0);
 
 // memory_copy.wast:1712
-assert_return(() => call($12, "load8_u", [46_984]), 0);
+assert_return(() => call($12, "load8_u", [55_122]), 0);
 
 // memory_copy.wast:1713
-assert_return(() => call($12, "load8_u", [47_183]), 0);
+assert_return(() => call($12, "load8_u", [55_321]), 0);
 
 // memory_copy.wast:1714
-assert_return(() => call($12, "load8_u", [47_382]), 0);
+assert_return(() => call($12, "load8_u", [55_520]), 0);
 
 // memory_copy.wast:1715
-assert_return(() => call($12, "load8_u", [47_581]), 0);
+assert_return(() => call($12, "load8_u", [55_719]), 0);
 
 // memory_copy.wast:1716
-assert_return(() => call($12, "load8_u", [47_780]), 0);
+assert_return(() => call($12, "load8_u", [55_918]), 0);
 
 // memory_copy.wast:1717
-assert_return(() => call($12, "load8_u", [47_979]), 0);
+assert_return(() => call($12, "load8_u", [56_117]), 0);
 
 // memory_copy.wast:1718
-assert_return(() => call($12, "load8_u", [48_178]), 0);
+assert_return(() => call($12, "load8_u", [56_316]), 0);
 
 // memory_copy.wast:1719
-assert_return(() => call($12, "load8_u", [48_377]), 0);
+assert_return(() => call($12, "load8_u", [56_515]), 0);
 
 // memory_copy.wast:1720
-assert_return(() => call($12, "load8_u", [48_576]), 0);
+assert_return(() => call($12, "load8_u", [56_714]), 0);
 
 // memory_copy.wast:1721
-assert_return(() => call($12, "load8_u", [48_775]), 0);
+assert_return(() => call($12, "load8_u", [56_913]), 0);
 
 // memory_copy.wast:1722
-assert_return(() => call($12, "load8_u", [48_974]), 0);
+assert_return(() => call($12, "load8_u", [57_112]), 0);
 
 // memory_copy.wast:1723
-assert_return(() => call($12, "load8_u", [49_173]), 0);
+assert_return(() => call($12, "load8_u", [57_311]), 0);
 
 // memory_copy.wast:1724
-assert_return(() => call($12, "load8_u", [49_372]), 0);
+assert_return(() => call($12, "load8_u", [57_510]), 0);
 
 // memory_copy.wast:1725
-assert_return(() => call($12, "load8_u", [49_571]), 0);
+assert_return(() => call($12, "load8_u", [57_709]), 0);
 
 // memory_copy.wast:1726
-assert_return(() => call($12, "load8_u", [49_770]), 0);
+assert_return(() => call($12, "load8_u", [57_908]), 0);
 
 // memory_copy.wast:1727
-assert_return(() => call($12, "load8_u", [49_969]), 0);
+assert_return(() => call($12, "load8_u", [58_107]), 0);
 
 // memory_copy.wast:1728
-assert_return(() => call($12, "load8_u", [50_168]), 0);
+assert_return(() => call($12, "load8_u", [58_306]), 0);
 
 // memory_copy.wast:1729
-assert_return(() => call($12, "load8_u", [50_367]), 0);
+assert_return(() => call($12, "load8_u", [58_505]), 0);
 
 // memory_copy.wast:1730
-assert_return(() => call($12, "load8_u", [50_566]), 0);
+assert_return(() => call($12, "load8_u", [58_704]), 0);
 
 // memory_copy.wast:1731
-assert_return(() => call($12, "load8_u", [50_765]), 0);
+assert_return(() => call($12, "load8_u", [58_903]), 0);
 
 // memory_copy.wast:1732
-assert_return(() => call($12, "load8_u", [50_964]), 0);
+assert_return(() => call($12, "load8_u", [59_102]), 0);
 
 // memory_copy.wast:1733
-assert_return(() => call($12, "load8_u", [51_163]), 0);
+assert_return(() => call($12, "load8_u", [59_301]), 0);
 
 // memory_copy.wast:1734
-assert_return(() => call($12, "load8_u", [51_362]), 0);
+assert_return(() => call($12, "load8_u", [59_500]), 0);
 
 // memory_copy.wast:1735
-assert_return(() => call($12, "load8_u", [51_561]), 0);
+assert_return(() => call($12, "load8_u", [59_699]), 0);
 
 // memory_copy.wast:1736
-assert_return(() => call($12, "load8_u", [51_760]), 0);
+assert_return(() => call($12, "load8_u", [59_898]), 0);
 
 // memory_copy.wast:1737
-assert_return(() => call($12, "load8_u", [51_959]), 0);
+assert_return(() => call($12, "load8_u", [60_097]), 0);
 
 // memory_copy.wast:1738
-assert_return(() => call($12, "load8_u", [52_158]), 0);
+assert_return(() => call($12, "load8_u", [60_296]), 0);
 
 // memory_copy.wast:1739
-assert_return(() => call($12, "load8_u", [52_357]), 0);
+assert_return(() => call($12, "load8_u", [60_495]), 0);
 
 // memory_copy.wast:1740
-assert_return(() => call($12, "load8_u", [52_556]), 0);
+assert_return(() => call($12, "load8_u", [60_694]), 0);
 
 // memory_copy.wast:1741
-assert_return(() => call($12, "load8_u", [52_755]), 0);
+assert_return(() => call($12, "load8_u", [60_893]), 0);
 
 // memory_copy.wast:1742
-assert_return(() => call($12, "load8_u", [52_954]), 0);
+assert_return(() => call($12, "load8_u", [61_092]), 0);
 
 // memory_copy.wast:1743
-assert_return(() => call($12, "load8_u", [53_153]), 0);
+assert_return(() => call($12, "load8_u", [61_291]), 0);
 
 // memory_copy.wast:1744
-assert_return(() => call($12, "load8_u", [53_352]), 0);
+assert_return(() => call($12, "load8_u", [61_490]), 0);
 
 // memory_copy.wast:1745
-assert_return(() => call($12, "load8_u", [53_551]), 0);
+assert_return(() => call($12, "load8_u", [61_689]), 0);
 
 // memory_copy.wast:1746
-assert_return(() => call($12, "load8_u", [53_750]), 0);
+assert_return(() => call($12, "load8_u", [61_888]), 0);
 
 // memory_copy.wast:1747
-assert_return(() => call($12, "load8_u", [53_949]), 0);
+assert_return(() => call($12, "load8_u", [62_087]), 0);
 
 // memory_copy.wast:1748
-assert_return(() => call($12, "load8_u", [54_148]), 0);
+assert_return(() => call($12, "load8_u", [62_286]), 0);
 
 // memory_copy.wast:1749
-assert_return(() => call($12, "load8_u", [54_347]), 0);
+assert_return(() => call($12, "load8_u", [62_485]), 0);
 
 // memory_copy.wast:1750
-assert_return(() => call($12, "load8_u", [54_546]), 0);
+assert_return(() => call($12, "load8_u", [62_684]), 0);
 
 // memory_copy.wast:1751
-assert_return(() => call($12, "load8_u", [54_745]), 0);
+assert_return(() => call($12, "load8_u", [62_883]), 0);
 
 // memory_copy.wast:1752
-assert_return(() => call($12, "load8_u", [54_944]), 0);
+assert_return(() => call($12, "load8_u", [63_082]), 0);
 
 // memory_copy.wast:1753
-assert_return(() => call($12, "load8_u", [55_143]), 0);
+assert_return(() => call($12, "load8_u", [63_281]), 0);
 
 // memory_copy.wast:1754
-assert_return(() => call($12, "load8_u", [55_342]), 0);
+assert_return(() => call($12, "load8_u", [63_480]), 0);
 
 // memory_copy.wast:1755
-assert_return(() => call($12, "load8_u", [55_541]), 0);
+assert_return(() => call($12, "load8_u", [63_679]), 0);
 
 // memory_copy.wast:1756
-assert_return(() => call($12, "load8_u", [55_740]), 0);
+assert_return(() => call($12, "load8_u", [63_878]), 0);
 
 // memory_copy.wast:1757
-assert_return(() => call($12, "load8_u", [55_939]), 0);
+assert_return(() => call($12, "load8_u", [64_077]), 0);
 
 // memory_copy.wast:1758
-assert_return(() => call($12, "load8_u", [56_138]), 0);
+assert_return(() => call($12, "load8_u", [64_276]), 0);
 
 // memory_copy.wast:1759
-assert_return(() => call($12, "load8_u", [56_337]), 0);
+assert_return(() => call($12, "load8_u", [64_475]), 0);
 
 // memory_copy.wast:1760
-assert_return(() => call($12, "load8_u", [56_536]), 0);
+assert_return(() => call($12, "load8_u", [64_674]), 0);
 
 // memory_copy.wast:1761
-assert_return(() => call($12, "load8_u", [56_735]), 0);
+assert_return(() => call($12, "load8_u", [64_873]), 0);
 
 // memory_copy.wast:1762
-assert_return(() => call($12, "load8_u", [56_934]), 0);
+assert_return(() => call($12, "load8_u", [65_072]), 0);
 
 // memory_copy.wast:1763
-assert_return(() => call($12, "load8_u", [57_133]), 0);
+assert_return(() => call($12, "load8_u", [65_271]), 0);
 
 // memory_copy.wast:1764
-assert_return(() => call($12, "load8_u", [57_332]), 0);
+assert_return(() => call($12, "load8_u", [65_470]), 0);
 
 // memory_copy.wast:1765
-assert_return(() => call($12, "load8_u", [57_531]), 0);
+assert_return(() => call($12, "load8_u", [65_515]), 0);
 
 // memory_copy.wast:1766
-assert_return(() => call($12, "load8_u", [57_730]), 0);
+assert_return(() => call($12, "load8_u", [65_516]), 1);
 
 // memory_copy.wast:1767
-assert_return(() => call($12, "load8_u", [57_929]), 0);
+assert_return(() => call($12, "load8_u", [65_517]), 2);
 
 // memory_copy.wast:1768
-assert_return(() => call($12, "load8_u", [58_128]), 0);
+assert_return(() => call($12, "load8_u", [65_518]), 3);
 
 // memory_copy.wast:1769
-assert_return(() => call($12, "load8_u", [58_327]), 0);
+assert_return(() => call($12, "load8_u", [65_519]), 4);
 
 // memory_copy.wast:1770
-assert_return(() => call($12, "load8_u", [58_526]), 0);
+assert_return(() => call($12, "load8_u", [65_520]), 5);
 
 // memory_copy.wast:1771
-assert_return(() => call($12, "load8_u", [58_725]), 0);
+assert_return(() => call($12, "load8_u", [65_521]), 6);
 
 // memory_copy.wast:1772
-assert_return(() => call($12, "load8_u", [58_924]), 0);
+assert_return(() => call($12, "load8_u", [65_522]), 7);
 
 // memory_copy.wast:1773
-assert_return(() => call($12, "load8_u", [59_123]), 0);
+assert_return(() => call($12, "load8_u", [65_523]), 8);
 
 // memory_copy.wast:1774
-assert_return(() => call($12, "load8_u", [59_322]), 0);
+assert_return(() => call($12, "load8_u", [65_524]), 9);
 
 // memory_copy.wast:1775
-assert_return(() => call($12, "load8_u", [59_521]), 0);
+assert_return(() => call($12, "load8_u", [65_525]), 10);
 
 // memory_copy.wast:1776
-assert_return(() => call($12, "load8_u", [59_720]), 0);
+assert_return(() => call($12, "load8_u", [65_526]), 11);
 
 // memory_copy.wast:1777
-assert_return(() => call($12, "load8_u", [59_919]), 0);
+assert_return(() => call($12, "load8_u", [65_527]), 12);
 
 // memory_copy.wast:1778
-assert_return(() => call($12, "load8_u", [60_118]), 0);
+assert_return(() => call($12, "load8_u", [65_528]), 13);
 
 // memory_copy.wast:1779
-assert_return(() => call($12, "load8_u", [60_317]), 0);
+assert_return(() => call($12, "load8_u", [65_529]), 14);
 
 // memory_copy.wast:1780
-assert_return(() => call($12, "load8_u", [60_516]), 0);
+assert_return(() => call($12, "load8_u", [65_530]), 15);
 
 // memory_copy.wast:1781
-assert_return(() => call($12, "load8_u", [60_715]), 0);
+assert_return(() => call($12, "load8_u", [65_531]), 16);
 
 // memory_copy.wast:1782
-assert_return(() => call($12, "load8_u", [60_914]), 0);
+assert_return(() => call($12, "load8_u", [65_532]), 17);
 
 // memory_copy.wast:1783
-assert_return(() => call($12, "load8_u", [61_113]), 0);
+assert_return(() => call($12, "load8_u", [65_533]), 18);
 
 // memory_copy.wast:1784
-assert_return(() => call($12, "load8_u", [61_312]), 0);
+assert_return(() => call($12, "load8_u", [65_534]), 19);
 
 // memory_copy.wast:1785
-assert_return(() => call($12, "load8_u", [61_511]), 0);
-
-// memory_copy.wast:1786
-assert_return(() => call($12, "load8_u", [61_710]), 0);
+assert_return(() => call($12, "load8_u", [65_535]), 20);
 
 // memory_copy.wast:1787
-assert_return(() => call($12, "load8_u", [61_909]), 0);
-
-// memory_copy.wast:1788
-assert_return(() => call($12, "load8_u", [62_108]), 0);
-
-// memory_copy.wast:1789
-assert_return(() => call($12, "load8_u", [62_307]), 0);
-
-// memory_copy.wast:1790
-assert_return(() => call($12, "load8_u", [62_506]), 0);
-
-// memory_copy.wast:1791
-assert_return(() => call($12, "load8_u", [62_705]), 0);
-
-// memory_copy.wast:1792
-assert_return(() => call($12, "load8_u", [62_904]), 0);
-
-// memory_copy.wast:1793
-assert_return(() => call($12, "load8_u", [63_103]), 0);
-
-// memory_copy.wast:1794
-assert_return(() => call($12, "load8_u", [63_302]), 0);
+let $13 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8c\x80\x80\x80\x00\x02\x60\x03\x7f\x7f\x7f\x00\x60\x01\x7f\x01\x7f\x03\x83\x80\x80\x80\x00\x02\x00\x01\x05\x84\x80\x80\x80\x00\x01\x01\x01\x01\x07\x97\x80\x80\x80\x00\x03\x03\x6d\x65\x6d\x02\x00\x03\x72\x75\x6e\x00\x00\x07\x6c\x6f\x61\x64\x38\x5f\x75\x00\x01\x0a\x9e\x80\x80\x80\x00\x02\x8c\x80\x80\x80\x00\x00\x20\x00\x20\x01\x20\x02\xfc\x0a\x00\x00\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x2d\x00\x00\x0b\x0b\x9c\x80\x80\x80\x00\x01\x00\x41\xce\xff\x03\x0b\x14\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10\x11\x12\x13");
 
 // memory_copy.wast:1795
-assert_return(() => call($12, "load8_u", [63_501]), 0);
-
-// memory_copy.wast:1796
-assert_return(() => call($12, "load8_u", [63_700]), 0);
-
-// memory_copy.wast:1797
-assert_return(() => call($12, "load8_u", [63_899]), 0);
+assert_trap(() => call($13, "run", [65_516, 65_486, 40]));
 
 // memory_copy.wast:1798
-assert_return(() => call($12, "load8_u", [64_098]), 0);
+assert_return(() => call($13, "load8_u", [198]), 0);
 
 // memory_copy.wast:1799
-assert_return(() => call($12, "load8_u", [64_297]), 0);
+assert_return(() => call($13, "load8_u", [397]), 0);
 
 // memory_copy.wast:1800
-assert_return(() => call($12, "load8_u", [64_496]), 0);
+assert_return(() => call($13, "load8_u", [596]), 0);
 
 // memory_copy.wast:1801
-assert_return(() => call($12, "load8_u", [64_695]), 0);
+assert_return(() => call($13, "load8_u", [795]), 0);
 
 // memory_copy.wast:1802
-assert_return(() => call($12, "load8_u", [64_894]), 0);
+assert_return(() => call($13, "load8_u", [994]), 0);
 
 // memory_copy.wast:1803
-assert_return(() => call($12, "load8_u", [65_093]), 0);
+assert_return(() => call($13, "load8_u", [1_193]), 0);
 
 // memory_copy.wast:1804
-assert_return(() => call($12, "load8_u", [65_292]), 0);
+assert_return(() => call($13, "load8_u", [1_392]), 0);
 
 // memory_copy.wast:1805
-assert_return(() => call($12, "load8_u", [65_491]), 0);
+assert_return(() => call($13, "load8_u", [1_591]), 0);
 
 // memory_copy.wast:1806
-assert_return(() => call($12, "load8_u", [65_515]), 0);
+assert_return(() => call($13, "load8_u", [1_790]), 0);
 
 // memory_copy.wast:1807
-assert_return(() => call($12, "load8_u", [65_516]), 1);
+assert_return(() => call($13, "load8_u", [1_989]), 0);
 
 // memory_copy.wast:1808
-assert_return(() => call($12, "load8_u", [65_517]), 2);
+assert_return(() => call($13, "load8_u", [2_188]), 0);
 
 // memory_copy.wast:1809
-assert_return(() => call($12, "load8_u", [65_518]), 3);
+assert_return(() => call($13, "load8_u", [2_387]), 0);
 
 // memory_copy.wast:1810
-assert_return(() => call($12, "load8_u", [65_519]), 4);
+assert_return(() => call($13, "load8_u", [2_586]), 0);
 
 // memory_copy.wast:1811
-assert_return(() => call($12, "load8_u", [65_520]), 5);
+assert_return(() => call($13, "load8_u", [2_785]), 0);
 
 // memory_copy.wast:1812
-assert_return(() => call($12, "load8_u", [65_521]), 6);
+assert_return(() => call($13, "load8_u", [2_984]), 0);
 
 // memory_copy.wast:1813
-assert_return(() => call($12, "load8_u", [65_522]), 7);
+assert_return(() => call($13, "load8_u", [3_183]), 0);
 
 // memory_copy.wast:1814
-assert_return(() => call($12, "load8_u", [65_523]), 8);
+assert_return(() => call($13, "load8_u", [3_382]), 0);
 
 // memory_copy.wast:1815
-assert_return(() => call($12, "load8_u", [65_524]), 9);
+assert_return(() => call($13, "load8_u", [3_581]), 0);
 
 // memory_copy.wast:1816
-assert_return(() => call($12, "load8_u", [65_525]), 10);
+assert_return(() => call($13, "load8_u", [3_780]), 0);
 
 // memory_copy.wast:1817
-assert_return(() => call($12, "load8_u", [65_526]), 11);
+assert_return(() => call($13, "load8_u", [3_979]), 0);
 
 // memory_copy.wast:1818
-assert_return(() => call($12, "load8_u", [65_527]), 12);
+assert_return(() => call($13, "load8_u", [4_178]), 0);
 
 // memory_copy.wast:1819
-assert_return(() => call($12, "load8_u", [65_528]), 13);
+assert_return(() => call($13, "load8_u", [4_377]), 0);
 
 // memory_copy.wast:1820
-assert_return(() => call($12, "load8_u", [65_529]), 14);
+assert_return(() => call($13, "load8_u", [4_576]), 0);
 
 // memory_copy.wast:1821
-assert_return(() => call($12, "load8_u", [65_530]), 15);
+assert_return(() => call($13, "load8_u", [4_775]), 0);
 
 // memory_copy.wast:1822
-assert_return(() => call($12, "load8_u", [65_531]), 16);
+assert_return(() => call($13, "load8_u", [4_974]), 0);
 
 // memory_copy.wast:1823
-assert_return(() => call($12, "load8_u", [65_532]), 17);
+assert_return(() => call($13, "load8_u", [5_173]), 0);
 
 // memory_copy.wast:1824
-assert_return(() => call($12, "load8_u", [65_533]), 18);
+assert_return(() => call($13, "load8_u", [5_372]), 0);
 
 // memory_copy.wast:1825
-assert_return(() => call($12, "load8_u", [65_534]), 19);
+assert_return(() => call($13, "load8_u", [5_571]), 0);
 
 // memory_copy.wast:1826
-assert_return(() => call($12, "load8_u", [65_535]), 20);
+assert_return(() => call($13, "load8_u", [5_770]), 0);
+
+// memory_copy.wast:1827
+assert_return(() => call($13, "load8_u", [5_969]), 0);
 
 // memory_copy.wast:1828
-let $13 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8c\x80\x80\x80\x00\x02\x60\x03\x7f\x7f\x7f\x00\x60\x01\x7f\x01\x7f\x03\x83\x80\x80\x80\x00\x02\x00\x01\x05\x84\x80\x80\x80\x00\x01\x01\x01\x01\x07\x97\x80\x80\x80\x00\x03\x03\x6d\x65\x6d\x02\x00\x03\x72\x75\x6e\x00\x00\x07\x6c\x6f\x61\x64\x38\x5f\x75\x00\x01\x0a\x9e\x80\x80\x80\x00\x02\x8c\x80\x80\x80\x00\x00\x20\x00\x20\x01\x20\x02\xfc\x0a\x00\x00\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x2d\x00\x00\x0b\x0b\x9c\x80\x80\x80\x00\x01\x00\x41\xce\xff\x03\x0b\x14\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10\x11\x12\x13");
+assert_return(() => call($13, "load8_u", [6_168]), 0);
+
+// memory_copy.wast:1829
+assert_return(() => call($13, "load8_u", [6_367]), 0);
+
+// memory_copy.wast:1830
+assert_return(() => call($13, "load8_u", [6_566]), 0);
+
+// memory_copy.wast:1831
+assert_return(() => call($13, "load8_u", [6_765]), 0);
+
+// memory_copy.wast:1832
+assert_return(() => call($13, "load8_u", [6_964]), 0);
+
+// memory_copy.wast:1833
+assert_return(() => call($13, "load8_u", [7_163]), 0);
+
+// memory_copy.wast:1834
+assert_return(() => call($13, "load8_u", [7_362]), 0);
+
+// memory_copy.wast:1835
+assert_return(() => call($13, "load8_u", [7_561]), 0);
 
 // memory_copy.wast:1836
-assert_trap(() => call($13, "run", [65_516, 65_486, 40]));
+assert_return(() => call($13, "load8_u", [7_760]), 0);
+
+// memory_copy.wast:1837
+assert_return(() => call($13, "load8_u", [7_959]), 0);
+
+// memory_copy.wast:1838
+assert_return(() => call($13, "load8_u", [8_158]), 0);
 
 // memory_copy.wast:1839
-assert_return(() => call($13, "load8_u", [198]), 0);
+assert_return(() => call($13, "load8_u", [8_357]), 0);
 
 // memory_copy.wast:1840
-assert_return(() => call($13, "load8_u", [397]), 0);
+assert_return(() => call($13, "load8_u", [8_556]), 0);
 
 // memory_copy.wast:1841
-assert_return(() => call($13, "load8_u", [596]), 0);
+assert_return(() => call($13, "load8_u", [8_755]), 0);
 
 // memory_copy.wast:1842
-assert_return(() => call($13, "load8_u", [795]), 0);
+assert_return(() => call($13, "load8_u", [8_954]), 0);
 
 // memory_copy.wast:1843
-assert_return(() => call($13, "load8_u", [994]), 0);
+assert_return(() => call($13, "load8_u", [9_153]), 0);
 
 // memory_copy.wast:1844
-assert_return(() => call($13, "load8_u", [1_193]), 0);
+assert_return(() => call($13, "load8_u", [9_352]), 0);
 
 // memory_copy.wast:1845
-assert_return(() => call($13, "load8_u", [1_392]), 0);
+assert_return(() => call($13, "load8_u", [9_551]), 0);
 
 // memory_copy.wast:1846
-assert_return(() => call($13, "load8_u", [1_591]), 0);
+assert_return(() => call($13, "load8_u", [9_750]), 0);
 
 // memory_copy.wast:1847
-assert_return(() => call($13, "load8_u", [1_790]), 0);
+assert_return(() => call($13, "load8_u", [9_949]), 0);
 
 // memory_copy.wast:1848
-assert_return(() => call($13, "load8_u", [1_989]), 0);
+assert_return(() => call($13, "load8_u", [10_148]), 0);
 
 // memory_copy.wast:1849
-assert_return(() => call($13, "load8_u", [2_188]), 0);
+assert_return(() => call($13, "load8_u", [10_347]), 0);
 
 // memory_copy.wast:1850
-assert_return(() => call($13, "load8_u", [2_387]), 0);
+assert_return(() => call($13, "load8_u", [10_546]), 0);
 
 // memory_copy.wast:1851
-assert_return(() => call($13, "load8_u", [2_586]), 0);
+assert_return(() => call($13, "load8_u", [10_745]), 0);
 
 // memory_copy.wast:1852
-assert_return(() => call($13, "load8_u", [2_785]), 0);
+assert_return(() => call($13, "load8_u", [10_944]), 0);
 
 // memory_copy.wast:1853
-assert_return(() => call($13, "load8_u", [2_984]), 0);
+assert_return(() => call($13, "load8_u", [11_143]), 0);
 
 // memory_copy.wast:1854
-assert_return(() => call($13, "load8_u", [3_183]), 0);
+assert_return(() => call($13, "load8_u", [11_342]), 0);
 
 // memory_copy.wast:1855
-assert_return(() => call($13, "load8_u", [3_382]), 0);
+assert_return(() => call($13, "load8_u", [11_541]), 0);
 
 // memory_copy.wast:1856
-assert_return(() => call($13, "load8_u", [3_581]), 0);
+assert_return(() => call($13, "load8_u", [11_740]), 0);
 
 // memory_copy.wast:1857
-assert_return(() => call($13, "load8_u", [3_780]), 0);
+assert_return(() => call($13, "load8_u", [11_939]), 0);
 
 // memory_copy.wast:1858
-assert_return(() => call($13, "load8_u", [3_979]), 0);
+assert_return(() => call($13, "load8_u", [12_138]), 0);
 
 // memory_copy.wast:1859
-assert_return(() => call($13, "load8_u", [4_178]), 0);
+assert_return(() => call($13, "load8_u", [12_337]), 0);
 
 // memory_copy.wast:1860
-assert_return(() => call($13, "load8_u", [4_377]), 0);
+assert_return(() => call($13, "load8_u", [12_536]), 0);
 
 // memory_copy.wast:1861
-assert_return(() => call($13, "load8_u", [4_576]), 0);
+assert_return(() => call($13, "load8_u", [12_735]), 0);
 
 // memory_copy.wast:1862
-assert_return(() => call($13, "load8_u", [4_775]), 0);
+assert_return(() => call($13, "load8_u", [12_934]), 0);
 
 // memory_copy.wast:1863
-assert_return(() => call($13, "load8_u", [4_974]), 0);
+assert_return(() => call($13, "load8_u", [13_133]), 0);
 
 // memory_copy.wast:1864
-assert_return(() => call($13, "load8_u", [5_173]), 0);
+assert_return(() => call($13, "load8_u", [13_332]), 0);
 
 // memory_copy.wast:1865
-assert_return(() => call($13, "load8_u", [5_372]), 0);
+assert_return(() => call($13, "load8_u", [13_531]), 0);
 
 // memory_copy.wast:1866
-assert_return(() => call($13, "load8_u", [5_571]), 0);
+assert_return(() => call($13, "load8_u", [13_730]), 0);
 
 // memory_copy.wast:1867
-assert_return(() => call($13, "load8_u", [5_770]), 0);
+assert_return(() => call($13, "load8_u", [13_929]), 0);
 
 // memory_copy.wast:1868
-assert_return(() => call($13, "load8_u", [5_969]), 0);
+assert_return(() => call($13, "load8_u", [14_128]), 0);
 
 // memory_copy.wast:1869
-assert_return(() => call($13, "load8_u", [6_168]), 0);
+assert_return(() => call($13, "load8_u", [14_327]), 0);
 
 // memory_copy.wast:1870
-assert_return(() => call($13, "load8_u", [6_367]), 0);
+assert_return(() => call($13, "load8_u", [14_526]), 0);
 
 // memory_copy.wast:1871
-assert_return(() => call($13, "load8_u", [6_566]), 0);
+assert_return(() => call($13, "load8_u", [14_725]), 0);
 
 // memory_copy.wast:1872
-assert_return(() => call($13, "load8_u", [6_765]), 0);
+assert_return(() => call($13, "load8_u", [14_924]), 0);
 
 // memory_copy.wast:1873
-assert_return(() => call($13, "load8_u", [6_964]), 0);
+assert_return(() => call($13, "load8_u", [15_123]), 0);
 
 // memory_copy.wast:1874
-assert_return(() => call($13, "load8_u", [7_163]), 0);
+assert_return(() => call($13, "load8_u", [15_322]), 0);
 
 // memory_copy.wast:1875
-assert_return(() => call($13, "load8_u", [7_362]), 0);
+assert_return(() => call($13, "load8_u", [15_521]), 0);
 
 // memory_copy.wast:1876
-assert_return(() => call($13, "load8_u", [7_561]), 0);
+assert_return(() => call($13, "load8_u", [15_720]), 0);
 
 // memory_copy.wast:1877
-assert_return(() => call($13, "load8_u", [7_760]), 0);
+assert_return(() => call($13, "load8_u", [15_919]), 0);
 
 // memory_copy.wast:1878
-assert_return(() => call($13, "load8_u", [7_959]), 0);
+assert_return(() => call($13, "load8_u", [16_118]), 0);
 
 // memory_copy.wast:1879
-assert_return(() => call($13, "load8_u", [8_158]), 0);
+assert_return(() => call($13, "load8_u", [16_317]), 0);
 
 // memory_copy.wast:1880
-assert_return(() => call($13, "load8_u", [8_357]), 0);
+assert_return(() => call($13, "load8_u", [16_516]), 0);
 
 // memory_copy.wast:1881
-assert_return(() => call($13, "load8_u", [8_556]), 0);
+assert_return(() => call($13, "load8_u", [16_715]), 0);
 
 // memory_copy.wast:1882
-assert_return(() => call($13, "load8_u", [8_755]), 0);
+assert_return(() => call($13, "load8_u", [16_914]), 0);
 
 // memory_copy.wast:1883
-assert_return(() => call($13, "load8_u", [8_954]), 0);
+assert_return(() => call($13, "load8_u", [17_113]), 0);
 
 // memory_copy.wast:1884
-assert_return(() => call($13, "load8_u", [9_153]), 0);
+assert_return(() => call($13, "load8_u", [17_312]), 0);
 
 // memory_copy.wast:1885
-assert_return(() => call($13, "load8_u", [9_352]), 0);
+assert_return(() => call($13, "load8_u", [17_511]), 0);
 
 // memory_copy.wast:1886
-assert_return(() => call($13, "load8_u", [9_551]), 0);
+assert_return(() => call($13, "load8_u", [17_710]), 0);
 
 // memory_copy.wast:1887
-assert_return(() => call($13, "load8_u", [9_750]), 0);
+assert_return(() => call($13, "load8_u", [17_909]), 0);
 
 // memory_copy.wast:1888
-assert_return(() => call($13, "load8_u", [9_949]), 0);
+assert_return(() => call($13, "load8_u", [18_108]), 0);
 
 // memory_copy.wast:1889
-assert_return(() => call($13, "load8_u", [10_148]), 0);
+assert_return(() => call($13, "load8_u", [18_307]), 0);
 
 // memory_copy.wast:1890
-assert_return(() => call($13, "load8_u", [10_347]), 0);
+assert_return(() => call($13, "load8_u", [18_506]), 0);
 
 // memory_copy.wast:1891
-assert_return(() => call($13, "load8_u", [10_546]), 0);
+assert_return(() => call($13, "load8_u", [18_705]), 0);
 
 // memory_copy.wast:1892
-assert_return(() => call($13, "load8_u", [10_745]), 0);
+assert_return(() => call($13, "load8_u", [18_904]), 0);
 
 // memory_copy.wast:1893
-assert_return(() => call($13, "load8_u", [10_944]), 0);
+assert_return(() => call($13, "load8_u", [19_103]), 0);
 
 // memory_copy.wast:1894
-assert_return(() => call($13, "load8_u", [11_143]), 0);
+assert_return(() => call($13, "load8_u", [19_302]), 0);
 
 // memory_copy.wast:1895
-assert_return(() => call($13, "load8_u", [11_342]), 0);
+assert_return(() => call($13, "load8_u", [19_501]), 0);
 
 // memory_copy.wast:1896
-assert_return(() => call($13, "load8_u", [11_541]), 0);
+assert_return(() => call($13, "load8_u", [19_700]), 0);
 
 // memory_copy.wast:1897
-assert_return(() => call($13, "load8_u", [11_740]), 0);
+assert_return(() => call($13, "load8_u", [19_899]), 0);
 
 // memory_copy.wast:1898
-assert_return(() => call($13, "load8_u", [11_939]), 0);
+assert_return(() => call($13, "load8_u", [20_098]), 0);
 
 // memory_copy.wast:1899
-assert_return(() => call($13, "load8_u", [12_138]), 0);
+assert_return(() => call($13, "load8_u", [20_297]), 0);
 
 // memory_copy.wast:1900
-assert_return(() => call($13, "load8_u", [12_337]), 0);
+assert_return(() => call($13, "load8_u", [20_496]), 0);
 
 // memory_copy.wast:1901
-assert_return(() => call($13, "load8_u", [12_536]), 0);
+assert_return(() => call($13, "load8_u", [20_695]), 0);
 
 // memory_copy.wast:1902
-assert_return(() => call($13, "load8_u", [12_735]), 0);
+assert_return(() => call($13, "load8_u", [20_894]), 0);
 
 // memory_copy.wast:1903
-assert_return(() => call($13, "load8_u", [12_934]), 0);
+assert_return(() => call($13, "load8_u", [21_093]), 0);
 
 // memory_copy.wast:1904
-assert_return(() => call($13, "load8_u", [13_133]), 0);
+assert_return(() => call($13, "load8_u", [21_292]), 0);
 
 // memory_copy.wast:1905
-assert_return(() => call($13, "load8_u", [13_332]), 0);
+assert_return(() => call($13, "load8_u", [21_491]), 0);
 
 // memory_copy.wast:1906
-assert_return(() => call($13, "load8_u", [13_531]), 0);
+assert_return(() => call($13, "load8_u", [21_690]), 0);
 
 // memory_copy.wast:1907
-assert_return(() => call($13, "load8_u", [13_730]), 0);
+assert_return(() => call($13, "load8_u", [21_889]), 0);
 
 // memory_copy.wast:1908
-assert_return(() => call($13, "load8_u", [13_929]), 0);
+assert_return(() => call($13, "load8_u", [22_088]), 0);
 
 // memory_copy.wast:1909
-assert_return(() => call($13, "load8_u", [14_128]), 0);
+assert_return(() => call($13, "load8_u", [22_287]), 0);
 
 // memory_copy.wast:1910
-assert_return(() => call($13, "load8_u", [14_327]), 0);
+assert_return(() => call($13, "load8_u", [22_486]), 0);
 
 // memory_copy.wast:1911
-assert_return(() => call($13, "load8_u", [14_526]), 0);
+assert_return(() => call($13, "load8_u", [22_685]), 0);
 
 // memory_copy.wast:1912
-assert_return(() => call($13, "load8_u", [14_725]), 0);
+assert_return(() => call($13, "load8_u", [22_884]), 0);
 
 // memory_copy.wast:1913
-assert_return(() => call($13, "load8_u", [14_924]), 0);
+assert_return(() => call($13, "load8_u", [23_083]), 0);
 
 // memory_copy.wast:1914
-assert_return(() => call($13, "load8_u", [15_123]), 0);
+assert_return(() => call($13, "load8_u", [23_282]), 0);
 
 // memory_copy.wast:1915
-assert_return(() => call($13, "load8_u", [15_322]), 0);
+assert_return(() => call($13, "load8_u", [23_481]), 0);
 
 // memory_copy.wast:1916
-assert_return(() => call($13, "load8_u", [15_521]), 0);
+assert_return(() => call($13, "load8_u", [23_680]), 0);
 
 // memory_copy.wast:1917
-assert_return(() => call($13, "load8_u", [15_720]), 0);
+assert_return(() => call($13, "load8_u", [23_879]), 0);
 
 // memory_copy.wast:1918
-assert_return(() => call($13, "load8_u", [15_919]), 0);
+assert_return(() => call($13, "load8_u", [24_078]), 0);
 
 // memory_copy.wast:1919
-assert_return(() => call($13, "load8_u", [16_118]), 0);
+assert_return(() => call($13, "load8_u", [24_277]), 0);
 
 // memory_copy.wast:1920
-assert_return(() => call($13, "load8_u", [16_317]), 0);
+assert_return(() => call($13, "load8_u", [24_476]), 0);
 
 // memory_copy.wast:1921
-assert_return(() => call($13, "load8_u", [16_516]), 0);
+assert_return(() => call($13, "load8_u", [24_675]), 0);
 
 // memory_copy.wast:1922
-assert_return(() => call($13, "load8_u", [16_715]), 0);
+assert_return(() => call($13, "load8_u", [24_874]), 0);
 
 // memory_copy.wast:1923
-assert_return(() => call($13, "load8_u", [16_914]), 0);
+assert_return(() => call($13, "load8_u", [25_073]), 0);
 
 // memory_copy.wast:1924
-assert_return(() => call($13, "load8_u", [17_113]), 0);
+assert_return(() => call($13, "load8_u", [25_272]), 0);
 
 // memory_copy.wast:1925
-assert_return(() => call($13, "load8_u", [17_312]), 0);
+assert_return(() => call($13, "load8_u", [25_471]), 0);
 
 // memory_copy.wast:1926
-assert_return(() => call($13, "load8_u", [17_511]), 0);
+assert_return(() => call($13, "load8_u", [25_670]), 0);
 
 // memory_copy.wast:1927
-assert_return(() => call($13, "load8_u", [17_710]), 0);
+assert_return(() => call($13, "load8_u", [25_869]), 0);
 
 // memory_copy.wast:1928
-assert_return(() => call($13, "load8_u", [17_909]), 0);
+assert_return(() => call($13, "load8_u", [26_068]), 0);
 
 // memory_copy.wast:1929
-assert_return(() => call($13, "load8_u", [18_108]), 0);
+assert_return(() => call($13, "load8_u", [26_267]), 0);
 
 // memory_copy.wast:1930
-assert_return(() => call($13, "load8_u", [18_307]), 0);
+assert_return(() => call($13, "load8_u", [26_466]), 0);
 
 // memory_copy.wast:1931
-assert_return(() => call($13, "load8_u", [18_506]), 0);
+assert_return(() => call($13, "load8_u", [26_665]), 0);
 
 // memory_copy.wast:1932
-assert_return(() => call($13, "load8_u", [18_705]), 0);
+assert_return(() => call($13, "load8_u", [26_864]), 0);
 
 // memory_copy.wast:1933
-assert_return(() => call($13, "load8_u", [18_904]), 0);
+assert_return(() => call($13, "load8_u", [27_063]), 0);
 
 // memory_copy.wast:1934
-assert_return(() => call($13, "load8_u", [19_103]), 0);
+assert_return(() => call($13, "load8_u", [27_262]), 0);
 
 // memory_copy.wast:1935
-assert_return(() => call($13, "load8_u", [19_302]), 0);
+assert_return(() => call($13, "load8_u", [27_461]), 0);
 
 // memory_copy.wast:1936
-assert_return(() => call($13, "load8_u", [19_501]), 0);
+assert_return(() => call($13, "load8_u", [27_660]), 0);
 
 // memory_copy.wast:1937
-assert_return(() => call($13, "load8_u", [19_700]), 0);
+assert_return(() => call($13, "load8_u", [27_859]), 0);
 
 // memory_copy.wast:1938
-assert_return(() => call($13, "load8_u", [19_899]), 0);
+assert_return(() => call($13, "load8_u", [28_058]), 0);
 
 // memory_copy.wast:1939
-assert_return(() => call($13, "load8_u", [20_098]), 0);
+assert_return(() => call($13, "load8_u", [28_257]), 0);
 
 // memory_copy.wast:1940
-assert_return(() => call($13, "load8_u", [20_297]), 0);
+assert_return(() => call($13, "load8_u", [28_456]), 0);
 
 // memory_copy.wast:1941
-assert_return(() => call($13, "load8_u", [20_496]), 0);
+assert_return(() => call($13, "load8_u", [28_655]), 0);
 
 // memory_copy.wast:1942
-assert_return(() => call($13, "load8_u", [20_695]), 0);
+assert_return(() => call($13, "load8_u", [28_854]), 0);
 
 // memory_copy.wast:1943
-assert_return(() => call($13, "load8_u", [20_894]), 0);
+assert_return(() => call($13, "load8_u", [29_053]), 0);
 
 // memory_copy.wast:1944
-assert_return(() => call($13, "load8_u", [21_093]), 0);
+assert_return(() => call($13, "load8_u", [29_252]), 0);
 
 // memory_copy.wast:1945
-assert_return(() => call($13, "load8_u", [21_292]), 0);
+assert_return(() => call($13, "load8_u", [29_451]), 0);
 
 // memory_copy.wast:1946
-assert_return(() => call($13, "load8_u", [21_491]), 0);
+assert_return(() => call($13, "load8_u", [29_650]), 0);
 
 // memory_copy.wast:1947
-assert_return(() => call($13, "load8_u", [21_690]), 0);
+assert_return(() => call($13, "load8_u", [29_849]), 0);
 
 // memory_copy.wast:1948
-assert_return(() => call($13, "load8_u", [21_889]), 0);
+assert_return(() => call($13, "load8_u", [30_048]), 0);
 
 // memory_copy.wast:1949
-assert_return(() => call($13, "load8_u", [22_088]), 0);
+assert_return(() => call($13, "load8_u", [30_247]), 0);
 
 // memory_copy.wast:1950
-assert_return(() => call($13, "load8_u", [22_287]), 0);
+assert_return(() => call($13, "load8_u", [30_446]), 0);
 
 // memory_copy.wast:1951
-assert_return(() => call($13, "load8_u", [22_486]), 0);
+assert_return(() => call($13, "load8_u", [30_645]), 0);
 
 // memory_copy.wast:1952
-assert_return(() => call($13, "load8_u", [22_685]), 0);
+assert_return(() => call($13, "load8_u", [30_844]), 0);
 
 // memory_copy.wast:1953
-assert_return(() => call($13, "load8_u", [22_884]), 0);
+assert_return(() => call($13, "load8_u", [31_043]), 0);
 
 // memory_copy.wast:1954
-assert_return(() => call($13, "load8_u", [23_083]), 0);
+assert_return(() => call($13, "load8_u", [31_242]), 0);
 
 // memory_copy.wast:1955
-assert_return(() => call($13, "load8_u", [23_282]), 0);
+assert_return(() => call($13, "load8_u", [31_441]), 0);
 
 // memory_copy.wast:1956
-assert_return(() => call($13, "load8_u", [23_481]), 0);
+assert_return(() => call($13, "load8_u", [31_640]), 0);
 
 // memory_copy.wast:1957
-assert_return(() => call($13, "load8_u", [23_680]), 0);
+assert_return(() => call($13, "load8_u", [31_839]), 0);
 
 // memory_copy.wast:1958
-assert_return(() => call($13, "load8_u", [23_879]), 0);
+assert_return(() => call($13, "load8_u", [32_038]), 0);
 
 // memory_copy.wast:1959
-assert_return(() => call($13, "load8_u", [24_078]), 0);
+assert_return(() => call($13, "load8_u", [32_237]), 0);
 
 // memory_copy.wast:1960
-assert_return(() => call($13, "load8_u", [24_277]), 0);
+assert_return(() => call($13, "load8_u", [32_436]), 0);
 
 // memory_copy.wast:1961
-assert_return(() => call($13, "load8_u", [24_476]), 0);
+assert_return(() => call($13, "load8_u", [32_635]), 0);
 
 // memory_copy.wast:1962
-assert_return(() => call($13, "load8_u", [24_675]), 0);
+assert_return(() => call($13, "load8_u", [32_834]), 0);
 
 // memory_copy.wast:1963
-assert_return(() => call($13, "load8_u", [24_874]), 0);
+assert_return(() => call($13, "load8_u", [33_033]), 0);
 
 // memory_copy.wast:1964
-assert_return(() => call($13, "load8_u", [25_073]), 0);
+assert_return(() => call($13, "load8_u", [33_232]), 0);
 
 // memory_copy.wast:1965
-assert_return(() => call($13, "load8_u", [25_272]), 0);
+assert_return(() => call($13, "load8_u", [33_431]), 0);
 
 // memory_copy.wast:1966
-assert_return(() => call($13, "load8_u", [25_471]), 0);
+assert_return(() => call($13, "load8_u", [33_630]), 0);
 
 // memory_copy.wast:1967
-assert_return(() => call($13, "load8_u", [25_670]), 0);
+assert_return(() => call($13, "load8_u", [33_829]), 0);
 
 // memory_copy.wast:1968
-assert_return(() => call($13, "load8_u", [25_869]), 0);
+assert_return(() => call($13, "load8_u", [34_028]), 0);
 
 // memory_copy.wast:1969
-assert_return(() => call($13, "load8_u", [26_068]), 0);
+assert_return(() => call($13, "load8_u", [34_227]), 0);
 
 // memory_copy.wast:1970
-assert_return(() => call($13, "load8_u", [26_267]), 0);
+assert_return(() => call($13, "load8_u", [34_426]), 0);
 
 // memory_copy.wast:1971
-assert_return(() => call($13, "load8_u", [26_466]), 0);
+assert_return(() => call($13, "load8_u", [34_625]), 0);
 
 // memory_copy.wast:1972
-assert_return(() => call($13, "load8_u", [26_665]), 0);
+assert_return(() => call($13, "load8_u", [34_824]), 0);
 
 // memory_copy.wast:1973
-assert_return(() => call($13, "load8_u", [26_864]), 0);
+assert_return(() => call($13, "load8_u", [35_023]), 0);
 
 // memory_copy.wast:1974
-assert_return(() => call($13, "load8_u", [27_063]), 0);
+assert_return(() => call($13, "load8_u", [35_222]), 0);
 
 // memory_copy.wast:1975
-assert_return(() => call($13, "load8_u", [27_262]), 0);
+assert_return(() => call($13, "load8_u", [35_421]), 0);
 
 // memory_copy.wast:1976
-assert_return(() => call($13, "load8_u", [27_461]), 0);
+assert_return(() => call($13, "load8_u", [35_620]), 0);
 
 // memory_copy.wast:1977
-assert_return(() => call($13, "load8_u", [27_660]), 0);
+assert_return(() => call($13, "load8_u", [35_819]), 0);
 
 // memory_copy.wast:1978
-assert_return(() => call($13, "load8_u", [27_859]), 0);
+assert_return(() => call($13, "load8_u", [36_018]), 0);
 
 // memory_copy.wast:1979
-assert_return(() => call($13, "load8_u", [28_058]), 0);
+assert_return(() => call($13, "load8_u", [36_217]), 0);
 
 // memory_copy.wast:1980
-assert_return(() => call($13, "load8_u", [28_257]), 0);
+assert_return(() => call($13, "load8_u", [36_416]), 0);
 
 // memory_copy.wast:1981
-assert_return(() => call($13, "load8_u", [28_456]), 0);
+assert_return(() => call($13, "load8_u", [36_615]), 0);
 
 // memory_copy.wast:1982
-assert_return(() => call($13, "load8_u", [28_655]), 0);
+assert_return(() => call($13, "load8_u", [36_814]), 0);
 
 // memory_copy.wast:1983
-assert_return(() => call($13, "load8_u", [28_854]), 0);
+assert_return(() => call($13, "load8_u", [37_013]), 0);
 
 // memory_copy.wast:1984
-assert_return(() => call($13, "load8_u", [29_053]), 0);
+assert_return(() => call($13, "load8_u", [37_212]), 0);
 
 // memory_copy.wast:1985
-assert_return(() => call($13, "load8_u", [29_252]), 0);
+assert_return(() => call($13, "load8_u", [37_411]), 0);
 
 // memory_copy.wast:1986
-assert_return(() => call($13, "load8_u", [29_451]), 0);
+assert_return(() => call($13, "load8_u", [37_610]), 0);
 
 // memory_copy.wast:1987
-assert_return(() => call($13, "load8_u", [29_650]), 0);
+assert_return(() => call($13, "load8_u", [37_809]), 0);
 
 // memory_copy.wast:1988
-assert_return(() => call($13, "load8_u", [29_849]), 0);
+assert_return(() => call($13, "load8_u", [38_008]), 0);
 
 // memory_copy.wast:1989
-assert_return(() => call($13, "load8_u", [30_048]), 0);
+assert_return(() => call($13, "load8_u", [38_207]), 0);
 
 // memory_copy.wast:1990
-assert_return(() => call($13, "load8_u", [30_247]), 0);
+assert_return(() => call($13, "load8_u", [38_406]), 0);
 
 // memory_copy.wast:1991
-assert_return(() => call($13, "load8_u", [30_446]), 0);
+assert_return(() => call($13, "load8_u", [38_605]), 0);
 
 // memory_copy.wast:1992
-assert_return(() => call($13, "load8_u", [30_645]), 0);
+assert_return(() => call($13, "load8_u", [38_804]), 0);
 
 // memory_copy.wast:1993
-assert_return(() => call($13, "load8_u", [30_844]), 0);
+assert_return(() => call($13, "load8_u", [39_003]), 0);
 
 // memory_copy.wast:1994
-assert_return(() => call($13, "load8_u", [31_043]), 0);
+assert_return(() => call($13, "load8_u", [39_202]), 0);
 
 // memory_copy.wast:1995
-assert_return(() => call($13, "load8_u", [31_242]), 0);
+assert_return(() => call($13, "load8_u", [39_401]), 0);
 
 // memory_copy.wast:1996
-assert_return(() => call($13, "load8_u", [31_441]), 0);
+assert_return(() => call($13, "load8_u", [39_600]), 0);
 
 // memory_copy.wast:1997
-assert_return(() => call($13, "load8_u", [31_640]), 0);
+assert_return(() => call($13, "load8_u", [39_799]), 0);
 
 // memory_copy.wast:1998
-assert_return(() => call($13, "load8_u", [31_839]), 0);
+assert_return(() => call($13, "load8_u", [39_998]), 0);
 
 // memory_copy.wast:1999
-assert_return(() => call($13, "load8_u", [32_038]), 0);
+assert_return(() => call($13, "load8_u", [40_197]), 0);
 
 // memory_copy.wast:2000
-assert_return(() => call($13, "load8_u", [32_237]), 0);
+assert_return(() => call($13, "load8_u", [40_396]), 0);
 
 // memory_copy.wast:2001
-assert_return(() => call($13, "load8_u", [32_436]), 0);
+assert_return(() => call($13, "load8_u", [40_595]), 0);
 
 // memory_copy.wast:2002
-assert_return(() => call($13, "load8_u", [32_635]), 0);
+assert_return(() => call($13, "load8_u", [40_794]), 0);
 
 // memory_copy.wast:2003
-assert_return(() => call($13, "load8_u", [32_834]), 0);
+assert_return(() => call($13, "load8_u", [40_993]), 0);
 
 // memory_copy.wast:2004
-assert_return(() => call($13, "load8_u", [33_033]), 0);
+assert_return(() => call($13, "load8_u", [41_192]), 0);
 
 // memory_copy.wast:2005
-assert_return(() => call($13, "load8_u", [33_232]), 0);
+assert_return(() => call($13, "load8_u", [41_391]), 0);
 
 // memory_copy.wast:2006
-assert_return(() => call($13, "load8_u", [33_431]), 0);
+assert_return(() => call($13, "load8_u", [41_590]), 0);
 
 // memory_copy.wast:2007
-assert_return(() => call($13, "load8_u", [33_630]), 0);
+assert_return(() => call($13, "load8_u", [41_789]), 0);
 
 // memory_copy.wast:2008
-assert_return(() => call($13, "load8_u", [33_829]), 0);
+assert_return(() => call($13, "load8_u", [41_988]), 0);
 
 // memory_copy.wast:2009
-assert_return(() => call($13, "load8_u", [34_028]), 0);
+assert_return(() => call($13, "load8_u", [42_187]), 0);
 
 // memory_copy.wast:2010
-assert_return(() => call($13, "load8_u", [34_227]), 0);
+assert_return(() => call($13, "load8_u", [42_386]), 0);
 
 // memory_copy.wast:2011
-assert_return(() => call($13, "load8_u", [34_426]), 0);
+assert_return(() => call($13, "load8_u", [42_585]), 0);
 
 // memory_copy.wast:2012
-assert_return(() => call($13, "load8_u", [34_625]), 0);
+assert_return(() => call($13, "load8_u", [42_784]), 0);
 
 // memory_copy.wast:2013
-assert_return(() => call($13, "load8_u", [34_824]), 0);
+assert_return(() => call($13, "load8_u", [42_983]), 0);
 
 // memory_copy.wast:2014
-assert_return(() => call($13, "load8_u", [35_023]), 0);
+assert_return(() => call($13, "load8_u", [43_182]), 0);
 
 // memory_copy.wast:2015
-assert_return(() => call($13, "load8_u", [35_222]), 0);
+assert_return(() => call($13, "load8_u", [43_381]), 0);
 
 // memory_copy.wast:2016
-assert_return(() => call($13, "load8_u", [35_421]), 0);
+assert_return(() => call($13, "load8_u", [43_580]), 0);
 
 // memory_copy.wast:2017
-assert_return(() => call($13, "load8_u", [35_620]), 0);
+assert_return(() => call($13, "load8_u", [43_779]), 0);
 
 // memory_copy.wast:2018
-assert_return(() => call($13, "load8_u", [35_819]), 0);
+assert_return(() => call($13, "load8_u", [43_978]), 0);
 
 // memory_copy.wast:2019
-assert_return(() => call($13, "load8_u", [36_018]), 0);
+assert_return(() => call($13, "load8_u", [44_177]), 0);
 
 // memory_copy.wast:2020
-assert_return(() => call($13, "load8_u", [36_217]), 0);
+assert_return(() => call($13, "load8_u", [44_376]), 0);
 
 // memory_copy.wast:2021
-assert_return(() => call($13, "load8_u", [36_416]), 0);
+assert_return(() => call($13, "load8_u", [44_575]), 0);
 
 // memory_copy.wast:2022
-assert_return(() => call($13, "load8_u", [36_615]), 0);
+assert_return(() => call($13, "load8_u", [44_774]), 0);
 
 // memory_copy.wast:2023
-assert_return(() => call($13, "load8_u", [36_814]), 0);
+assert_return(() => call($13, "load8_u", [44_973]), 0);
 
 // memory_copy.wast:2024
-assert_return(() => call($13, "load8_u", [37_013]), 0);
+assert_return(() => call($13, "load8_u", [45_172]), 0);
 
 // memory_copy.wast:2025
-assert_return(() => call($13, "load8_u", [37_212]), 0);
+assert_return(() => call($13, "load8_u", [45_371]), 0);
 
 // memory_copy.wast:2026
-assert_return(() => call($13, "load8_u", [37_411]), 0);
+assert_return(() => call($13, "load8_u", [45_570]), 0);
 
 // memory_copy.wast:2027
-assert_return(() => call($13, "load8_u", [37_610]), 0);
+assert_return(() => call($13, "load8_u", [45_769]), 0);
 
 // memory_copy.wast:2028
-assert_return(() => call($13, "load8_u", [37_809]), 0);
+assert_return(() => call($13, "load8_u", [45_968]), 0);
 
 // memory_copy.wast:2029
-assert_return(() => call($13, "load8_u", [38_008]), 0);
+assert_return(() => call($13, "load8_u", [46_167]), 0);
 
 // memory_copy.wast:2030
-assert_return(() => call($13, "load8_u", [38_207]), 0);
+assert_return(() => call($13, "load8_u", [46_366]), 0);
 
 // memory_copy.wast:2031
-assert_return(() => call($13, "load8_u", [38_406]), 0);
+assert_return(() => call($13, "load8_u", [46_565]), 0);
 
 // memory_copy.wast:2032
-assert_return(() => call($13, "load8_u", [38_605]), 0);
+assert_return(() => call($13, "load8_u", [46_764]), 0);
 
 // memory_copy.wast:2033
-assert_return(() => call($13, "load8_u", [38_804]), 0);
+assert_return(() => call($13, "load8_u", [46_963]), 0);
 
 // memory_copy.wast:2034
-assert_return(() => call($13, "load8_u", [39_003]), 0);
+assert_return(() => call($13, "load8_u", [47_162]), 0);
 
 // memory_copy.wast:2035
-assert_return(() => call($13, "load8_u", [39_202]), 0);
+assert_return(() => call($13, "load8_u", [47_361]), 0);
 
 // memory_copy.wast:2036
-assert_return(() => call($13, "load8_u", [39_401]), 0);
+assert_return(() => call($13, "load8_u", [47_560]), 0);
 
 // memory_copy.wast:2037
-assert_return(() => call($13, "load8_u", [39_600]), 0);
+assert_return(() => call($13, "load8_u", [47_759]), 0);
 
 // memory_copy.wast:2038
-assert_return(() => call($13, "load8_u", [39_799]), 0);
+assert_return(() => call($13, "load8_u", [47_958]), 0);
 
 // memory_copy.wast:2039
-assert_return(() => call($13, "load8_u", [39_998]), 0);
+assert_return(() => call($13, "load8_u", [48_157]), 0);
 
 // memory_copy.wast:2040
-assert_return(() => call($13, "load8_u", [40_197]), 0);
+assert_return(() => call($13, "load8_u", [48_356]), 0);
 
 // memory_copy.wast:2041
-assert_return(() => call($13, "load8_u", [40_396]), 0);
+assert_return(() => call($13, "load8_u", [48_555]), 0);
 
 // memory_copy.wast:2042
-assert_return(() => call($13, "load8_u", [40_595]), 0);
+assert_return(() => call($13, "load8_u", [48_754]), 0);
 
 // memory_copy.wast:2043
-assert_return(() => call($13, "load8_u", [40_794]), 0);
+assert_return(() => call($13, "load8_u", [48_953]), 0);
 
 // memory_copy.wast:2044
-assert_return(() => call($13, "load8_u", [40_993]), 0);
+assert_return(() => call($13, "load8_u", [49_152]), 0);
 
 // memory_copy.wast:2045
-assert_return(() => call($13, "load8_u", [41_192]), 0);
+assert_return(() => call($13, "load8_u", [49_351]), 0);
 
 // memory_copy.wast:2046
-assert_return(() => call($13, "load8_u", [41_391]), 0);
+assert_return(() => call($13, "load8_u", [49_550]), 0);
 
 // memory_copy.wast:2047
-assert_return(() => call($13, "load8_u", [41_590]), 0);
+assert_return(() => call($13, "load8_u", [49_749]), 0);
 
 // memory_copy.wast:2048
-assert_return(() => call($13, "load8_u", [41_789]), 0);
+assert_return(() => call($13, "load8_u", [49_948]), 0);
 
 // memory_copy.wast:2049
-assert_return(() => call($13, "load8_u", [41_988]), 0);
+assert_return(() => call($13, "load8_u", [50_147]), 0);
 
 // memory_copy.wast:2050
-assert_return(() => call($13, "load8_u", [42_187]), 0);
+assert_return(() => call($13, "load8_u", [50_346]), 0);
 
 // memory_copy.wast:2051
-assert_return(() => call($13, "load8_u", [42_386]), 0);
+assert_return(() => call($13, "load8_u", [50_545]), 0);
 
 // memory_copy.wast:2052
-assert_return(() => call($13, "load8_u", [42_585]), 0);
+assert_return(() => call($13, "load8_u", [50_744]), 0);
 
 // memory_copy.wast:2053
-assert_return(() => call($13, "load8_u", [42_784]), 0);
+assert_return(() => call($13, "load8_u", [50_943]), 0);
 
 // memory_copy.wast:2054
-assert_return(() => call($13, "load8_u", [42_983]), 0);
+assert_return(() => call($13, "load8_u", [51_142]), 0);
 
 // memory_copy.wast:2055
-assert_return(() => call($13, "load8_u", [43_182]), 0);
+assert_return(() => call($13, "load8_u", [51_341]), 0);
 
 // memory_copy.wast:2056
-assert_return(() => call($13, "load8_u", [43_381]), 0);
+assert_return(() => call($13, "load8_u", [51_540]), 0);
 
 // memory_copy.wast:2057
-assert_return(() => call($13, "load8_u", [43_580]), 0);
+assert_return(() => call($13, "load8_u", [51_739]), 0);
 
 // memory_copy.wast:2058
-assert_return(() => call($13, "load8_u", [43_779]), 0);
+assert_return(() => call($13, "load8_u", [51_938]), 0);
 
 // memory_copy.wast:2059
-assert_return(() => call($13, "load8_u", [43_978]), 0);
+assert_return(() => call($13, "load8_u", [52_137]), 0);
 
 // memory_copy.wast:2060
-assert_return(() => call($13, "load8_u", [44_177]), 0);
+assert_return(() => call($13, "load8_u", [52_336]), 0);
 
 // memory_copy.wast:2061
-assert_return(() => call($13, "load8_u", [44_376]), 0);
+assert_return(() => call($13, "load8_u", [52_535]), 0);
 
 // memory_copy.wast:2062
-assert_return(() => call($13, "load8_u", [44_575]), 0);
+assert_return(() => call($13, "load8_u", [52_734]), 0);
 
 // memory_copy.wast:2063
-assert_return(() => call($13, "load8_u", [44_774]), 0);
+assert_return(() => call($13, "load8_u", [52_933]), 0);
 
 // memory_copy.wast:2064
-assert_return(() => call($13, "load8_u", [44_973]), 0);
+assert_return(() => call($13, "load8_u", [53_132]), 0);
 
 // memory_copy.wast:2065
-assert_return(() => call($13, "load8_u", [45_172]), 0);
+assert_return(() => call($13, "load8_u", [53_331]), 0);
 
 // memory_copy.wast:2066
-assert_return(() => call($13, "load8_u", [45_371]), 0);
+assert_return(() => call($13, "load8_u", [53_530]), 0);
 
 // memory_copy.wast:2067
-assert_return(() => call($13, "load8_u", [45_570]), 0);
+assert_return(() => call($13, "load8_u", [53_729]), 0);
 
 // memory_copy.wast:2068
-assert_return(() => call($13, "load8_u", [45_769]), 0);
+assert_return(() => call($13, "load8_u", [53_928]), 0);
 
 // memory_copy.wast:2069
-assert_return(() => call($13, "load8_u", [45_968]), 0);
+assert_return(() => call($13, "load8_u", [54_127]), 0);
 
 // memory_copy.wast:2070
-assert_return(() => call($13, "load8_u", [46_167]), 0);
+assert_return(() => call($13, "load8_u", [54_326]), 0);
 
 // memory_copy.wast:2071
-assert_return(() => call($13, "load8_u", [46_366]), 0);
+assert_return(() => call($13, "load8_u", [54_525]), 0);
 
 // memory_copy.wast:2072
-assert_return(() => call($13, "load8_u", [46_565]), 0);
+assert_return(() => call($13, "load8_u", [54_724]), 0);
 
 // memory_copy.wast:2073
-assert_return(() => call($13, "load8_u", [46_764]), 0);
+assert_return(() => call($13, "load8_u", [54_923]), 0);
 
 // memory_copy.wast:2074
-assert_return(() => call($13, "load8_u", [46_963]), 0);
+assert_return(() => call($13, "load8_u", [55_122]), 0);
 
 // memory_copy.wast:2075
-assert_return(() => call($13, "load8_u", [47_162]), 0);
+assert_return(() => call($13, "load8_u", [55_321]), 0);
 
 // memory_copy.wast:2076
-assert_return(() => call($13, "load8_u", [47_361]), 0);
+assert_return(() => call($13, "load8_u", [55_520]), 0);
 
 // memory_copy.wast:2077
-assert_return(() => call($13, "load8_u", [47_560]), 0);
+assert_return(() => call($13, "load8_u", [55_719]), 0);
 
 // memory_copy.wast:2078
-assert_return(() => call($13, "load8_u", [47_759]), 0);
+assert_return(() => call($13, "load8_u", [55_918]), 0);
 
 // memory_copy.wast:2079
-assert_return(() => call($13, "load8_u", [47_958]), 0);
+assert_return(() => call($13, "load8_u", [56_117]), 0);
 
 // memory_copy.wast:2080
-assert_return(() => call($13, "load8_u", [48_157]), 0);
+assert_return(() => call($13, "load8_u", [56_316]), 0);
 
 // memory_copy.wast:2081
-assert_return(() => call($13, "load8_u", [48_356]), 0);
+assert_return(() => call($13, "load8_u", [56_515]), 0);
 
 // memory_copy.wast:2082
-assert_return(() => call($13, "load8_u", [48_555]), 0);
+assert_return(() => call($13, "load8_u", [56_714]), 0);
 
 // memory_copy.wast:2083
-assert_return(() => call($13, "load8_u", [48_754]), 0);
+assert_return(() => call($13, "load8_u", [56_913]), 0);
 
 // memory_copy.wast:2084
-assert_return(() => call($13, "load8_u", [48_953]), 0);
+assert_return(() => call($13, "load8_u", [57_112]), 0);
 
 // memory_copy.wast:2085
-assert_return(() => call($13, "load8_u", [49_152]), 0);
+assert_return(() => call($13, "load8_u", [57_311]), 0);
 
 // memory_copy.wast:2086
-assert_return(() => call($13, "load8_u", [49_351]), 0);
+assert_return(() => call($13, "load8_u", [57_510]), 0);
 
 // memory_copy.wast:2087
-assert_return(() => call($13, "load8_u", [49_550]), 0);
+assert_return(() => call($13, "load8_u", [57_709]), 0);
 
 // memory_copy.wast:2088
-assert_return(() => call($13, "load8_u", [49_749]), 0);
+assert_return(() => call($13, "load8_u", [57_908]), 0);
 
 // memory_copy.wast:2089
-assert_return(() => call($13, "load8_u", [49_948]), 0);
+assert_return(() => call($13, "load8_u", [58_107]), 0);
 
 // memory_copy.wast:2090
-assert_return(() => call($13, "load8_u", [50_147]), 0);
+assert_return(() => call($13, "load8_u", [58_306]), 0);
 
 // memory_copy.wast:2091
-assert_return(() => call($13, "load8_u", [50_346]), 0);
+assert_return(() => call($13, "load8_u", [58_505]), 0);
 
 // memory_copy.wast:2092
-assert_return(() => call($13, "load8_u", [50_545]), 0);
+assert_return(() => call($13, "load8_u", [58_704]), 0);
 
 // memory_copy.wast:2093
-assert_return(() => call($13, "load8_u", [50_744]), 0);
+assert_return(() => call($13, "load8_u", [58_903]), 0);
 
 // memory_copy.wast:2094
-assert_return(() => call($13, "load8_u", [50_943]), 0);
+assert_return(() => call($13, "load8_u", [59_102]), 0);
 
 // memory_copy.wast:2095
-assert_return(() => call($13, "load8_u", [51_142]), 0);
+assert_return(() => call($13, "load8_u", [59_301]), 0);
 
 // memory_copy.wast:2096
-assert_return(() => call($13, "load8_u", [51_341]), 0);
+assert_return(() => call($13, "load8_u", [59_500]), 0);
 
 // memory_copy.wast:2097
-assert_return(() => call($13, "load8_u", [51_540]), 0);
+assert_return(() => call($13, "load8_u", [59_699]), 0);
 
 // memory_copy.wast:2098
-assert_return(() => call($13, "load8_u", [51_739]), 0);
+assert_return(() => call($13, "load8_u", [59_898]), 0);
 
 // memory_copy.wast:2099
-assert_return(() => call($13, "load8_u", [51_938]), 0);
+assert_return(() => call($13, "load8_u", [60_097]), 0);
 
 // memory_copy.wast:2100
-assert_return(() => call($13, "load8_u", [52_137]), 0);
+assert_return(() => call($13, "load8_u", [60_296]), 0);
 
 // memory_copy.wast:2101
-assert_return(() => call($13, "load8_u", [52_336]), 0);
+assert_return(() => call($13, "load8_u", [60_495]), 0);
 
 // memory_copy.wast:2102
-assert_return(() => call($13, "load8_u", [52_535]), 0);
+assert_return(() => call($13, "load8_u", [60_694]), 0);
 
 // memory_copy.wast:2103
-assert_return(() => call($13, "load8_u", [52_734]), 0);
+assert_return(() => call($13, "load8_u", [60_893]), 0);
 
 // memory_copy.wast:2104
-assert_return(() => call($13, "load8_u", [52_933]), 0);
+assert_return(() => call($13, "load8_u", [61_092]), 0);
 
 // memory_copy.wast:2105
-assert_return(() => call($13, "load8_u", [53_132]), 0);
+assert_return(() => call($13, "load8_u", [61_291]), 0);
 
 // memory_copy.wast:2106
-assert_return(() => call($13, "load8_u", [53_331]), 0);
+assert_return(() => call($13, "load8_u", [61_490]), 0);
 
 // memory_copy.wast:2107
-assert_return(() => call($13, "load8_u", [53_530]), 0);
+assert_return(() => call($13, "load8_u", [61_689]), 0);
 
 // memory_copy.wast:2108
-assert_return(() => call($13, "load8_u", [53_729]), 0);
+assert_return(() => call($13, "load8_u", [61_888]), 0);
 
 // memory_copy.wast:2109
-assert_return(() => call($13, "load8_u", [53_928]), 0);
+assert_return(() => call($13, "load8_u", [62_087]), 0);
 
 // memory_copy.wast:2110
-assert_return(() => call($13, "load8_u", [54_127]), 0);
+assert_return(() => call($13, "load8_u", [62_286]), 0);
 
 // memory_copy.wast:2111
-assert_return(() => call($13, "load8_u", [54_326]), 0);
+assert_return(() => call($13, "load8_u", [62_485]), 0);
 
 // memory_copy.wast:2112
-assert_return(() => call($13, "load8_u", [54_525]), 0);
+assert_return(() => call($13, "load8_u", [62_684]), 0);
 
 // memory_copy.wast:2113
-assert_return(() => call($13, "load8_u", [54_724]), 0);
+assert_return(() => call($13, "load8_u", [62_883]), 0);
 
 // memory_copy.wast:2114
-assert_return(() => call($13, "load8_u", [54_923]), 0);
+assert_return(() => call($13, "load8_u", [63_082]), 0);
 
 // memory_copy.wast:2115
-assert_return(() => call($13, "load8_u", [55_122]), 0);
+assert_return(() => call($13, "load8_u", [63_281]), 0);
 
 // memory_copy.wast:2116
-assert_return(() => call($13, "load8_u", [55_321]), 0);
+assert_return(() => call($13, "load8_u", [63_480]), 0);
 
 // memory_copy.wast:2117
-assert_return(() => call($13, "load8_u", [55_520]), 0);
+assert_return(() => call($13, "load8_u", [63_679]), 0);
 
 // memory_copy.wast:2118
-assert_return(() => call($13, "load8_u", [55_719]), 0);
+assert_return(() => call($13, "load8_u", [63_878]), 0);
 
 // memory_copy.wast:2119
-assert_return(() => call($13, "load8_u", [55_918]), 0);
+assert_return(() => call($13, "load8_u", [64_077]), 0);
 
 // memory_copy.wast:2120
-assert_return(() => call($13, "load8_u", [56_117]), 0);
+assert_return(() => call($13, "load8_u", [64_276]), 0);
 
 // memory_copy.wast:2121
-assert_return(() => call($13, "load8_u", [56_316]), 0);
+assert_return(() => call($13, "load8_u", [64_475]), 0);
 
 // memory_copy.wast:2122
-assert_return(() => call($13, "load8_u", [56_515]), 0);
+assert_return(() => call($13, "load8_u", [64_674]), 0);
 
 // memory_copy.wast:2123
-assert_return(() => call($13, "load8_u", [56_714]), 0);
+assert_return(() => call($13, "load8_u", [64_873]), 0);
 
 // memory_copy.wast:2124
-assert_return(() => call($13, "load8_u", [56_913]), 0);
+assert_return(() => call($13, "load8_u", [65_072]), 0);
 
 // memory_copy.wast:2125
-assert_return(() => call($13, "load8_u", [57_112]), 0);
+assert_return(() => call($13, "load8_u", [65_271]), 0);
 
 // memory_copy.wast:2126
-assert_return(() => call($13, "load8_u", [57_311]), 0);
+assert_return(() => call($13, "load8_u", [65_470]), 0);
 
 // memory_copy.wast:2127
-assert_return(() => call($13, "load8_u", [57_510]), 0);
+assert_return(() => call($13, "load8_u", [65_486]), 0);
 
 // memory_copy.wast:2128
-assert_return(() => call($13, "load8_u", [57_709]), 0);
+assert_return(() => call($13, "load8_u", [65_487]), 1);
 
 // memory_copy.wast:2129
-assert_return(() => call($13, "load8_u", [57_908]), 0);
+assert_return(() => call($13, "load8_u", [65_488]), 2);
 
 // memory_copy.wast:2130
-assert_return(() => call($13, "load8_u", [58_107]), 0);
+assert_return(() => call($13, "load8_u", [65_489]), 3);
 
 // memory_copy.wast:2131
-assert_return(() => call($13, "load8_u", [58_306]), 0);
+assert_return(() => call($13, "load8_u", [65_490]), 4);
 
 // memory_copy.wast:2132
-assert_return(() => call($13, "load8_u", [58_505]), 0);
+assert_return(() => call($13, "load8_u", [65_491]), 5);
 
 // memory_copy.wast:2133
-assert_return(() => call($13, "load8_u", [58_704]), 0);
+assert_return(() => call($13, "load8_u", [65_492]), 6);
 
 // memory_copy.wast:2134
-assert_return(() => call($13, "load8_u", [58_903]), 0);
+assert_return(() => call($13, "load8_u", [65_493]), 7);
 
 // memory_copy.wast:2135
-assert_return(() => call($13, "load8_u", [59_102]), 0);
+assert_return(() => call($13, "load8_u", [65_494]), 8);
 
 // memory_copy.wast:2136
-assert_return(() => call($13, "load8_u", [59_301]), 0);
+assert_return(() => call($13, "load8_u", [65_495]), 9);
 
 // memory_copy.wast:2137
-assert_return(() => call($13, "load8_u", [59_500]), 0);
+assert_return(() => call($13, "load8_u", [65_496]), 10);
 
 // memory_copy.wast:2138
-assert_return(() => call($13, "load8_u", [59_699]), 0);
+assert_return(() => call($13, "load8_u", [65_497]), 11);
 
 // memory_copy.wast:2139
-assert_return(() => call($13, "load8_u", [59_898]), 0);
+assert_return(() => call($13, "load8_u", [65_498]), 12);
 
 // memory_copy.wast:2140
-assert_return(() => call($13, "load8_u", [60_097]), 0);
+assert_return(() => call($13, "load8_u", [65_499]), 13);
 
 // memory_copy.wast:2141
-assert_return(() => call($13, "load8_u", [60_296]), 0);
+assert_return(() => call($13, "load8_u", [65_500]), 14);
 
 // memory_copy.wast:2142
-assert_return(() => call($13, "load8_u", [60_495]), 0);
+assert_return(() => call($13, "load8_u", [65_501]), 15);
 
 // memory_copy.wast:2143
-assert_return(() => call($13, "load8_u", [60_694]), 0);
+assert_return(() => call($13, "load8_u", [65_502]), 16);
 
 // memory_copy.wast:2144
-assert_return(() => call($13, "load8_u", [60_893]), 0);
+assert_return(() => call($13, "load8_u", [65_503]), 17);
 
 // memory_copy.wast:2145
-assert_return(() => call($13, "load8_u", [61_092]), 0);
+assert_return(() => call($13, "load8_u", [65_504]), 18);
 
 // memory_copy.wast:2146
-assert_return(() => call($13, "load8_u", [61_291]), 0);
-
-// memory_copy.wast:2147
-assert_return(() => call($13, "load8_u", [61_490]), 0);
+assert_return(() => call($13, "load8_u", [65_505]), 19);
 
 // memory_copy.wast:2148
-assert_return(() => call($13, "load8_u", [61_689]), 0);
-
-// memory_copy.wast:2149
-assert_return(() => call($13, "load8_u", [61_888]), 0);
-
-// memory_copy.wast:2150
-assert_return(() => call($13, "load8_u", [62_087]), 0);
-
-// memory_copy.wast:2151
-assert_return(() => call($13, "load8_u", [62_286]), 0);
-
-// memory_copy.wast:2152
-assert_return(() => call($13, "load8_u", [62_485]), 0);
-
-// memory_copy.wast:2153
-assert_return(() => call($13, "load8_u", [62_684]), 0);
-
-// memory_copy.wast:2154
-assert_return(() => call($13, "load8_u", [62_883]), 0);
-
-// memory_copy.wast:2155
-assert_return(() => call($13, "load8_u", [63_082]), 0);
+let $14 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8c\x80\x80\x80\x00\x02\x60\x03\x7f\x7f\x7f\x00\x60\x01\x7f\x01\x7f\x03\x83\x80\x80\x80\x00\x02\x00\x01\x05\x84\x80\x80\x80\x00\x01\x01\x01\x01\x07\x97\x80\x80\x80\x00\x03\x03\x6d\x65\x6d\x02\x00\x03\x72\x75\x6e\x00\x00\x07\x6c\x6f\x61\x64\x38\x5f\x75\x00\x01\x0a\x9e\x80\x80\x80\x00\x02\x8c\x80\x80\x80\x00\x00\x20\x00\x20\x01\x20\x02\xfc\x0a\x00\x00\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x2d\x00\x00\x0b\x0b\x9c\x80\x80\x80\x00\x01\x00\x41\xec\xff\x03\x0b\x14\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10\x11\x12\x13");
 
 // memory_copy.wast:2156
-assert_return(() => call($13, "load8_u", [63_281]), 0);
-
-// memory_copy.wast:2157
-assert_return(() => call($13, "load8_u", [63_480]), 0);
-
-// memory_copy.wast:2158
-assert_return(() => call($13, "load8_u", [63_679]), 0);
+assert_trap(() => call($14, "run", [65_486, 65_516, 40]));
 
 // memory_copy.wast:2159
-assert_return(() => call($13, "load8_u", [63_878]), 0);
+assert_return(() => call($14, "load8_u", [198]), 0);
 
 // memory_copy.wast:2160
-assert_return(() => call($13, "load8_u", [64_077]), 0);
+assert_return(() => call($14, "load8_u", [397]), 0);
 
 // memory_copy.wast:2161
-assert_return(() => call($13, "load8_u", [64_276]), 0);
+assert_return(() => call($14, "load8_u", [596]), 0);
 
 // memory_copy.wast:2162
-assert_return(() => call($13, "load8_u", [64_475]), 0);
+assert_return(() => call($14, "load8_u", [795]), 0);
 
 // memory_copy.wast:2163
-assert_return(() => call($13, "load8_u", [64_674]), 0);
+assert_return(() => call($14, "load8_u", [994]), 0);
 
 // memory_copy.wast:2164
-assert_return(() => call($13, "load8_u", [64_873]), 0);
+assert_return(() => call($14, "load8_u", [1_193]), 0);
 
 // memory_copy.wast:2165
-assert_return(() => call($13, "load8_u", [65_072]), 0);
+assert_return(() => call($14, "load8_u", [1_392]), 0);
 
 // memory_copy.wast:2166
-assert_return(() => call($13, "load8_u", [65_271]), 0);
+assert_return(() => call($14, "load8_u", [1_591]), 0);
 
 // memory_copy.wast:2167
-assert_return(() => call($13, "load8_u", [65_470]), 0);
+assert_return(() => call($14, "load8_u", [1_790]), 0);
 
 // memory_copy.wast:2168
-assert_return(() => call($13, "load8_u", [65_486]), 0);
+assert_return(() => call($14, "load8_u", [1_989]), 0);
 
 // memory_copy.wast:2169
-assert_return(() => call($13, "load8_u", [65_487]), 1);
+assert_return(() => call($14, "load8_u", [2_188]), 0);
 
 // memory_copy.wast:2170
-assert_return(() => call($13, "load8_u", [65_488]), 2);
+assert_return(() => call($14, "load8_u", [2_387]), 0);
 
 // memory_copy.wast:2171
-assert_return(() => call($13, "load8_u", [65_489]), 3);
+assert_return(() => call($14, "load8_u", [2_586]), 0);
 
 // memory_copy.wast:2172
-assert_return(() => call($13, "load8_u", [65_490]), 4);
+assert_return(() => call($14, "load8_u", [2_785]), 0);
 
 // memory_copy.wast:2173
-assert_return(() => call($13, "load8_u", [65_491]), 5);
+assert_return(() => call($14, "load8_u", [2_984]), 0);
 
 // memory_copy.wast:2174
-assert_return(() => call($13, "load8_u", [65_492]), 6);
+assert_return(() => call($14, "load8_u", [3_183]), 0);
 
 // memory_copy.wast:2175
-assert_return(() => call($13, "load8_u", [65_493]), 7);
+assert_return(() => call($14, "load8_u", [3_382]), 0);
 
 // memory_copy.wast:2176
-assert_return(() => call($13, "load8_u", [65_494]), 8);
+assert_return(() => call($14, "load8_u", [3_581]), 0);
 
 // memory_copy.wast:2177
-assert_return(() => call($13, "load8_u", [65_495]), 9);
+assert_return(() => call($14, "load8_u", [3_780]), 0);
 
 // memory_copy.wast:2178
-assert_return(() => call($13, "load8_u", [65_496]), 10);
+assert_return(() => call($14, "load8_u", [3_979]), 0);
 
 // memory_copy.wast:2179
-assert_return(() => call($13, "load8_u", [65_497]), 11);
+assert_return(() => call($14, "load8_u", [4_178]), 0);
 
 // memory_copy.wast:2180
-assert_return(() => call($13, "load8_u", [65_498]), 12);
+assert_return(() => call($14, "load8_u", [4_377]), 0);
 
 // memory_copy.wast:2181
-assert_return(() => call($13, "load8_u", [65_499]), 13);
+assert_return(() => call($14, "load8_u", [4_576]), 0);
 
 // memory_copy.wast:2182
-assert_return(() => call($13, "load8_u", [65_500]), 14);
+assert_return(() => call($14, "load8_u", [4_775]), 0);
 
 // memory_copy.wast:2183
-assert_return(() => call($13, "load8_u", [65_501]), 15);
+assert_return(() => call($14, "load8_u", [4_974]), 0);
 
 // memory_copy.wast:2184
-assert_return(() => call($13, "load8_u", [65_502]), 16);
+assert_return(() => call($14, "load8_u", [5_173]), 0);
 
 // memory_copy.wast:2185
-assert_return(() => call($13, "load8_u", [65_503]), 17);
+assert_return(() => call($14, "load8_u", [5_372]), 0);
 
 // memory_copy.wast:2186
-assert_return(() => call($13, "load8_u", [65_504]), 18);
+assert_return(() => call($14, "load8_u", [5_571]), 0);
 
 // memory_copy.wast:2187
-assert_return(() => call($13, "load8_u", [65_505]), 19);
+assert_return(() => call($14, "load8_u", [5_770]), 0);
+
+// memory_copy.wast:2188
+assert_return(() => call($14, "load8_u", [5_969]), 0);
 
 // memory_copy.wast:2189
-let $14 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8c\x80\x80\x80\x00\x02\x60\x03\x7f\x7f\x7f\x00\x60\x01\x7f\x01\x7f\x03\x83\x80\x80\x80\x00\x02\x00\x01\x05\x84\x80\x80\x80\x00\x01\x01\x01\x01\x07\x97\x80\x80\x80\x00\x03\x03\x6d\x65\x6d\x02\x00\x03\x72\x75\x6e\x00\x00\x07\x6c\x6f\x61\x64\x38\x5f\x75\x00\x01\x0a\x9e\x80\x80\x80\x00\x02\x8c\x80\x80\x80\x00\x00\x20\x00\x20\x01\x20\x02\xfc\x0a\x00\x00\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x2d\x00\x00\x0b\x0b\x9c\x80\x80\x80\x00\x01\x00\x41\xec\xff\x03\x0b\x14\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10\x11\x12\x13");
+assert_return(() => call($14, "load8_u", [6_168]), 0);
+
+// memory_copy.wast:2190
+assert_return(() => call($14, "load8_u", [6_367]), 0);
+
+// memory_copy.wast:2191
+assert_return(() => call($14, "load8_u", [6_566]), 0);
+
+// memory_copy.wast:2192
+assert_return(() => call($14, "load8_u", [6_765]), 0);
+
+// memory_copy.wast:2193
+assert_return(() => call($14, "load8_u", [6_964]), 0);
+
+// memory_copy.wast:2194
+assert_return(() => call($14, "load8_u", [7_163]), 0);
+
+// memory_copy.wast:2195
+assert_return(() => call($14, "load8_u", [7_362]), 0);
+
+// memory_copy.wast:2196
+assert_return(() => call($14, "load8_u", [7_561]), 0);
 
 // memory_copy.wast:2197
-assert_trap(() => call($14, "run", [65_486, 65_516, 40]));
+assert_return(() => call($14, "load8_u", [7_760]), 0);
+
+// memory_copy.wast:2198
+assert_return(() => call($14, "load8_u", [7_959]), 0);
+
+// memory_copy.wast:2199
+assert_return(() => call($14, "load8_u", [8_158]), 0);
 
 // memory_copy.wast:2200
-assert_return(() => call($14, "load8_u", [198]), 0);
+assert_return(() => call($14, "load8_u", [8_357]), 0);
 
 // memory_copy.wast:2201
-assert_return(() => call($14, "load8_u", [397]), 0);
+assert_return(() => call($14, "load8_u", [8_556]), 0);
 
 // memory_copy.wast:2202
-assert_return(() => call($14, "load8_u", [596]), 0);
+assert_return(() => call($14, "load8_u", [8_755]), 0);
 
 // memory_copy.wast:2203
-assert_return(() => call($14, "load8_u", [795]), 0);
+assert_return(() => call($14, "load8_u", [8_954]), 0);
 
 // memory_copy.wast:2204
-assert_return(() => call($14, "load8_u", [994]), 0);
+assert_return(() => call($14, "load8_u", [9_153]), 0);
 
 // memory_copy.wast:2205
-assert_return(() => call($14, "load8_u", [1_193]), 0);
+assert_return(() => call($14, "load8_u", [9_352]), 0);
 
 // memory_copy.wast:2206
-assert_return(() => call($14, "load8_u", [1_392]), 0);
+assert_return(() => call($14, "load8_u", [9_551]), 0);
 
 // memory_copy.wast:2207
-assert_return(() => call($14, "load8_u", [1_591]), 0);
+assert_return(() => call($14, "load8_u", [9_750]), 0);
 
 // memory_copy.wast:2208
-assert_return(() => call($14, "load8_u", [1_790]), 0);
+assert_return(() => call($14, "load8_u", [9_949]), 0);
 
 // memory_copy.wast:2209
-assert_return(() => call($14, "load8_u", [1_989]), 0);
+assert_return(() => call($14, "load8_u", [10_148]), 0);
 
 // memory_copy.wast:2210
-assert_return(() => call($14, "load8_u", [2_188]), 0);
+assert_return(() => call($14, "load8_u", [10_347]), 0);
 
 // memory_copy.wast:2211
-assert_return(() => call($14, "load8_u", [2_387]), 0);
+assert_return(() => call($14, "load8_u", [10_546]), 0);
 
 // memory_copy.wast:2212
-assert_return(() => call($14, "load8_u", [2_586]), 0);
+assert_return(() => call($14, "load8_u", [10_745]), 0);
 
 // memory_copy.wast:2213
-assert_return(() => call($14, "load8_u", [2_785]), 0);
+assert_return(() => call($14, "load8_u", [10_944]), 0);
 
 // memory_copy.wast:2214
-assert_return(() => call($14, "load8_u", [2_984]), 0);
+assert_return(() => call($14, "load8_u", [11_143]), 0);
 
 // memory_copy.wast:2215
-assert_return(() => call($14, "load8_u", [3_183]), 0);
+assert_return(() => call($14, "load8_u", [11_342]), 0);
 
 // memory_copy.wast:2216
-assert_return(() => call($14, "load8_u", [3_382]), 0);
+assert_return(() => call($14, "load8_u", [11_541]), 0);
 
 // memory_copy.wast:2217
-assert_return(() => call($14, "load8_u", [3_581]), 0);
+assert_return(() => call($14, "load8_u", [11_740]), 0);
 
 // memory_copy.wast:2218
-assert_return(() => call($14, "load8_u", [3_780]), 0);
+assert_return(() => call($14, "load8_u", [11_939]), 0);
 
 // memory_copy.wast:2219
-assert_return(() => call($14, "load8_u", [3_979]), 0);
+assert_return(() => call($14, "load8_u", [12_138]), 0);
 
 // memory_copy.wast:2220
-assert_return(() => call($14, "load8_u", [4_178]), 0);
+assert_return(() => call($14, "load8_u", [12_337]), 0);
 
 // memory_copy.wast:2221
-assert_return(() => call($14, "load8_u", [4_377]), 0);
+assert_return(() => call($14, "load8_u", [12_536]), 0);
 
 // memory_copy.wast:2222
-assert_return(() => call($14, "load8_u", [4_576]), 0);
+assert_return(() => call($14, "load8_u", [12_735]), 0);
 
 // memory_copy.wast:2223
-assert_return(() => call($14, "load8_u", [4_775]), 0);
+assert_return(() => call($14, "load8_u", [12_934]), 0);
 
 // memory_copy.wast:2224
-assert_return(() => call($14, "load8_u", [4_974]), 0);
+assert_return(() => call($14, "load8_u", [13_133]), 0);
 
 // memory_copy.wast:2225
-assert_return(() => call($14, "load8_u", [5_173]), 0);
+assert_return(() => call($14, "load8_u", [13_332]), 0);
 
 // memory_copy.wast:2226
-assert_return(() => call($14, "load8_u", [5_372]), 0);
+assert_return(() => call($14, "load8_u", [13_531]), 0);
 
 // memory_copy.wast:2227
-assert_return(() => call($14, "load8_u", [5_571]), 0);
+assert_return(() => call($14, "load8_u", [13_730]), 0);
 
 // memory_copy.wast:2228
-assert_return(() => call($14, "load8_u", [5_770]), 0);
+assert_return(() => call($14, "load8_u", [13_929]), 0);
 
 // memory_copy.wast:2229
-assert_return(() => call($14, "load8_u", [5_969]), 0);
+assert_return(() => call($14, "load8_u", [14_128]), 0);
 
 // memory_copy.wast:2230
-assert_return(() => call($14, "load8_u", [6_168]), 0);
+assert_return(() => call($14, "load8_u", [14_327]), 0);
 
 // memory_copy.wast:2231
-assert_return(() => call($14, "load8_u", [6_367]), 0);
+assert_return(() => call($14, "load8_u", [14_526]), 0);
 
 // memory_copy.wast:2232
-assert_return(() => call($14, "load8_u", [6_566]), 0);
+assert_return(() => call($14, "load8_u", [14_725]), 0);
 
 // memory_copy.wast:2233
-assert_return(() => call($14, "load8_u", [6_765]), 0);
+assert_return(() => call($14, "load8_u", [14_924]), 0);
 
 // memory_copy.wast:2234
-assert_return(() => call($14, "load8_u", [6_964]), 0);
+assert_return(() => call($14, "load8_u", [15_123]), 0);
 
 // memory_copy.wast:2235
-assert_return(() => call($14, "load8_u", [7_163]), 0);
+assert_return(() => call($14, "load8_u", [15_322]), 0);
 
 // memory_copy.wast:2236
-assert_return(() => call($14, "load8_u", [7_362]), 0);
+assert_return(() => call($14, "load8_u", [15_521]), 0);
 
 // memory_copy.wast:2237
-assert_return(() => call($14, "load8_u", [7_561]), 0);
+assert_return(() => call($14, "load8_u", [15_720]), 0);
 
 // memory_copy.wast:2238
-assert_return(() => call($14, "load8_u", [7_760]), 0);
+assert_return(() => call($14, "load8_u", [15_919]), 0);
 
 // memory_copy.wast:2239
-assert_return(() => call($14, "load8_u", [7_959]), 0);
+assert_return(() => call($14, "load8_u", [16_118]), 0);
 
 // memory_copy.wast:2240
-assert_return(() => call($14, "load8_u", [8_158]), 0);
+assert_return(() => call($14, "load8_u", [16_317]), 0);
 
 // memory_copy.wast:2241
-assert_return(() => call($14, "load8_u", [8_357]), 0);
+assert_return(() => call($14, "load8_u", [16_516]), 0);
 
 // memory_copy.wast:2242
-assert_return(() => call($14, "load8_u", [8_556]), 0);
+assert_return(() => call($14, "load8_u", [16_715]), 0);
 
 // memory_copy.wast:2243
-assert_return(() => call($14, "load8_u", [8_755]), 0);
+assert_return(() => call($14, "load8_u", [16_914]), 0);
 
 // memory_copy.wast:2244
-assert_return(() => call($14, "load8_u", [8_954]), 0);
+assert_return(() => call($14, "load8_u", [17_113]), 0);
 
 // memory_copy.wast:2245
-assert_return(() => call($14, "load8_u", [9_153]), 0);
+assert_return(() => call($14, "load8_u", [17_312]), 0);
 
 // memory_copy.wast:2246
-assert_return(() => call($14, "load8_u", [9_352]), 0);
+assert_return(() => call($14, "load8_u", [17_511]), 0);
 
 // memory_copy.wast:2247
-assert_return(() => call($14, "load8_u", [9_551]), 0);
+assert_return(() => call($14, "load8_u", [17_710]), 0);
 
 // memory_copy.wast:2248
-assert_return(() => call($14, "load8_u", [9_750]), 0);
+assert_return(() => call($14, "load8_u", [17_909]), 0);
 
 // memory_copy.wast:2249
-assert_return(() => call($14, "load8_u", [9_949]), 0);
+assert_return(() => call($14, "load8_u", [18_108]), 0);
 
 // memory_copy.wast:2250
-assert_return(() => call($14, "load8_u", [10_148]), 0);
+assert_return(() => call($14, "load8_u", [18_307]), 0);
 
 // memory_copy.wast:2251
-assert_return(() => call($14, "load8_u", [10_347]), 0);
+assert_return(() => call($14, "load8_u", [18_506]), 0);
 
 // memory_copy.wast:2252
-assert_return(() => call($14, "load8_u", [10_546]), 0);
+assert_return(() => call($14, "load8_u", [18_705]), 0);
 
 // memory_copy.wast:2253
-assert_return(() => call($14, "load8_u", [10_745]), 0);
+assert_return(() => call($14, "load8_u", [18_904]), 0);
 
 // memory_copy.wast:2254
-assert_return(() => call($14, "load8_u", [10_944]), 0);
+assert_return(() => call($14, "load8_u", [19_103]), 0);
 
 // memory_copy.wast:2255
-assert_return(() => call($14, "load8_u", [11_143]), 0);
+assert_return(() => call($14, "load8_u", [19_302]), 0);
 
 // memory_copy.wast:2256
-assert_return(() => call($14, "load8_u", [11_342]), 0);
+assert_return(() => call($14, "load8_u", [19_501]), 0);
 
 // memory_copy.wast:2257
-assert_return(() => call($14, "load8_u", [11_541]), 0);
+assert_return(() => call($14, "load8_u", [19_700]), 0);
 
 // memory_copy.wast:2258
-assert_return(() => call($14, "load8_u", [11_740]), 0);
+assert_return(() => call($14, "load8_u", [19_899]), 0);
 
 // memory_copy.wast:2259
-assert_return(() => call($14, "load8_u", [11_939]), 0);
+assert_return(() => call($14, "load8_u", [20_098]), 0);
 
 // memory_copy.wast:2260
-assert_return(() => call($14, "load8_u", [12_138]), 0);
+assert_return(() => call($14, "load8_u", [20_297]), 0);
 
 // memory_copy.wast:2261
-assert_return(() => call($14, "load8_u", [12_337]), 0);
+assert_return(() => call($14, "load8_u", [20_496]), 0);
 
 // memory_copy.wast:2262
-assert_return(() => call($14, "load8_u", [12_536]), 0);
+assert_return(() => call($14, "load8_u", [20_695]), 0);
 
 // memory_copy.wast:2263
-assert_return(() => call($14, "load8_u", [12_735]), 0);
+assert_return(() => call($14, "load8_u", [20_894]), 0);
 
 // memory_copy.wast:2264
-assert_return(() => call($14, "load8_u", [12_934]), 0);
+assert_return(() => call($14, "load8_u", [21_093]), 0);
 
 // memory_copy.wast:2265
-assert_return(() => call($14, "load8_u", [13_133]), 0);
+assert_return(() => call($14, "load8_u", [21_292]), 0);
 
 // memory_copy.wast:2266
-assert_return(() => call($14, "load8_u", [13_332]), 0);
+assert_return(() => call($14, "load8_u", [21_491]), 0);
 
 // memory_copy.wast:2267
-assert_return(() => call($14, "load8_u", [13_531]), 0);
+assert_return(() => call($14, "load8_u", [21_690]), 0);
 
 // memory_copy.wast:2268
-assert_return(() => call($14, "load8_u", [13_730]), 0);
+assert_return(() => call($14, "load8_u", [21_889]), 0);
 
 // memory_copy.wast:2269
-assert_return(() => call($14, "load8_u", [13_929]), 0);
+assert_return(() => call($14, "load8_u", [22_088]), 0);
 
 // memory_copy.wast:2270
-assert_return(() => call($14, "load8_u", [14_128]), 0);
+assert_return(() => call($14, "load8_u", [22_287]), 0);
 
 // memory_copy.wast:2271
-assert_return(() => call($14, "load8_u", [14_327]), 0);
+assert_return(() => call($14, "load8_u", [22_486]), 0);
 
 // memory_copy.wast:2272
-assert_return(() => call($14, "load8_u", [14_526]), 0);
+assert_return(() => call($14, "load8_u", [22_685]), 0);
 
 // memory_copy.wast:2273
-assert_return(() => call($14, "load8_u", [14_725]), 0);
+assert_return(() => call($14, "load8_u", [22_884]), 0);
 
 // memory_copy.wast:2274
-assert_return(() => call($14, "load8_u", [14_924]), 0);
+assert_return(() => call($14, "load8_u", [23_083]), 0);
 
 // memory_copy.wast:2275
-assert_return(() => call($14, "load8_u", [15_123]), 0);
+assert_return(() => call($14, "load8_u", [23_282]), 0);
 
 // memory_copy.wast:2276
-assert_return(() => call($14, "load8_u", [15_322]), 0);
+assert_return(() => call($14, "load8_u", [23_481]), 0);
 
 // memory_copy.wast:2277
-assert_return(() => call($14, "load8_u", [15_521]), 0);
+assert_return(() => call($14, "load8_u", [23_680]), 0);
 
 // memory_copy.wast:2278
-assert_return(() => call($14, "load8_u", [15_720]), 0);
+assert_return(() => call($14, "load8_u", [23_879]), 0);
 
 // memory_copy.wast:2279
-assert_return(() => call($14, "load8_u", [15_919]), 0);
+assert_return(() => call($14, "load8_u", [24_078]), 0);
 
 // memory_copy.wast:2280
-assert_return(() => call($14, "load8_u", [16_118]), 0);
+assert_return(() => call($14, "load8_u", [24_277]), 0);
 
 // memory_copy.wast:2281
-assert_return(() => call($14, "load8_u", [16_317]), 0);
+assert_return(() => call($14, "load8_u", [24_476]), 0);
 
 // memory_copy.wast:2282
-assert_return(() => call($14, "load8_u", [16_516]), 0);
+assert_return(() => call($14, "load8_u", [24_675]), 0);
 
 // memory_copy.wast:2283
-assert_return(() => call($14, "load8_u", [16_715]), 0);
+assert_return(() => call($14, "load8_u", [24_874]), 0);
 
 // memory_copy.wast:2284
-assert_return(() => call($14, "load8_u", [16_914]), 0);
+assert_return(() => call($14, "load8_u", [25_073]), 0);
 
 // memory_copy.wast:2285
-assert_return(() => call($14, "load8_u", [17_113]), 0);
+assert_return(() => call($14, "load8_u", [25_272]), 0);
 
 // memory_copy.wast:2286
-assert_return(() => call($14, "load8_u", [17_312]), 0);
+assert_return(() => call($14, "load8_u", [25_471]), 0);
 
 // memory_copy.wast:2287
-assert_return(() => call($14, "load8_u", [17_511]), 0);
+assert_return(() => call($14, "load8_u", [25_670]), 0);
 
 // memory_copy.wast:2288
-assert_return(() => call($14, "load8_u", [17_710]), 0);
+assert_return(() => call($14, "load8_u", [25_869]), 0);
 
 // memory_copy.wast:2289
-assert_return(() => call($14, "load8_u", [17_909]), 0);
+assert_return(() => call($14, "load8_u", [26_068]), 0);
 
 // memory_copy.wast:2290
-assert_return(() => call($14, "load8_u", [18_108]), 0);
+assert_return(() => call($14, "load8_u", [26_267]), 0);
 
 // memory_copy.wast:2291
-assert_return(() => call($14, "load8_u", [18_307]), 0);
+assert_return(() => call($14, "load8_u", [26_466]), 0);
 
 // memory_copy.wast:2292
-assert_return(() => call($14, "load8_u", [18_506]), 0);
+assert_return(() => call($14, "load8_u", [26_665]), 0);
 
 // memory_copy.wast:2293
-assert_return(() => call($14, "load8_u", [18_705]), 0);
+assert_return(() => call($14, "load8_u", [26_864]), 0);
 
 // memory_copy.wast:2294
-assert_return(() => call($14, "load8_u", [18_904]), 0);
+assert_return(() => call($14, "load8_u", [27_063]), 0);
 
 // memory_copy.wast:2295
-assert_return(() => call($14, "load8_u", [19_103]), 0);
+assert_return(() => call($14, "load8_u", [27_262]), 0);
 
 // memory_copy.wast:2296
-assert_return(() => call($14, "load8_u", [19_302]), 0);
+assert_return(() => call($14, "load8_u", [27_461]), 0);
 
 // memory_copy.wast:2297
-assert_return(() => call($14, "load8_u", [19_501]), 0);
+assert_return(() => call($14, "load8_u", [27_660]), 0);
 
 // memory_copy.wast:2298
-assert_return(() => call($14, "load8_u", [19_700]), 0);
+assert_return(() => call($14, "load8_u", [27_859]), 0);
 
 // memory_copy.wast:2299
-assert_return(() => call($14, "load8_u", [19_899]), 0);
+assert_return(() => call($14, "load8_u", [28_058]), 0);
 
 // memory_copy.wast:2300
-assert_return(() => call($14, "load8_u", [20_098]), 0);
+assert_return(() => call($14, "load8_u", [28_257]), 0);
 
 // memory_copy.wast:2301
-assert_return(() => call($14, "load8_u", [20_297]), 0);
+assert_return(() => call($14, "load8_u", [28_456]), 0);
 
 // memory_copy.wast:2302
-assert_return(() => call($14, "load8_u", [20_496]), 0);
+assert_return(() => call($14, "load8_u", [28_655]), 0);
 
 // memory_copy.wast:2303
-assert_return(() => call($14, "load8_u", [20_695]), 0);
+assert_return(() => call($14, "load8_u", [28_854]), 0);
 
 // memory_copy.wast:2304
-assert_return(() => call($14, "load8_u", [20_894]), 0);
+assert_return(() => call($14, "load8_u", [29_053]), 0);
 
 // memory_copy.wast:2305
-assert_return(() => call($14, "load8_u", [21_093]), 0);
+assert_return(() => call($14, "load8_u", [29_252]), 0);
 
 // memory_copy.wast:2306
-assert_return(() => call($14, "load8_u", [21_292]), 0);
+assert_return(() => call($14, "load8_u", [29_451]), 0);
 
 // memory_copy.wast:2307
-assert_return(() => call($14, "load8_u", [21_491]), 0);
+assert_return(() => call($14, "load8_u", [29_650]), 0);
 
 // memory_copy.wast:2308
-assert_return(() => call($14, "load8_u", [21_690]), 0);
+assert_return(() => call($14, "load8_u", [29_849]), 0);
 
 // memory_copy.wast:2309
-assert_return(() => call($14, "load8_u", [21_889]), 0);
+assert_return(() => call($14, "load8_u", [30_048]), 0);
 
 // memory_copy.wast:2310
-assert_return(() => call($14, "load8_u", [22_088]), 0);
+assert_return(() => call($14, "load8_u", [30_247]), 0);
 
 // memory_copy.wast:2311
-assert_return(() => call($14, "load8_u", [22_287]), 0);
+assert_return(() => call($14, "load8_u", [30_446]), 0);
 
 // memory_copy.wast:2312
-assert_return(() => call($14, "load8_u", [22_486]), 0);
+assert_return(() => call($14, "load8_u", [30_645]), 0);
 
 // memory_copy.wast:2313
-assert_return(() => call($14, "load8_u", [22_685]), 0);
+assert_return(() => call($14, "load8_u", [30_844]), 0);
 
 // memory_copy.wast:2314
-assert_return(() => call($14, "load8_u", [22_884]), 0);
+assert_return(() => call($14, "load8_u", [31_043]), 0);
 
 // memory_copy.wast:2315
-assert_return(() => call($14, "load8_u", [23_083]), 0);
+assert_return(() => call($14, "load8_u", [31_242]), 0);
 
 // memory_copy.wast:2316
-assert_return(() => call($14, "load8_u", [23_282]), 0);
+assert_return(() => call($14, "load8_u", [31_441]), 0);
 
 // memory_copy.wast:2317
-assert_return(() => call($14, "load8_u", [23_481]), 0);
+assert_return(() => call($14, "load8_u", [31_640]), 0);
 
 // memory_copy.wast:2318
-assert_return(() => call($14, "load8_u", [23_680]), 0);
+assert_return(() => call($14, "load8_u", [31_839]), 0);
 
 // memory_copy.wast:2319
-assert_return(() => call($14, "load8_u", [23_879]), 0);
+assert_return(() => call($14, "load8_u", [32_038]), 0);
 
 // memory_copy.wast:2320
-assert_return(() => call($14, "load8_u", [24_078]), 0);
+assert_return(() => call($14, "load8_u", [32_237]), 0);
 
 // memory_copy.wast:2321
-assert_return(() => call($14, "load8_u", [24_277]), 0);
+assert_return(() => call($14, "load8_u", [32_436]), 0);
 
 // memory_copy.wast:2322
-assert_return(() => call($14, "load8_u", [24_476]), 0);
+assert_return(() => call($14, "load8_u", [32_635]), 0);
 
 // memory_copy.wast:2323
-assert_return(() => call($14, "load8_u", [24_675]), 0);
+assert_return(() => call($14, "load8_u", [32_834]), 0);
 
 // memory_copy.wast:2324
-assert_return(() => call($14, "load8_u", [24_874]), 0);
+assert_return(() => call($14, "load8_u", [33_033]), 0);
 
 // memory_copy.wast:2325
-assert_return(() => call($14, "load8_u", [25_073]), 0);
+assert_return(() => call($14, "load8_u", [33_232]), 0);
 
 // memory_copy.wast:2326
-assert_return(() => call($14, "load8_u", [25_272]), 0);
+assert_return(() => call($14, "load8_u", [33_431]), 0);
 
 // memory_copy.wast:2327
-assert_return(() => call($14, "load8_u", [25_471]), 0);
+assert_return(() => call($14, "load8_u", [33_630]), 0);
 
 // memory_copy.wast:2328
-assert_return(() => call($14, "load8_u", [25_670]), 0);
+assert_return(() => call($14, "load8_u", [33_829]), 0);
 
 // memory_copy.wast:2329
-assert_return(() => call($14, "load8_u", [25_869]), 0);
+assert_return(() => call($14, "load8_u", [34_028]), 0);
 
 // memory_copy.wast:2330
-assert_return(() => call($14, "load8_u", [26_068]), 0);
+assert_return(() => call($14, "load8_u", [34_227]), 0);
 
 // memory_copy.wast:2331
-assert_return(() => call($14, "load8_u", [26_267]), 0);
+assert_return(() => call($14, "load8_u", [34_426]), 0);
 
 // memory_copy.wast:2332
-assert_return(() => call($14, "load8_u", [26_466]), 0);
+assert_return(() => call($14, "load8_u", [34_625]), 0);
 
 // memory_copy.wast:2333
-assert_return(() => call($14, "load8_u", [26_665]), 0);
+assert_return(() => call($14, "load8_u", [34_824]), 0);
 
 // memory_copy.wast:2334
-assert_return(() => call($14, "load8_u", [26_864]), 0);
+assert_return(() => call($14, "load8_u", [35_023]), 0);
 
 // memory_copy.wast:2335
-assert_return(() => call($14, "load8_u", [27_063]), 0);
+assert_return(() => call($14, "load8_u", [35_222]), 0);
 
 // memory_copy.wast:2336
-assert_return(() => call($14, "load8_u", [27_262]), 0);
+assert_return(() => call($14, "load8_u", [35_421]), 0);
 
 // memory_copy.wast:2337
-assert_return(() => call($14, "load8_u", [27_461]), 0);
+assert_return(() => call($14, "load8_u", [35_620]), 0);
 
 // memory_copy.wast:2338
-assert_return(() => call($14, "load8_u", [27_660]), 0);
+assert_return(() => call($14, "load8_u", [35_819]), 0);
 
 // memory_copy.wast:2339
-assert_return(() => call($14, "load8_u", [27_859]), 0);
+assert_return(() => call($14, "load8_u", [36_018]), 0);
 
 // memory_copy.wast:2340
-assert_return(() => call($14, "load8_u", [28_058]), 0);
+assert_return(() => call($14, "load8_u", [36_217]), 0);
 
 // memory_copy.wast:2341
-assert_return(() => call($14, "load8_u", [28_257]), 0);
+assert_return(() => call($14, "load8_u", [36_416]), 0);
 
 // memory_copy.wast:2342
-assert_return(() => call($14, "load8_u", [28_456]), 0);
+assert_return(() => call($14, "load8_u", [36_615]), 0);
 
 // memory_copy.wast:2343
-assert_return(() => call($14, "load8_u", [28_655]), 0);
+assert_return(() => call($14, "load8_u", [36_814]), 0);
 
 // memory_copy.wast:2344
-assert_return(() => call($14, "load8_u", [28_854]), 0);
+assert_return(() => call($14, "load8_u", [37_013]), 0);
 
 // memory_copy.wast:2345
-assert_return(() => call($14, "load8_u", [29_053]), 0);
+assert_return(() => call($14, "load8_u", [37_212]), 0);
 
 // memory_copy.wast:2346
-assert_return(() => call($14, "load8_u", [29_252]), 0);
+assert_return(() => call($14, "load8_u", [37_411]), 0);
 
 // memory_copy.wast:2347
-assert_return(() => call($14, "load8_u", [29_451]), 0);
+assert_return(() => call($14, "load8_u", [37_610]), 0);
 
 // memory_copy.wast:2348
-assert_return(() => call($14, "load8_u", [29_650]), 0);
+assert_return(() => call($14, "load8_u", [37_809]), 0);
 
 // memory_copy.wast:2349
-assert_return(() => call($14, "load8_u", [29_849]), 0);
+assert_return(() => call($14, "load8_u", [38_008]), 0);
 
 // memory_copy.wast:2350
-assert_return(() => call($14, "load8_u", [30_048]), 0);
+assert_return(() => call($14, "load8_u", [38_207]), 0);
 
 // memory_copy.wast:2351
-assert_return(() => call($14, "load8_u", [30_247]), 0);
+assert_return(() => call($14, "load8_u", [38_406]), 0);
 
 // memory_copy.wast:2352
-assert_return(() => call($14, "load8_u", [30_446]), 0);
+assert_return(() => call($14, "load8_u", [38_605]), 0);
 
 // memory_copy.wast:2353
-assert_return(() => call($14, "load8_u", [30_645]), 0);
+assert_return(() => call($14, "load8_u", [38_804]), 0);
 
 // memory_copy.wast:2354
-assert_return(() => call($14, "load8_u", [30_844]), 0);
+assert_return(() => call($14, "load8_u", [39_003]), 0);
 
 // memory_copy.wast:2355
-assert_return(() => call($14, "load8_u", [31_043]), 0);
+assert_return(() => call($14, "load8_u", [39_202]), 0);
 
 // memory_copy.wast:2356
-assert_return(() => call($14, "load8_u", [31_242]), 0);
+assert_return(() => call($14, "load8_u", [39_401]), 0);
 
 // memory_copy.wast:2357
-assert_return(() => call($14, "load8_u", [31_441]), 0);
+assert_return(() => call($14, "load8_u", [39_600]), 0);
 
 // memory_copy.wast:2358
-assert_return(() => call($14, "load8_u", [31_640]), 0);
+assert_return(() => call($14, "load8_u", [39_799]), 0);
 
 // memory_copy.wast:2359
-assert_return(() => call($14, "load8_u", [31_839]), 0);
+assert_return(() => call($14, "load8_u", [39_998]), 0);
 
 // memory_copy.wast:2360
-assert_return(() => call($14, "load8_u", [32_038]), 0);
+assert_return(() => call($14, "load8_u", [40_197]), 0);
 
 // memory_copy.wast:2361
-assert_return(() => call($14, "load8_u", [32_237]), 0);
+assert_return(() => call($14, "load8_u", [40_396]), 0);
 
 // memory_copy.wast:2362
-assert_return(() => call($14, "load8_u", [32_436]), 0);
+assert_return(() => call($14, "load8_u", [40_595]), 0);
 
 // memory_copy.wast:2363
-assert_return(() => call($14, "load8_u", [32_635]), 0);
+assert_return(() => call($14, "load8_u", [40_794]), 0);
 
 // memory_copy.wast:2364
-assert_return(() => call($14, "load8_u", [32_834]), 0);
+assert_return(() => call($14, "load8_u", [40_993]), 0);
 
 // memory_copy.wast:2365
-assert_return(() => call($14, "load8_u", [33_033]), 0);
+assert_return(() => call($14, "load8_u", [41_192]), 0);
 
 // memory_copy.wast:2366
-assert_return(() => call($14, "load8_u", [33_232]), 0);
+assert_return(() => call($14, "load8_u", [41_391]), 0);
 
 // memory_copy.wast:2367
-assert_return(() => call($14, "load8_u", [33_431]), 0);
+assert_return(() => call($14, "load8_u", [41_590]), 0);
 
 // memory_copy.wast:2368
-assert_return(() => call($14, "load8_u", [33_630]), 0);
+assert_return(() => call($14, "load8_u", [41_789]), 0);
 
 // memory_copy.wast:2369
-assert_return(() => call($14, "load8_u", [33_829]), 0);
+assert_return(() => call($14, "load8_u", [41_988]), 0);
 
 // memory_copy.wast:2370
-assert_return(() => call($14, "load8_u", [34_028]), 0);
+assert_return(() => call($14, "load8_u", [42_187]), 0);
 
 // memory_copy.wast:2371
-assert_return(() => call($14, "load8_u", [34_227]), 0);
+assert_return(() => call($14, "load8_u", [42_386]), 0);
 
 // memory_copy.wast:2372
-assert_return(() => call($14, "load8_u", [34_426]), 0);
+assert_return(() => call($14, "load8_u", [42_585]), 0);
 
 // memory_copy.wast:2373
-assert_return(() => call($14, "load8_u", [34_625]), 0);
+assert_return(() => call($14, "load8_u", [42_784]), 0);
 
 // memory_copy.wast:2374
-assert_return(() => call($14, "load8_u", [34_824]), 0);
+assert_return(() => call($14, "load8_u", [42_983]), 0);
 
 // memory_copy.wast:2375
-assert_return(() => call($14, "load8_u", [35_023]), 0);
+assert_return(() => call($14, "load8_u", [43_182]), 0);
 
 // memory_copy.wast:2376
-assert_return(() => call($14, "load8_u", [35_222]), 0);
+assert_return(() => call($14, "load8_u", [43_381]), 0);
 
 // memory_copy.wast:2377
-assert_return(() => call($14, "load8_u", [35_421]), 0);
+assert_return(() => call($14, "load8_u", [43_580]), 0);
 
 // memory_copy.wast:2378
-assert_return(() => call($14, "load8_u", [35_620]), 0);
+assert_return(() => call($14, "load8_u", [43_779]), 0);
 
 // memory_copy.wast:2379
-assert_return(() => call($14, "load8_u", [35_819]), 0);
+assert_return(() => call($14, "load8_u", [43_978]), 0);
 
 // memory_copy.wast:2380
-assert_return(() => call($14, "load8_u", [36_018]), 0);
+assert_return(() => call($14, "load8_u", [44_177]), 0);
 
 // memory_copy.wast:2381
-assert_return(() => call($14, "load8_u", [36_217]), 0);
+assert_return(() => call($14, "load8_u", [44_376]), 0);
 
 // memory_copy.wast:2382
-assert_return(() => call($14, "load8_u", [36_416]), 0);
+assert_return(() => call($14, "load8_u", [44_575]), 0);
 
 // memory_copy.wast:2383
-assert_return(() => call($14, "load8_u", [36_615]), 0);
+assert_return(() => call($14, "load8_u", [44_774]), 0);
 
 // memory_copy.wast:2384
-assert_return(() => call($14, "load8_u", [36_814]), 0);
+assert_return(() => call($14, "load8_u", [44_973]), 0);
 
 // memory_copy.wast:2385
-assert_return(() => call($14, "load8_u", [37_013]), 0);
+assert_return(() => call($14, "load8_u", [45_172]), 0);
 
 // memory_copy.wast:2386
-assert_return(() => call($14, "load8_u", [37_212]), 0);
+assert_return(() => call($14, "load8_u", [45_371]), 0);
 
 // memory_copy.wast:2387
-assert_return(() => call($14, "load8_u", [37_411]), 0);
+assert_return(() => call($14, "load8_u", [45_570]), 0);
 
 // memory_copy.wast:2388
-assert_return(() => call($14, "load8_u", [37_610]), 0);
+assert_return(() => call($14, "load8_u", [45_769]), 0);
 
 // memory_copy.wast:2389
-assert_return(() => call($14, "load8_u", [37_809]), 0);
+assert_return(() => call($14, "load8_u", [45_968]), 0);
 
 // memory_copy.wast:2390
-assert_return(() => call($14, "load8_u", [38_008]), 0);
+assert_return(() => call($14, "load8_u", [46_167]), 0);
 
 // memory_copy.wast:2391
-assert_return(() => call($14, "load8_u", [38_207]), 0);
+assert_return(() => call($14, "load8_u", [46_366]), 0);
 
 // memory_copy.wast:2392
-assert_return(() => call($14, "load8_u", [38_406]), 0);
+assert_return(() => call($14, "load8_u", [46_565]), 0);
 
 // memory_copy.wast:2393
-assert_return(() => call($14, "load8_u", [38_605]), 0);
+assert_return(() => call($14, "load8_u", [46_764]), 0);
 
 // memory_copy.wast:2394
-assert_return(() => call($14, "load8_u", [38_804]), 0);
+assert_return(() => call($14, "load8_u", [46_963]), 0);
 
 // memory_copy.wast:2395
-assert_return(() => call($14, "load8_u", [39_003]), 0);
+assert_return(() => call($14, "load8_u", [47_162]), 0);
 
 // memory_copy.wast:2396
-assert_return(() => call($14, "load8_u", [39_202]), 0);
+assert_return(() => call($14, "load8_u", [47_361]), 0);
 
 // memory_copy.wast:2397
-assert_return(() => call($14, "load8_u", [39_401]), 0);
+assert_return(() => call($14, "load8_u", [47_560]), 0);
 
 // memory_copy.wast:2398
-assert_return(() => call($14, "load8_u", [39_600]), 0);
+assert_return(() => call($14, "load8_u", [47_759]), 0);
 
 // memory_copy.wast:2399
-assert_return(() => call($14, "load8_u", [39_799]), 0);
+assert_return(() => call($14, "load8_u", [47_958]), 0);
 
 // memory_copy.wast:2400
-assert_return(() => call($14, "load8_u", [39_998]), 0);
+assert_return(() => call($14, "load8_u", [48_157]), 0);
 
 // memory_copy.wast:2401
-assert_return(() => call($14, "load8_u", [40_197]), 0);
+assert_return(() => call($14, "load8_u", [48_356]), 0);
 
 // memory_copy.wast:2402
-assert_return(() => call($14, "load8_u", [40_396]), 0);
+assert_return(() => call($14, "load8_u", [48_555]), 0);
 
 // memory_copy.wast:2403
-assert_return(() => call($14, "load8_u", [40_595]), 0);
+assert_return(() => call($14, "load8_u", [48_754]), 0);
 
 // memory_copy.wast:2404
-assert_return(() => call($14, "load8_u", [40_794]), 0);
+assert_return(() => call($14, "load8_u", [48_953]), 0);
 
 // memory_copy.wast:2405
-assert_return(() => call($14, "load8_u", [40_993]), 0);
+assert_return(() => call($14, "load8_u", [49_152]), 0);
 
 // memory_copy.wast:2406
-assert_return(() => call($14, "load8_u", [41_192]), 0);
+assert_return(() => call($14, "load8_u", [49_351]), 0);
 
 // memory_copy.wast:2407
-assert_return(() => call($14, "load8_u", [41_391]), 0);
+assert_return(() => call($14, "load8_u", [49_550]), 0);
 
 // memory_copy.wast:2408
-assert_return(() => call($14, "load8_u", [41_590]), 0);
+assert_return(() => call($14, "load8_u", [49_749]), 0);
 
 // memory_copy.wast:2409
-assert_return(() => call($14, "load8_u", [41_789]), 0);
+assert_return(() => call($14, "load8_u", [49_948]), 0);
 
 // memory_copy.wast:2410
-assert_return(() => call($14, "load8_u", [41_988]), 0);
+assert_return(() => call($14, "load8_u", [50_147]), 0);
 
 // memory_copy.wast:2411
-assert_return(() => call($14, "load8_u", [42_187]), 0);
+assert_return(() => call($14, "load8_u", [50_346]), 0);
 
 // memory_copy.wast:2412
-assert_return(() => call($14, "load8_u", [42_386]), 0);
+assert_return(() => call($14, "load8_u", [50_545]), 0);
 
 // memory_copy.wast:2413
-assert_return(() => call($14, "load8_u", [42_585]), 0);
+assert_return(() => call($14, "load8_u", [50_744]), 0);
 
 // memory_copy.wast:2414
-assert_return(() => call($14, "load8_u", [42_784]), 0);
+assert_return(() => call($14, "load8_u", [50_943]), 0);
 
 // memory_copy.wast:2415
-assert_return(() => call($14, "load8_u", [42_983]), 0);
+assert_return(() => call($14, "load8_u", [51_142]), 0);
 
 // memory_copy.wast:2416
-assert_return(() => call($14, "load8_u", [43_182]), 0);
+assert_return(() => call($14, "load8_u", [51_341]), 0);
 
 // memory_copy.wast:2417
-assert_return(() => call($14, "load8_u", [43_381]), 0);
+assert_return(() => call($14, "load8_u", [51_540]), 0);
 
 // memory_copy.wast:2418
-assert_return(() => call($14, "load8_u", [43_580]), 0);
+assert_return(() => call($14, "load8_u", [51_739]), 0);
 
 // memory_copy.wast:2419
-assert_return(() => call($14, "load8_u", [43_779]), 0);
+assert_return(() => call($14, "load8_u", [51_938]), 0);
 
 // memory_copy.wast:2420
-assert_return(() => call($14, "load8_u", [43_978]), 0);
+assert_return(() => call($14, "load8_u", [52_137]), 0);
 
 // memory_copy.wast:2421
-assert_return(() => call($14, "load8_u", [44_177]), 0);
+assert_return(() => call($14, "load8_u", [52_336]), 0);
 
 // memory_copy.wast:2422
-assert_return(() => call($14, "load8_u", [44_376]), 0);
+assert_return(() => call($14, "load8_u", [52_535]), 0);
 
 // memory_copy.wast:2423
-assert_return(() => call($14, "load8_u", [44_575]), 0);
+assert_return(() => call($14, "load8_u", [52_734]), 0);
 
 // memory_copy.wast:2424
-assert_return(() => call($14, "load8_u", [44_774]), 0);
+assert_return(() => call($14, "load8_u", [52_933]), 0);
 
 // memory_copy.wast:2425
-assert_return(() => call($14, "load8_u", [44_973]), 0);
+assert_return(() => call($14, "load8_u", [53_132]), 0);
 
 // memory_copy.wast:2426
-assert_return(() => call($14, "load8_u", [45_172]), 0);
+assert_return(() => call($14, "load8_u", [53_331]), 0);
 
 // memory_copy.wast:2427
-assert_return(() => call($14, "load8_u", [45_371]), 0);
+assert_return(() => call($14, "load8_u", [53_530]), 0);
 
 // memory_copy.wast:2428
-assert_return(() => call($14, "load8_u", [45_570]), 0);
+assert_return(() => call($14, "load8_u", [53_729]), 0);
 
 // memory_copy.wast:2429
-assert_return(() => call($14, "load8_u", [45_769]), 0);
+assert_return(() => call($14, "load8_u", [53_928]), 0);
 
 // memory_copy.wast:2430
-assert_return(() => call($14, "load8_u", [45_968]), 0);
+assert_return(() => call($14, "load8_u", [54_127]), 0);
 
 // memory_copy.wast:2431
-assert_return(() => call($14, "load8_u", [46_167]), 0);
+assert_return(() => call($14, "load8_u", [54_326]), 0);
 
 // memory_copy.wast:2432
-assert_return(() => call($14, "load8_u", [46_366]), 0);
+assert_return(() => call($14, "load8_u", [54_525]), 0);
 
 // memory_copy.wast:2433
-assert_return(() => call($14, "load8_u", [46_565]), 0);
+assert_return(() => call($14, "load8_u", [54_724]), 0);
 
 // memory_copy.wast:2434
-assert_return(() => call($14, "load8_u", [46_764]), 0);
+assert_return(() => call($14, "load8_u", [54_923]), 0);
 
 // memory_copy.wast:2435
-assert_return(() => call($14, "load8_u", [46_963]), 0);
+assert_return(() => call($14, "load8_u", [55_122]), 0);
 
 // memory_copy.wast:2436
-assert_return(() => call($14, "load8_u", [47_162]), 0);
+assert_return(() => call($14, "load8_u", [55_321]), 0);
 
 // memory_copy.wast:2437
-assert_return(() => call($14, "load8_u", [47_361]), 0);
+assert_return(() => call($14, "load8_u", [55_520]), 0);
 
 // memory_copy.wast:2438
-assert_return(() => call($14, "load8_u", [47_560]), 0);
+assert_return(() => call($14, "load8_u", [55_719]), 0);
 
 // memory_copy.wast:2439
-assert_return(() => call($14, "load8_u", [47_759]), 0);
+assert_return(() => call($14, "load8_u", [55_918]), 0);
 
 // memory_copy.wast:2440
-assert_return(() => call($14, "load8_u", [47_958]), 0);
+assert_return(() => call($14, "load8_u", [56_117]), 0);
 
 // memory_copy.wast:2441
-assert_return(() => call($14, "load8_u", [48_157]), 0);
+assert_return(() => call($14, "load8_u", [56_316]), 0);
 
 // memory_copy.wast:2442
-assert_return(() => call($14, "load8_u", [48_356]), 0);
+assert_return(() => call($14, "load8_u", [56_515]), 0);
 
 // memory_copy.wast:2443
-assert_return(() => call($14, "load8_u", [48_555]), 0);
+assert_return(() => call($14, "load8_u", [56_714]), 0);
 
 // memory_copy.wast:2444
-assert_return(() => call($14, "load8_u", [48_754]), 0);
+assert_return(() => call($14, "load8_u", [56_913]), 0);
 
 // memory_copy.wast:2445
-assert_return(() => call($14, "load8_u", [48_953]), 0);
+assert_return(() => call($14, "load8_u", [57_112]), 0);
 
 // memory_copy.wast:2446
-assert_return(() => call($14, "load8_u", [49_152]), 0);
+assert_return(() => call($14, "load8_u", [57_311]), 0);
 
 // memory_copy.wast:2447
-assert_return(() => call($14, "load8_u", [49_351]), 0);
+assert_return(() => call($14, "load8_u", [57_510]), 0);
 
 // memory_copy.wast:2448
-assert_return(() => call($14, "load8_u", [49_550]), 0);
+assert_return(() => call($14, "load8_u", [57_709]), 0);
 
 // memory_copy.wast:2449
-assert_return(() => call($14, "load8_u", [49_749]), 0);
+assert_return(() => call($14, "load8_u", [57_908]), 0);
 
 // memory_copy.wast:2450
-assert_return(() => call($14, "load8_u", [49_948]), 0);
+assert_return(() => call($14, "load8_u", [58_107]), 0);
 
 // memory_copy.wast:2451
-assert_return(() => call($14, "load8_u", [50_147]), 0);
+assert_return(() => call($14, "load8_u", [58_306]), 0);
 
 // memory_copy.wast:2452
-assert_return(() => call($14, "load8_u", [50_346]), 0);
+assert_return(() => call($14, "load8_u", [58_505]), 0);
 
 // memory_copy.wast:2453
-assert_return(() => call($14, "load8_u", [50_545]), 0);
+assert_return(() => call($14, "load8_u", [58_704]), 0);
 
 // memory_copy.wast:2454
-assert_return(() => call($14, "load8_u", [50_744]), 0);
+assert_return(() => call($14, "load8_u", [58_903]), 0);
 
 // memory_copy.wast:2455
-assert_return(() => call($14, "load8_u", [50_943]), 0);
+assert_return(() => call($14, "load8_u", [59_102]), 0);
 
 // memory_copy.wast:2456
-assert_return(() => call($14, "load8_u", [51_142]), 0);
+assert_return(() => call($14, "load8_u", [59_301]), 0);
 
 // memory_copy.wast:2457
-assert_return(() => call($14, "load8_u", [51_341]), 0);
+assert_return(() => call($14, "load8_u", [59_500]), 0);
 
 // memory_copy.wast:2458
-assert_return(() => call($14, "load8_u", [51_540]), 0);
+assert_return(() => call($14, "load8_u", [59_699]), 0);
 
 // memory_copy.wast:2459
-assert_return(() => call($14, "load8_u", [51_739]), 0);
+assert_return(() => call($14, "load8_u", [59_898]), 0);
 
 // memory_copy.wast:2460
-assert_return(() => call($14, "load8_u", [51_938]), 0);
+assert_return(() => call($14, "load8_u", [60_097]), 0);
 
 // memory_copy.wast:2461
-assert_return(() => call($14, "load8_u", [52_137]), 0);
+assert_return(() => call($14, "load8_u", [60_296]), 0);
 
 // memory_copy.wast:2462
-assert_return(() => call($14, "load8_u", [52_336]), 0);
+assert_return(() => call($14, "load8_u", [60_495]), 0);
 
 // memory_copy.wast:2463
-assert_return(() => call($14, "load8_u", [52_535]), 0);
+assert_return(() => call($14, "load8_u", [60_694]), 0);
 
 // memory_copy.wast:2464
-assert_return(() => call($14, "load8_u", [52_734]), 0);
+assert_return(() => call($14, "load8_u", [60_893]), 0);
 
 // memory_copy.wast:2465
-assert_return(() => call($14, "load8_u", [52_933]), 0);
+assert_return(() => call($14, "load8_u", [61_092]), 0);
 
 // memory_copy.wast:2466
-assert_return(() => call($14, "load8_u", [53_132]), 0);
+assert_return(() => call($14, "load8_u", [61_291]), 0);
 
 // memory_copy.wast:2467
-assert_return(() => call($14, "load8_u", [53_331]), 0);
+assert_return(() => call($14, "load8_u", [61_490]), 0);
 
 // memory_copy.wast:2468
-assert_return(() => call($14, "load8_u", [53_530]), 0);
+assert_return(() => call($14, "load8_u", [61_689]), 0);
 
 // memory_copy.wast:2469
-assert_return(() => call($14, "load8_u", [53_729]), 0);
+assert_return(() => call($14, "load8_u", [61_888]), 0);
 
 // memory_copy.wast:2470
-assert_return(() => call($14, "load8_u", [53_928]), 0);
+assert_return(() => call($14, "load8_u", [62_087]), 0);
 
 // memory_copy.wast:2471
-assert_return(() => call($14, "load8_u", [54_127]), 0);
+assert_return(() => call($14, "load8_u", [62_286]), 0);
 
 // memory_copy.wast:2472
-assert_return(() => call($14, "load8_u", [54_326]), 0);
+assert_return(() => call($14, "load8_u", [62_485]), 0);
 
 // memory_copy.wast:2473
-assert_return(() => call($14, "load8_u", [54_525]), 0);
+assert_return(() => call($14, "load8_u", [62_684]), 0);
 
 // memory_copy.wast:2474
-assert_return(() => call($14, "load8_u", [54_724]), 0);
+assert_return(() => call($14, "load8_u", [62_883]), 0);
 
 // memory_copy.wast:2475
-assert_return(() => call($14, "load8_u", [54_923]), 0);
+assert_return(() => call($14, "load8_u", [63_082]), 0);
 
 // memory_copy.wast:2476
-assert_return(() => call($14, "load8_u", [55_122]), 0);
+assert_return(() => call($14, "load8_u", [63_281]), 0);
 
 // memory_copy.wast:2477
-assert_return(() => call($14, "load8_u", [55_321]), 0);
+assert_return(() => call($14, "load8_u", [63_480]), 0);
 
 // memory_copy.wast:2478
-assert_return(() => call($14, "load8_u", [55_520]), 0);
+assert_return(() => call($14, "load8_u", [63_679]), 0);
 
 // memory_copy.wast:2479
-assert_return(() => call($14, "load8_u", [55_719]), 0);
+assert_return(() => call($14, "load8_u", [63_878]), 0);
 
 // memory_copy.wast:2480
-assert_return(() => call($14, "load8_u", [55_918]), 0);
+assert_return(() => call($14, "load8_u", [64_077]), 0);
 
 // memory_copy.wast:2481
-assert_return(() => call($14, "load8_u", [56_117]), 0);
+assert_return(() => call($14, "load8_u", [64_276]), 0);
 
 // memory_copy.wast:2482
-assert_return(() => call($14, "load8_u", [56_316]), 0);
+assert_return(() => call($14, "load8_u", [64_475]), 0);
 
 // memory_copy.wast:2483
-assert_return(() => call($14, "load8_u", [56_515]), 0);
+assert_return(() => call($14, "load8_u", [64_674]), 0);
 
 // memory_copy.wast:2484
-assert_return(() => call($14, "load8_u", [56_714]), 0);
+assert_return(() => call($14, "load8_u", [64_873]), 0);
 
 // memory_copy.wast:2485
-assert_return(() => call($14, "load8_u", [56_913]), 0);
+assert_return(() => call($14, "load8_u", [65_072]), 0);
 
 // memory_copy.wast:2486
-assert_return(() => call($14, "load8_u", [57_112]), 0);
+assert_return(() => call($14, "load8_u", [65_271]), 0);
 
 // memory_copy.wast:2487
-assert_return(() => call($14, "load8_u", [57_311]), 0);
+assert_return(() => call($14, "load8_u", [65_470]), 0);
 
 // memory_copy.wast:2488
-assert_return(() => call($14, "load8_u", [57_510]), 0);
+assert_return(() => call($14, "load8_u", [65_516]), 0);
 
 // memory_copy.wast:2489
-assert_return(() => call($14, "load8_u", [57_709]), 0);
+assert_return(() => call($14, "load8_u", [65_517]), 1);
 
 // memory_copy.wast:2490
-assert_return(() => call($14, "load8_u", [57_908]), 0);
+assert_return(() => call($14, "load8_u", [65_518]), 2);
 
 // memory_copy.wast:2491
-assert_return(() => call($14, "load8_u", [58_107]), 0);
+assert_return(() => call($14, "load8_u", [65_519]), 3);
 
 // memory_copy.wast:2492
-assert_return(() => call($14, "load8_u", [58_306]), 0);
+assert_return(() => call($14, "load8_u", [65_520]), 4);
 
 // memory_copy.wast:2493
-assert_return(() => call($14, "load8_u", [58_505]), 0);
+assert_return(() => call($14, "load8_u", [65_521]), 5);
 
 // memory_copy.wast:2494
-assert_return(() => call($14, "load8_u", [58_704]), 0);
+assert_return(() => call($14, "load8_u", [65_522]), 6);
 
 // memory_copy.wast:2495
-assert_return(() => call($14, "load8_u", [58_903]), 0);
+assert_return(() => call($14, "load8_u", [65_523]), 7);
 
 // memory_copy.wast:2496
-assert_return(() => call($14, "load8_u", [59_102]), 0);
+assert_return(() => call($14, "load8_u", [65_524]), 8);
 
 // memory_copy.wast:2497
-assert_return(() => call($14, "load8_u", [59_301]), 0);
+assert_return(() => call($14, "load8_u", [65_525]), 9);
 
 // memory_copy.wast:2498
-assert_return(() => call($14, "load8_u", [59_500]), 0);
+assert_return(() => call($14, "load8_u", [65_526]), 10);
 
 // memory_copy.wast:2499
-assert_return(() => call($14, "load8_u", [59_699]), 0);
+assert_return(() => call($14, "load8_u", [65_527]), 11);
 
 // memory_copy.wast:2500
-assert_return(() => call($14, "load8_u", [59_898]), 0);
+assert_return(() => call($14, "load8_u", [65_528]), 12);
 
 // memory_copy.wast:2501
-assert_return(() => call($14, "load8_u", [60_097]), 0);
+assert_return(() => call($14, "load8_u", [65_529]), 13);
 
 // memory_copy.wast:2502
-assert_return(() => call($14, "load8_u", [60_296]), 0);
+assert_return(() => call($14, "load8_u", [65_530]), 14);
 
 // memory_copy.wast:2503
-assert_return(() => call($14, "load8_u", [60_495]), 0);
+assert_return(() => call($14, "load8_u", [65_531]), 15);
 
 // memory_copy.wast:2504
-assert_return(() => call($14, "load8_u", [60_694]), 0);
+assert_return(() => call($14, "load8_u", [65_532]), 16);
 
 // memory_copy.wast:2505
-assert_return(() => call($14, "load8_u", [60_893]), 0);
+assert_return(() => call($14, "load8_u", [65_533]), 17);
 
 // memory_copy.wast:2506
-assert_return(() => call($14, "load8_u", [61_092]), 0);
+assert_return(() => call($14, "load8_u", [65_534]), 18);
 
 // memory_copy.wast:2507
-assert_return(() => call($14, "load8_u", [61_291]), 0);
-
-// memory_copy.wast:2508
-assert_return(() => call($14, "load8_u", [61_490]), 0);
+assert_return(() => call($14, "load8_u", [65_535]), 19);
 
 // memory_copy.wast:2509
-assert_return(() => call($14, "load8_u", [61_689]), 0);
-
-// memory_copy.wast:2510
-assert_return(() => call($14, "load8_u", [61_888]), 0);
-
-// memory_copy.wast:2511
-assert_return(() => call($14, "load8_u", [62_087]), 0);
-
-// memory_copy.wast:2512
-assert_return(() => call($14, "load8_u", [62_286]), 0);
-
-// memory_copy.wast:2513
-assert_return(() => call($14, "load8_u", [62_485]), 0);
-
-// memory_copy.wast:2514
-assert_return(() => call($14, "load8_u", [62_684]), 0);
-
-// memory_copy.wast:2515
-assert_return(() => call($14, "load8_u", [62_883]), 0);
-
-// memory_copy.wast:2516
-assert_return(() => call($14, "load8_u", [63_082]), 0);
+let $15 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8c\x80\x80\x80\x00\x02\x60\x03\x7f\x7f\x7f\x00\x60\x01\x7f\x01\x7f\x03\x83\x80\x80\x80\x00\x02\x00\x01\x05\x84\x80\x80\x80\x00\x01\x01\x01\x01\x07\x97\x80\x80\x80\x00\x03\x03\x6d\x65\x6d\x02\x00\x03\x72\x75\x6e\x00\x00\x07\x6c\x6f\x61\x64\x38\x5f\x75\x00\x01\x0a\x9e\x80\x80\x80\x00\x02\x8c\x80\x80\x80\x00\x00\x20\x00\x20\x01\x20\x02\xfc\x0a\x00\x00\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x2d\x00\x00\x0b\x0b\x9c\x80\x80\x80\x00\x01\x00\x41\xe2\xff\x03\x0b\x14\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10\x11\x12\x13");
 
 // memory_copy.wast:2517
-assert_return(() => call($14, "load8_u", [63_281]), 0);
-
-// memory_copy.wast:2518
-assert_return(() => call($14, "load8_u", [63_480]), 0);
-
-// memory_copy.wast:2519
-assert_return(() => call($14, "load8_u", [63_679]), 0);
+assert_trap(() => call($15, "run", [65_516, 65_506, 40]));
 
 // memory_copy.wast:2520
-assert_return(() => call($14, "load8_u", [63_878]), 0);
+assert_return(() => call($15, "load8_u", [198]), 0);
 
 // memory_copy.wast:2521
-assert_return(() => call($14, "load8_u", [64_077]), 0);
+assert_return(() => call($15, "load8_u", [397]), 0);
 
 // memory_copy.wast:2522
-assert_return(() => call($14, "load8_u", [64_276]), 0);
+assert_return(() => call($15, "load8_u", [596]), 0);
 
 // memory_copy.wast:2523
-assert_return(() => call($14, "load8_u", [64_475]), 0);
+assert_return(() => call($15, "load8_u", [795]), 0);
 
 // memory_copy.wast:2524
-assert_return(() => call($14, "load8_u", [64_674]), 0);
+assert_return(() => call($15, "load8_u", [994]), 0);
 
 // memory_copy.wast:2525
-assert_return(() => call($14, "load8_u", [64_873]), 0);
+assert_return(() => call($15, "load8_u", [1_193]), 0);
 
 // memory_copy.wast:2526
-assert_return(() => call($14, "load8_u", [65_072]), 0);
+assert_return(() => call($15, "load8_u", [1_392]), 0);
 
 // memory_copy.wast:2527
-assert_return(() => call($14, "load8_u", [65_271]), 0);
+assert_return(() => call($15, "load8_u", [1_591]), 0);
 
 // memory_copy.wast:2528
-assert_return(() => call($14, "load8_u", [65_470]), 0);
+assert_return(() => call($15, "load8_u", [1_790]), 0);
 
 // memory_copy.wast:2529
-assert_return(() => call($14, "load8_u", [65_486]), 0);
+assert_return(() => call($15, "load8_u", [1_989]), 0);
 
 // memory_copy.wast:2530
-assert_return(() => call($14, "load8_u", [65_487]), 1);
+assert_return(() => call($15, "load8_u", [2_188]), 0);
 
 // memory_copy.wast:2531
-assert_return(() => call($14, "load8_u", [65_488]), 2);
+assert_return(() => call($15, "load8_u", [2_387]), 0);
 
 // memory_copy.wast:2532
-assert_return(() => call($14, "load8_u", [65_489]), 3);
+assert_return(() => call($15, "load8_u", [2_586]), 0);
 
 // memory_copy.wast:2533
-assert_return(() => call($14, "load8_u", [65_490]), 4);
+assert_return(() => call($15, "load8_u", [2_785]), 0);
 
 // memory_copy.wast:2534
-assert_return(() => call($14, "load8_u", [65_491]), 5);
+assert_return(() => call($15, "load8_u", [2_984]), 0);
 
 // memory_copy.wast:2535
-assert_return(() => call($14, "load8_u", [65_492]), 6);
+assert_return(() => call($15, "load8_u", [3_183]), 0);
 
 // memory_copy.wast:2536
-assert_return(() => call($14, "load8_u", [65_493]), 7);
+assert_return(() => call($15, "load8_u", [3_382]), 0);
 
 // memory_copy.wast:2537
-assert_return(() => call($14, "load8_u", [65_494]), 8);
+assert_return(() => call($15, "load8_u", [3_581]), 0);
 
 // memory_copy.wast:2538
-assert_return(() => call($14, "load8_u", [65_495]), 9);
+assert_return(() => call($15, "load8_u", [3_780]), 0);
 
 // memory_copy.wast:2539
-assert_return(() => call($14, "load8_u", [65_496]), 10);
+assert_return(() => call($15, "load8_u", [3_979]), 0);
 
 // memory_copy.wast:2540
-assert_return(() => call($14, "load8_u", [65_497]), 11);
+assert_return(() => call($15, "load8_u", [4_178]), 0);
 
 // memory_copy.wast:2541
-assert_return(() => call($14, "load8_u", [65_498]), 12);
+assert_return(() => call($15, "load8_u", [4_377]), 0);
 
 // memory_copy.wast:2542
-assert_return(() => call($14, "load8_u", [65_499]), 13);
+assert_return(() => call($15, "load8_u", [4_576]), 0);
 
 // memory_copy.wast:2543
-assert_return(() => call($14, "load8_u", [65_500]), 14);
+assert_return(() => call($15, "load8_u", [4_775]), 0);
 
 // memory_copy.wast:2544
-assert_return(() => call($14, "load8_u", [65_501]), 15);
+assert_return(() => call($15, "load8_u", [4_974]), 0);
 
 // memory_copy.wast:2545
-assert_return(() => call($14, "load8_u", [65_502]), 16);
+assert_return(() => call($15, "load8_u", [5_173]), 0);
 
 // memory_copy.wast:2546
-assert_return(() => call($14, "load8_u", [65_503]), 17);
+assert_return(() => call($15, "load8_u", [5_372]), 0);
 
 // memory_copy.wast:2547
-assert_return(() => call($14, "load8_u", [65_504]), 18);
+assert_return(() => call($15, "load8_u", [5_571]), 0);
 
 // memory_copy.wast:2548
-assert_return(() => call($14, "load8_u", [65_505]), 19);
+assert_return(() => call($15, "load8_u", [5_770]), 0);
 
 // memory_copy.wast:2549
-assert_return(() => call($14, "load8_u", [65_516]), 0);
+assert_return(() => call($15, "load8_u", [5_969]), 0);
 
 // memory_copy.wast:2550
-assert_return(() => call($14, "load8_u", [65_517]), 1);
+assert_return(() => call($15, "load8_u", [6_168]), 0);
 
 // memory_copy.wast:2551
-assert_return(() => call($14, "load8_u", [65_518]), 2);
+assert_return(() => call($15, "load8_u", [6_367]), 0);
 
 // memory_copy.wast:2552
-assert_return(() => call($14, "load8_u", [65_519]), 3);
+assert_return(() => call($15, "load8_u", [6_566]), 0);
 
 // memory_copy.wast:2553
-assert_return(() => call($14, "load8_u", [65_520]), 4);
+assert_return(() => call($15, "load8_u", [6_765]), 0);
 
 // memory_copy.wast:2554
-assert_return(() => call($14, "load8_u", [65_521]), 5);
+assert_return(() => call($15, "load8_u", [6_964]), 0);
 
 // memory_copy.wast:2555
-assert_return(() => call($14, "load8_u", [65_522]), 6);
+assert_return(() => call($15, "load8_u", [7_163]), 0);
 
 // memory_copy.wast:2556
-assert_return(() => call($14, "load8_u", [65_523]), 7);
+assert_return(() => call($15, "load8_u", [7_362]), 0);
 
 // memory_copy.wast:2557
-assert_return(() => call($14, "load8_u", [65_524]), 8);
+assert_return(() => call($15, "load8_u", [7_561]), 0);
 
 // memory_copy.wast:2558
-assert_return(() => call($14, "load8_u", [65_525]), 9);
+assert_return(() => call($15, "load8_u", [7_760]), 0);
 
 // memory_copy.wast:2559
-assert_return(() => call($14, "load8_u", [65_526]), 10);
+assert_return(() => call($15, "load8_u", [7_959]), 0);
 
 // memory_copy.wast:2560
-assert_return(() => call($14, "load8_u", [65_527]), 11);
+assert_return(() => call($15, "load8_u", [8_158]), 0);
 
 // memory_copy.wast:2561
-assert_return(() => call($14, "load8_u", [65_528]), 12);
+assert_return(() => call($15, "load8_u", [8_357]), 0);
 
 // memory_copy.wast:2562
-assert_return(() => call($14, "load8_u", [65_529]), 13);
+assert_return(() => call($15, "load8_u", [8_556]), 0);
 
 // memory_copy.wast:2563
-assert_return(() => call($14, "load8_u", [65_530]), 14);
+assert_return(() => call($15, "load8_u", [8_755]), 0);
 
 // memory_copy.wast:2564
-assert_return(() => call($14, "load8_u", [65_531]), 15);
+assert_return(() => call($15, "load8_u", [8_954]), 0);
 
 // memory_copy.wast:2565
-assert_return(() => call($14, "load8_u", [65_532]), 16);
+assert_return(() => call($15, "load8_u", [9_153]), 0);
 
 // memory_copy.wast:2566
-assert_return(() => call($14, "load8_u", [65_533]), 17);
+assert_return(() => call($15, "load8_u", [9_352]), 0);
 
 // memory_copy.wast:2567
-assert_return(() => call($14, "load8_u", [65_534]), 18);
+assert_return(() => call($15, "load8_u", [9_551]), 0);
 
 // memory_copy.wast:2568
-assert_return(() => call($14, "load8_u", [65_535]), 19);
+assert_return(() => call($15, "load8_u", [9_750]), 0);
+
+// memory_copy.wast:2569
+assert_return(() => call($15, "load8_u", [9_949]), 0);
 
 // memory_copy.wast:2570
-let $15 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8c\x80\x80\x80\x00\x02\x60\x03\x7f\x7f\x7f\x00\x60\x01\x7f\x01\x7f\x03\x83\x80\x80\x80\x00\x02\x00\x01\x05\x84\x80\x80\x80\x00\x01\x01\x01\x01\x07\x97\x80\x80\x80\x00\x03\x03\x6d\x65\x6d\x02\x00\x03\x72\x75\x6e\x00\x00\x07\x6c\x6f\x61\x64\x38\x5f\x75\x00\x01\x0a\x9e\x80\x80\x80\x00\x02\x8c\x80\x80\x80\x00\x00\x20\x00\x20\x01\x20\x02\xfc\x0a\x00\x00\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x2d\x00\x00\x0b\x0b\x9c\x80\x80\x80\x00\x01\x00\x41\xe2\xff\x03\x0b\x14\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10\x11\x12\x13");
+assert_return(() => call($15, "load8_u", [10_148]), 0);
+
+// memory_copy.wast:2571
+assert_return(() => call($15, "load8_u", [10_347]), 0);
+
+// memory_copy.wast:2572
+assert_return(() => call($15, "load8_u", [10_546]), 0);
+
+// memory_copy.wast:2573
+assert_return(() => call($15, "load8_u", [10_745]), 0);
+
+// memory_copy.wast:2574
+assert_return(() => call($15, "load8_u", [10_944]), 0);
+
+// memory_copy.wast:2575
+assert_return(() => call($15, "load8_u", [11_143]), 0);
+
+// memory_copy.wast:2576
+assert_return(() => call($15, "load8_u", [11_342]), 0);
+
+// memory_copy.wast:2577
+assert_return(() => call($15, "load8_u", [11_541]), 0);
 
 // memory_copy.wast:2578
-assert_trap(() => call($15, "run", [65_516, 65_506, 40]));
+assert_return(() => call($15, "load8_u", [11_740]), 0);
+
+// memory_copy.wast:2579
+assert_return(() => call($15, "load8_u", [11_939]), 0);
+
+// memory_copy.wast:2580
+assert_return(() => call($15, "load8_u", [12_138]), 0);
 
 // memory_copy.wast:2581
-assert_return(() => call($15, "load8_u", [198]), 0);
+assert_return(() => call($15, "load8_u", [12_337]), 0);
 
 // memory_copy.wast:2582
-assert_return(() => call($15, "load8_u", [397]), 0);
+assert_return(() => call($15, "load8_u", [12_536]), 0);
 
 // memory_copy.wast:2583
-assert_return(() => call($15, "load8_u", [596]), 0);
+assert_return(() => call($15, "load8_u", [12_735]), 0);
 
 // memory_copy.wast:2584
-assert_return(() => call($15, "load8_u", [795]), 0);
+assert_return(() => call($15, "load8_u", [12_934]), 0);
 
 // memory_copy.wast:2585
-assert_return(() => call($15, "load8_u", [994]), 0);
+assert_return(() => call($15, "load8_u", [13_133]), 0);
 
 // memory_copy.wast:2586
-assert_return(() => call($15, "load8_u", [1_193]), 0);
+assert_return(() => call($15, "load8_u", [13_332]), 0);
 
 // memory_copy.wast:2587
-assert_return(() => call($15, "load8_u", [1_392]), 0);
+assert_return(() => call($15, "load8_u", [13_531]), 0);
 
 // memory_copy.wast:2588
-assert_return(() => call($15, "load8_u", [1_591]), 0);
+assert_return(() => call($15, "load8_u", [13_730]), 0);
 
 // memory_copy.wast:2589
-assert_return(() => call($15, "load8_u", [1_790]), 0);
+assert_return(() => call($15, "load8_u", [13_929]), 0);
 
 // memory_copy.wast:2590
-assert_return(() => call($15, "load8_u", [1_989]), 0);
+assert_return(() => call($15, "load8_u", [14_128]), 0);
 
 // memory_copy.wast:2591
-assert_return(() => call($15, "load8_u", [2_188]), 0);
+assert_return(() => call($15, "load8_u", [14_327]), 0);
 
 // memory_copy.wast:2592
-assert_return(() => call($15, "load8_u", [2_387]), 0);
+assert_return(() => call($15, "load8_u", [14_526]), 0);
 
 // memory_copy.wast:2593
-assert_return(() => call($15, "load8_u", [2_586]), 0);
+assert_return(() => call($15, "load8_u", [14_725]), 0);
 
 // memory_copy.wast:2594
-assert_return(() => call($15, "load8_u", [2_785]), 0);
+assert_return(() => call($15, "load8_u", [14_924]), 0);
 
 // memory_copy.wast:2595
-assert_return(() => call($15, "load8_u", [2_984]), 0);
+assert_return(() => call($15, "load8_u", [15_123]), 0);
 
 // memory_copy.wast:2596
-assert_return(() => call($15, "load8_u", [3_183]), 0);
+assert_return(() => call($15, "load8_u", [15_322]), 0);
 
 // memory_copy.wast:2597
-assert_return(() => call($15, "load8_u", [3_382]), 0);
+assert_return(() => call($15, "load8_u", [15_521]), 0);
 
 // memory_copy.wast:2598
-assert_return(() => call($15, "load8_u", [3_581]), 0);
+assert_return(() => call($15, "load8_u", [15_720]), 0);
 
 // memory_copy.wast:2599
-assert_return(() => call($15, "load8_u", [3_780]), 0);
+assert_return(() => call($15, "load8_u", [15_919]), 0);
 
 // memory_copy.wast:2600
-assert_return(() => call($15, "load8_u", [3_979]), 0);
+assert_return(() => call($15, "load8_u", [16_118]), 0);
 
 // memory_copy.wast:2601
-assert_return(() => call($15, "load8_u", [4_178]), 0);
+assert_return(() => call($15, "load8_u", [16_317]), 0);
 
 // memory_copy.wast:2602
-assert_return(() => call($15, "load8_u", [4_377]), 0);
+assert_return(() => call($15, "load8_u", [16_516]), 0);
 
 // memory_copy.wast:2603
-assert_return(() => call($15, "load8_u", [4_576]), 0);
+assert_return(() => call($15, "load8_u", [16_715]), 0);
 
 // memory_copy.wast:2604
-assert_return(() => call($15, "load8_u", [4_775]), 0);
+assert_return(() => call($15, "load8_u", [16_914]), 0);
 
 // memory_copy.wast:2605
-assert_return(() => call($15, "load8_u", [4_974]), 0);
+assert_return(() => call($15, "load8_u", [17_113]), 0);
 
 // memory_copy.wast:2606
-assert_return(() => call($15, "load8_u", [5_173]), 0);
+assert_return(() => call($15, "load8_u", [17_312]), 0);
 
 // memory_copy.wast:2607
-assert_return(() => call($15, "load8_u", [5_372]), 0);
+assert_return(() => call($15, "load8_u", [17_511]), 0);
 
 // memory_copy.wast:2608
-assert_return(() => call($15, "load8_u", [5_571]), 0);
+assert_return(() => call($15, "load8_u", [17_710]), 0);
 
 // memory_copy.wast:2609
-assert_return(() => call($15, "load8_u", [5_770]), 0);
+assert_return(() => call($15, "load8_u", [17_909]), 0);
 
 // memory_copy.wast:2610
-assert_return(() => call($15, "load8_u", [5_969]), 0);
+assert_return(() => call($15, "load8_u", [18_108]), 0);
 
 // memory_copy.wast:2611
-assert_return(() => call($15, "load8_u", [6_168]), 0);
+assert_return(() => call($15, "load8_u", [18_307]), 0);
 
 // memory_copy.wast:2612
-assert_return(() => call($15, "load8_u", [6_367]), 0);
+assert_return(() => call($15, "load8_u", [18_506]), 0);
 
 // memory_copy.wast:2613
-assert_return(() => call($15, "load8_u", [6_566]), 0);
+assert_return(() => call($15, "load8_u", [18_705]), 0);
 
 // memory_copy.wast:2614
-assert_return(() => call($15, "load8_u", [6_765]), 0);
+assert_return(() => call($15, "load8_u", [18_904]), 0);
 
 // memory_copy.wast:2615
-assert_return(() => call($15, "load8_u", [6_964]), 0);
+assert_return(() => call($15, "load8_u", [19_103]), 0);
 
 // memory_copy.wast:2616
-assert_return(() => call($15, "load8_u", [7_163]), 0);
+assert_return(() => call($15, "load8_u", [19_302]), 0);
 
 // memory_copy.wast:2617
-assert_return(() => call($15, "load8_u", [7_362]), 0);
+assert_return(() => call($15, "load8_u", [19_501]), 0);
 
 // memory_copy.wast:2618
-assert_return(() => call($15, "load8_u", [7_561]), 0);
+assert_return(() => call($15, "load8_u", [19_700]), 0);
 
 // memory_copy.wast:2619
-assert_return(() => call($15, "load8_u", [7_760]), 0);
+assert_return(() => call($15, "load8_u", [19_899]), 0);
 
 // memory_copy.wast:2620
-assert_return(() => call($15, "load8_u", [7_959]), 0);
+assert_return(() => call($15, "load8_u", [20_098]), 0);
 
 // memory_copy.wast:2621
-assert_return(() => call($15, "load8_u", [8_158]), 0);
+assert_return(() => call($15, "load8_u", [20_297]), 0);
 
 // memory_copy.wast:2622
-assert_return(() => call($15, "load8_u", [8_357]), 0);
+assert_return(() => call($15, "load8_u", [20_496]), 0);
 
 // memory_copy.wast:2623
-assert_return(() => call($15, "load8_u", [8_556]), 0);
+assert_return(() => call($15, "load8_u", [20_695]), 0);
 
 // memory_copy.wast:2624
-assert_return(() => call($15, "load8_u", [8_755]), 0);
+assert_return(() => call($15, "load8_u", [20_894]), 0);
 
 // memory_copy.wast:2625
-assert_return(() => call($15, "load8_u", [8_954]), 0);
+assert_return(() => call($15, "load8_u", [21_093]), 0);
 
 // memory_copy.wast:2626
-assert_return(() => call($15, "load8_u", [9_153]), 0);
+assert_return(() => call($15, "load8_u", [21_292]), 0);
 
 // memory_copy.wast:2627
-assert_return(() => call($15, "load8_u", [9_352]), 0);
+assert_return(() => call($15, "load8_u", [21_491]), 0);
 
 // memory_copy.wast:2628
-assert_return(() => call($15, "load8_u", [9_551]), 0);
+assert_return(() => call($15, "load8_u", [21_690]), 0);
 
 // memory_copy.wast:2629
-assert_return(() => call($15, "load8_u", [9_750]), 0);
+assert_return(() => call($15, "load8_u", [21_889]), 0);
 
 // memory_copy.wast:2630
-assert_return(() => call($15, "load8_u", [9_949]), 0);
+assert_return(() => call($15, "load8_u", [22_088]), 0);
 
 // memory_copy.wast:2631
-assert_return(() => call($15, "load8_u", [10_148]), 0);
+assert_return(() => call($15, "load8_u", [22_287]), 0);
 
 // memory_copy.wast:2632
-assert_return(() => call($15, "load8_u", [10_347]), 0);
+assert_return(() => call($15, "load8_u", [22_486]), 0);
 
 // memory_copy.wast:2633
-assert_return(() => call($15, "load8_u", [10_546]), 0);
+assert_return(() => call($15, "load8_u", [22_685]), 0);
 
 // memory_copy.wast:2634
-assert_return(() => call($15, "load8_u", [10_745]), 0);
+assert_return(() => call($15, "load8_u", [22_884]), 0);
 
 // memory_copy.wast:2635
-assert_return(() => call($15, "load8_u", [10_944]), 0);
+assert_return(() => call($15, "load8_u", [23_083]), 0);
 
 // memory_copy.wast:2636
-assert_return(() => call($15, "load8_u", [11_143]), 0);
+assert_return(() => call($15, "load8_u", [23_282]), 0);
 
 // memory_copy.wast:2637
-assert_return(() => call($15, "load8_u", [11_342]), 0);
+assert_return(() => call($15, "load8_u", [23_481]), 0);
 
 // memory_copy.wast:2638
-assert_return(() => call($15, "load8_u", [11_541]), 0);
+assert_return(() => call($15, "load8_u", [23_680]), 0);
 
 // memory_copy.wast:2639
-assert_return(() => call($15, "load8_u", [11_740]), 0);
+assert_return(() => call($15, "load8_u", [23_879]), 0);
 
 // memory_copy.wast:2640
-assert_return(() => call($15, "load8_u", [11_939]), 0);
+assert_return(() => call($15, "load8_u", [24_078]), 0);
 
 // memory_copy.wast:2641
-assert_return(() => call($15, "load8_u", [12_138]), 0);
+assert_return(() => call($15, "load8_u", [24_277]), 0);
 
 // memory_copy.wast:2642
-assert_return(() => call($15, "load8_u", [12_337]), 0);
+assert_return(() => call($15, "load8_u", [24_476]), 0);
 
 // memory_copy.wast:2643
-assert_return(() => call($15, "load8_u", [12_536]), 0);
+assert_return(() => call($15, "load8_u", [24_675]), 0);
 
 // memory_copy.wast:2644
-assert_return(() => call($15, "load8_u", [12_735]), 0);
+assert_return(() => call($15, "load8_u", [24_874]), 0);
 
 // memory_copy.wast:2645
-assert_return(() => call($15, "load8_u", [12_934]), 0);
+assert_return(() => call($15, "load8_u", [25_073]), 0);
 
 // memory_copy.wast:2646
-assert_return(() => call($15, "load8_u", [13_133]), 0);
+assert_return(() => call($15, "load8_u", [25_272]), 0);
 
 // memory_copy.wast:2647
-assert_return(() => call($15, "load8_u", [13_332]), 0);
+assert_return(() => call($15, "load8_u", [25_471]), 0);
 
 // memory_copy.wast:2648
-assert_return(() => call($15, "load8_u", [13_531]), 0);
+assert_return(() => call($15, "load8_u", [25_670]), 0);
 
 // memory_copy.wast:2649
-assert_return(() => call($15, "load8_u", [13_730]), 0);
+assert_return(() => call($15, "load8_u", [25_869]), 0);
 
 // memory_copy.wast:2650
-assert_return(() => call($15, "load8_u", [13_929]), 0);
+assert_return(() => call($15, "load8_u", [26_068]), 0);
 
 // memory_copy.wast:2651
-assert_return(() => call($15, "load8_u", [14_128]), 0);
+assert_return(() => call($15, "load8_u", [26_267]), 0);
 
 // memory_copy.wast:2652
-assert_return(() => call($15, "load8_u", [14_327]), 0);
+assert_return(() => call($15, "load8_u", [26_466]), 0);
 
 // memory_copy.wast:2653
-assert_return(() => call($15, "load8_u", [14_526]), 0);
+assert_return(() => call($15, "load8_u", [26_665]), 0);
 
 // memory_copy.wast:2654
-assert_return(() => call($15, "load8_u", [14_725]), 0);
+assert_return(() => call($15, "load8_u", [26_864]), 0);
 
 // memory_copy.wast:2655
-assert_return(() => call($15, "load8_u", [14_924]), 0);
+assert_return(() => call($15, "load8_u", [27_063]), 0);
 
 // memory_copy.wast:2656
-assert_return(() => call($15, "load8_u", [15_123]), 0);
+assert_return(() => call($15, "load8_u", [27_262]), 0);
 
 // memory_copy.wast:2657
-assert_return(() => call($15, "load8_u", [15_322]), 0);
+assert_return(() => call($15, "load8_u", [27_461]), 0);
 
 // memory_copy.wast:2658
-assert_return(() => call($15, "load8_u", [15_521]), 0);
+assert_return(() => call($15, "load8_u", [27_660]), 0);
 
 // memory_copy.wast:2659
-assert_return(() => call($15, "load8_u", [15_720]), 0);
+assert_return(() => call($15, "load8_u", [27_859]), 0);
 
 // memory_copy.wast:2660
-assert_return(() => call($15, "load8_u", [15_919]), 0);
+assert_return(() => call($15, "load8_u", [28_058]), 0);
 
 // memory_copy.wast:2661
-assert_return(() => call($15, "load8_u", [16_118]), 0);
+assert_return(() => call($15, "load8_u", [28_257]), 0);
 
 // memory_copy.wast:2662
-assert_return(() => call($15, "load8_u", [16_317]), 0);
+assert_return(() => call($15, "load8_u", [28_456]), 0);
 
 // memory_copy.wast:2663
-assert_return(() => call($15, "load8_u", [16_516]), 0);
+assert_return(() => call($15, "load8_u", [28_655]), 0);
 
 // memory_copy.wast:2664
-assert_return(() => call($15, "load8_u", [16_715]), 0);
+assert_return(() => call($15, "load8_u", [28_854]), 0);
 
 // memory_copy.wast:2665
-assert_return(() => call($15, "load8_u", [16_914]), 0);
+assert_return(() => call($15, "load8_u", [29_053]), 0);
 
 // memory_copy.wast:2666
-assert_return(() => call($15, "load8_u", [17_113]), 0);
+assert_return(() => call($15, "load8_u", [29_252]), 0);
 
 // memory_copy.wast:2667
-assert_return(() => call($15, "load8_u", [17_312]), 0);
+assert_return(() => call($15, "load8_u", [29_451]), 0);
 
 // memory_copy.wast:2668
-assert_return(() => call($15, "load8_u", [17_511]), 0);
+assert_return(() => call($15, "load8_u", [29_650]), 0);
 
 // memory_copy.wast:2669
-assert_return(() => call($15, "load8_u", [17_710]), 0);
+assert_return(() => call($15, "load8_u", [29_849]), 0);
 
 // memory_copy.wast:2670
-assert_return(() => call($15, "load8_u", [17_909]), 0);
+assert_return(() => call($15, "load8_u", [30_048]), 0);
 
 // memory_copy.wast:2671
-assert_return(() => call($15, "load8_u", [18_108]), 0);
+assert_return(() => call($15, "load8_u", [30_247]), 0);
 
 // memory_copy.wast:2672
-assert_return(() => call($15, "load8_u", [18_307]), 0);
+assert_return(() => call($15, "load8_u", [30_446]), 0);
 
 // memory_copy.wast:2673
-assert_return(() => call($15, "load8_u", [18_506]), 0);
+assert_return(() => call($15, "load8_u", [30_645]), 0);
 
 // memory_copy.wast:2674
-assert_return(() => call($15, "load8_u", [18_705]), 0);
+assert_return(() => call($15, "load8_u", [30_844]), 0);
 
 // memory_copy.wast:2675
-assert_return(() => call($15, "load8_u", [18_904]), 0);
+assert_return(() => call($15, "load8_u", [31_043]), 0);
 
 // memory_copy.wast:2676
-assert_return(() => call($15, "load8_u", [19_103]), 0);
+assert_return(() => call($15, "load8_u", [31_242]), 0);
 
 // memory_copy.wast:2677
-assert_return(() => call($15, "load8_u", [19_302]), 0);
+assert_return(() => call($15, "load8_u", [31_441]), 0);
 
 // memory_copy.wast:2678
-assert_return(() => call($15, "load8_u", [19_501]), 0);
+assert_return(() => call($15, "load8_u", [31_640]), 0);
 
 // memory_copy.wast:2679
-assert_return(() => call($15, "load8_u", [19_700]), 0);
+assert_return(() => call($15, "load8_u", [31_839]), 0);
 
 // memory_copy.wast:2680
-assert_return(() => call($15, "load8_u", [19_899]), 0);
+assert_return(() => call($15, "load8_u", [32_038]), 0);
 
 // memory_copy.wast:2681
-assert_return(() => call($15, "load8_u", [20_098]), 0);
+assert_return(() => call($15, "load8_u", [32_237]), 0);
 
 // memory_copy.wast:2682
-assert_return(() => call($15, "load8_u", [20_297]), 0);
+assert_return(() => call($15, "load8_u", [32_436]), 0);
 
 // memory_copy.wast:2683
-assert_return(() => call($15, "load8_u", [20_496]), 0);
+assert_return(() => call($15, "load8_u", [32_635]), 0);
 
 // memory_copy.wast:2684
-assert_return(() => call($15, "load8_u", [20_695]), 0);
+assert_return(() => call($15, "load8_u", [32_834]), 0);
 
 // memory_copy.wast:2685
-assert_return(() => call($15, "load8_u", [20_894]), 0);
+assert_return(() => call($15, "load8_u", [33_033]), 0);
 
 // memory_copy.wast:2686
-assert_return(() => call($15, "load8_u", [21_093]), 0);
+assert_return(() => call($15, "load8_u", [33_232]), 0);
 
 // memory_copy.wast:2687
-assert_return(() => call($15, "load8_u", [21_292]), 0);
+assert_return(() => call($15, "load8_u", [33_431]), 0);
 
 // memory_copy.wast:2688
-assert_return(() => call($15, "load8_u", [21_491]), 0);
+assert_return(() => call($15, "load8_u", [33_630]), 0);
 
 // memory_copy.wast:2689
-assert_return(() => call($15, "load8_u", [21_690]), 0);
+assert_return(() => call($15, "load8_u", [33_829]), 0);
 
 // memory_copy.wast:2690
-assert_return(() => call($15, "load8_u", [21_889]), 0);
+assert_return(() => call($15, "load8_u", [34_028]), 0);
 
 // memory_copy.wast:2691
-assert_return(() => call($15, "load8_u", [22_088]), 0);
+assert_return(() => call($15, "load8_u", [34_227]), 0);
 
 // memory_copy.wast:2692
-assert_return(() => call($15, "load8_u", [22_287]), 0);
+assert_return(() => call($15, "load8_u", [34_426]), 0);
 
 // memory_copy.wast:2693
-assert_return(() => call($15, "load8_u", [22_486]), 0);
+assert_return(() => call($15, "load8_u", [34_625]), 0);
 
 // memory_copy.wast:2694
-assert_return(() => call($15, "load8_u", [22_685]), 0);
+assert_return(() => call($15, "load8_u", [34_824]), 0);
 
 // memory_copy.wast:2695
-assert_return(() => call($15, "load8_u", [22_884]), 0);
+assert_return(() => call($15, "load8_u", [35_023]), 0);
 
 // memory_copy.wast:2696
-assert_return(() => call($15, "load8_u", [23_083]), 0);
+assert_return(() => call($15, "load8_u", [35_222]), 0);
 
 // memory_copy.wast:2697
-assert_return(() => call($15, "load8_u", [23_282]), 0);
+assert_return(() => call($15, "load8_u", [35_421]), 0);
 
 // memory_copy.wast:2698
-assert_return(() => call($15, "load8_u", [23_481]), 0);
+assert_return(() => call($15, "load8_u", [35_620]), 0);
 
 // memory_copy.wast:2699
-assert_return(() => call($15, "load8_u", [23_680]), 0);
+assert_return(() => call($15, "load8_u", [35_819]), 0);
 
 // memory_copy.wast:2700
-assert_return(() => call($15, "load8_u", [23_879]), 0);
+assert_return(() => call($15, "load8_u", [36_018]), 0);
 
 // memory_copy.wast:2701
-assert_return(() => call($15, "load8_u", [24_078]), 0);
+assert_return(() => call($15, "load8_u", [36_217]), 0);
 
 // memory_copy.wast:2702
-assert_return(() => call($15, "load8_u", [24_277]), 0);
+assert_return(() => call($15, "load8_u", [36_416]), 0);
 
 // memory_copy.wast:2703
-assert_return(() => call($15, "load8_u", [24_476]), 0);
+assert_return(() => call($15, "load8_u", [36_615]), 0);
 
 // memory_copy.wast:2704
-assert_return(() => call($15, "load8_u", [24_675]), 0);
+assert_return(() => call($15, "load8_u", [36_814]), 0);
 
 // memory_copy.wast:2705
-assert_return(() => call($15, "load8_u", [24_874]), 0);
+assert_return(() => call($15, "load8_u", [37_013]), 0);
 
 // memory_copy.wast:2706
-assert_return(() => call($15, "load8_u", [25_073]), 0);
+assert_return(() => call($15, "load8_u", [37_212]), 0);
 
 // memory_copy.wast:2707
-assert_return(() => call($15, "load8_u", [25_272]), 0);
+assert_return(() => call($15, "load8_u", [37_411]), 0);
 
 // memory_copy.wast:2708
-assert_return(() => call($15, "load8_u", [25_471]), 0);
+assert_return(() => call($15, "load8_u", [37_610]), 0);
 
 // memory_copy.wast:2709
-assert_return(() => call($15, "load8_u", [25_670]), 0);
+assert_return(() => call($15, "load8_u", [37_809]), 0);
 
 // memory_copy.wast:2710
-assert_return(() => call($15, "load8_u", [25_869]), 0);
+assert_return(() => call($15, "load8_u", [38_008]), 0);
 
 // memory_copy.wast:2711
-assert_return(() => call($15, "load8_u", [26_068]), 0);
+assert_return(() => call($15, "load8_u", [38_207]), 0);
 
 // memory_copy.wast:2712
-assert_return(() => call($15, "load8_u", [26_267]), 0);
+assert_return(() => call($15, "load8_u", [38_406]), 0);
 
 // memory_copy.wast:2713
-assert_return(() => call($15, "load8_u", [26_466]), 0);
+assert_return(() => call($15, "load8_u", [38_605]), 0);
 
 // memory_copy.wast:2714
-assert_return(() => call($15, "load8_u", [26_665]), 0);
+assert_return(() => call($15, "load8_u", [38_804]), 0);
 
 // memory_copy.wast:2715
-assert_return(() => call($15, "load8_u", [26_864]), 0);
+assert_return(() => call($15, "load8_u", [39_003]), 0);
 
 // memory_copy.wast:2716
-assert_return(() => call($15, "load8_u", [27_063]), 0);
+assert_return(() => call($15, "load8_u", [39_202]), 0);
 
 // memory_copy.wast:2717
-assert_return(() => call($15, "load8_u", [27_262]), 0);
+assert_return(() => call($15, "load8_u", [39_401]), 0);
 
 // memory_copy.wast:2718
-assert_return(() => call($15, "load8_u", [27_461]), 0);
+assert_return(() => call($15, "load8_u", [39_600]), 0);
 
 // memory_copy.wast:2719
-assert_return(() => call($15, "load8_u", [27_660]), 0);
+assert_return(() => call($15, "load8_u", [39_799]), 0);
 
 // memory_copy.wast:2720
-assert_return(() => call($15, "load8_u", [27_859]), 0);
+assert_return(() => call($15, "load8_u", [39_998]), 0);
 
 // memory_copy.wast:2721
-assert_return(() => call($15, "load8_u", [28_058]), 0);
+assert_return(() => call($15, "load8_u", [40_197]), 0);
 
 // memory_copy.wast:2722
-assert_return(() => call($15, "load8_u", [28_257]), 0);
+assert_return(() => call($15, "load8_u", [40_396]), 0);
 
 // memory_copy.wast:2723
-assert_return(() => call($15, "load8_u", [28_456]), 0);
+assert_return(() => call($15, "load8_u", [40_595]), 0);
 
 // memory_copy.wast:2724
-assert_return(() => call($15, "load8_u", [28_655]), 0);
+assert_return(() => call($15, "load8_u", [40_794]), 0);
 
 // memory_copy.wast:2725
-assert_return(() => call($15, "load8_u", [28_854]), 0);
+assert_return(() => call($15, "load8_u", [40_993]), 0);
 
 // memory_copy.wast:2726
-assert_return(() => call($15, "load8_u", [29_053]), 0);
+assert_return(() => call($15, "load8_u", [41_192]), 0);
 
 // memory_copy.wast:2727
-assert_return(() => call($15, "load8_u", [29_252]), 0);
+assert_return(() => call($15, "load8_u", [41_391]), 0);
 
 // memory_copy.wast:2728
-assert_return(() => call($15, "load8_u", [29_451]), 0);
+assert_return(() => call($15, "load8_u", [41_590]), 0);
 
 // memory_copy.wast:2729
-assert_return(() => call($15, "load8_u", [29_650]), 0);
+assert_return(() => call($15, "load8_u", [41_789]), 0);
 
 // memory_copy.wast:2730
-assert_return(() => call($15, "load8_u", [29_849]), 0);
+assert_return(() => call($15, "load8_u", [41_988]), 0);
 
 // memory_copy.wast:2731
-assert_return(() => call($15, "load8_u", [30_048]), 0);
+assert_return(() => call($15, "load8_u", [42_187]), 0);
 
 // memory_copy.wast:2732
-assert_return(() => call($15, "load8_u", [30_247]), 0);
+assert_return(() => call($15, "load8_u", [42_386]), 0);
 
 // memory_copy.wast:2733
-assert_return(() => call($15, "load8_u", [30_446]), 0);
+assert_return(() => call($15, "load8_u", [42_585]), 0);
 
 // memory_copy.wast:2734
-assert_return(() => call($15, "load8_u", [30_645]), 0);
+assert_return(() => call($15, "load8_u", [42_784]), 0);
 
 // memory_copy.wast:2735
-assert_return(() => call($15, "load8_u", [30_844]), 0);
+assert_return(() => call($15, "load8_u", [42_983]), 0);
 
 // memory_copy.wast:2736
-assert_return(() => call($15, "load8_u", [31_043]), 0);
+assert_return(() => call($15, "load8_u", [43_182]), 0);
 
 // memory_copy.wast:2737
-assert_return(() => call($15, "load8_u", [31_242]), 0);
+assert_return(() => call($15, "load8_u", [43_381]), 0);
 
 // memory_copy.wast:2738
-assert_return(() => call($15, "load8_u", [31_441]), 0);
+assert_return(() => call($15, "load8_u", [43_580]), 0);
 
 // memory_copy.wast:2739
-assert_return(() => call($15, "load8_u", [31_640]), 0);
+assert_return(() => call($15, "load8_u", [43_779]), 0);
 
 // memory_copy.wast:2740
-assert_return(() => call($15, "load8_u", [31_839]), 0);
+assert_return(() => call($15, "load8_u", [43_978]), 0);
 
 // memory_copy.wast:2741
-assert_return(() => call($15, "load8_u", [32_038]), 0);
+assert_return(() => call($15, "load8_u", [44_177]), 0);
 
 // memory_copy.wast:2742
-assert_return(() => call($15, "load8_u", [32_237]), 0);
+assert_return(() => call($15, "load8_u", [44_376]), 0);
 
 // memory_copy.wast:2743
-assert_return(() => call($15, "load8_u", [32_436]), 0);
+assert_return(() => call($15, "load8_u", [44_575]), 0);
 
 // memory_copy.wast:2744
-assert_return(() => call($15, "load8_u", [32_635]), 0);
+assert_return(() => call($15, "load8_u", [44_774]), 0);
 
 // memory_copy.wast:2745
-assert_return(() => call($15, "load8_u", [32_834]), 0);
+assert_return(() => call($15, "load8_u", [44_973]), 0);
 
 // memory_copy.wast:2746
-assert_return(() => call($15, "load8_u", [33_033]), 0);
+assert_return(() => call($15, "load8_u", [45_172]), 0);
 
 // memory_copy.wast:2747
-assert_return(() => call($15, "load8_u", [33_232]), 0);
+assert_return(() => call($15, "load8_u", [45_371]), 0);
 
 // memory_copy.wast:2748
-assert_return(() => call($15, "load8_u", [33_431]), 0);
+assert_return(() => call($15, "load8_u", [45_570]), 0);
 
 // memory_copy.wast:2749
-assert_return(() => call($15, "load8_u", [33_630]), 0);
+assert_return(() => call($15, "load8_u", [45_769]), 0);
 
 // memory_copy.wast:2750
-assert_return(() => call($15, "load8_u", [33_829]), 0);
+assert_return(() => call($15, "load8_u", [45_968]), 0);
 
 // memory_copy.wast:2751
-assert_return(() => call($15, "load8_u", [34_028]), 0);
+assert_return(() => call($15, "load8_u", [46_167]), 0);
 
 // memory_copy.wast:2752
-assert_return(() => call($15, "load8_u", [34_227]), 0);
+assert_return(() => call($15, "load8_u", [46_366]), 0);
 
 // memory_copy.wast:2753
-assert_return(() => call($15, "load8_u", [34_426]), 0);
+assert_return(() => call($15, "load8_u", [46_565]), 0);
 
 // memory_copy.wast:2754
-assert_return(() => call($15, "load8_u", [34_625]), 0);
+assert_return(() => call($15, "load8_u", [46_764]), 0);
 
 // memory_copy.wast:2755
-assert_return(() => call($15, "load8_u", [34_824]), 0);
+assert_return(() => call($15, "load8_u", [46_963]), 0);
 
 // memory_copy.wast:2756
-assert_return(() => call($15, "load8_u", [35_023]), 0);
+assert_return(() => call($15, "load8_u", [47_162]), 0);
 
 // memory_copy.wast:2757
-assert_return(() => call($15, "load8_u", [35_222]), 0);
+assert_return(() => call($15, "load8_u", [47_361]), 0);
 
 // memory_copy.wast:2758
-assert_return(() => call($15, "load8_u", [35_421]), 0);
+assert_return(() => call($15, "load8_u", [47_560]), 0);
 
 // memory_copy.wast:2759
-assert_return(() => call($15, "load8_u", [35_620]), 0);
+assert_return(() => call($15, "load8_u", [47_759]), 0);
 
 // memory_copy.wast:2760
-assert_return(() => call($15, "load8_u", [35_819]), 0);
+assert_return(() => call($15, "load8_u", [47_958]), 0);
 
 // memory_copy.wast:2761
-assert_return(() => call($15, "load8_u", [36_018]), 0);
+assert_return(() => call($15, "load8_u", [48_157]), 0);
 
 // memory_copy.wast:2762
-assert_return(() => call($15, "load8_u", [36_217]), 0);
+assert_return(() => call($15, "load8_u", [48_356]), 0);
 
 // memory_copy.wast:2763
-assert_return(() => call($15, "load8_u", [36_416]), 0);
+assert_return(() => call($15, "load8_u", [48_555]), 0);
 
 // memory_copy.wast:2764
-assert_return(() => call($15, "load8_u", [36_615]), 0);
+assert_return(() => call($15, "load8_u", [48_754]), 0);
 
 // memory_copy.wast:2765
-assert_return(() => call($15, "load8_u", [36_814]), 0);
+assert_return(() => call($15, "load8_u", [48_953]), 0);
 
 // memory_copy.wast:2766
-assert_return(() => call($15, "load8_u", [37_013]), 0);
+assert_return(() => call($15, "load8_u", [49_152]), 0);
 
 // memory_copy.wast:2767
-assert_return(() => call($15, "load8_u", [37_212]), 0);
+assert_return(() => call($15, "load8_u", [49_351]), 0);
 
 // memory_copy.wast:2768
-assert_return(() => call($15, "load8_u", [37_411]), 0);
+assert_return(() => call($15, "load8_u", [49_550]), 0);
 
 // memory_copy.wast:2769
-assert_return(() => call($15, "load8_u", [37_610]), 0);
+assert_return(() => call($15, "load8_u", [49_749]), 0);
 
 // memory_copy.wast:2770
-assert_return(() => call($15, "load8_u", [37_809]), 0);
+assert_return(() => call($15, "load8_u", [49_948]), 0);
 
 // memory_copy.wast:2771
-assert_return(() => call($15, "load8_u", [38_008]), 0);
+assert_return(() => call($15, "load8_u", [50_147]), 0);
 
 // memory_copy.wast:2772
-assert_return(() => call($15, "load8_u", [38_207]), 0);
+assert_return(() => call($15, "load8_u", [50_346]), 0);
 
 // memory_copy.wast:2773
-assert_return(() => call($15, "load8_u", [38_406]), 0);
+assert_return(() => call($15, "load8_u", [50_545]), 0);
 
 // memory_copy.wast:2774
-assert_return(() => call($15, "load8_u", [38_605]), 0);
+assert_return(() => call($15, "load8_u", [50_744]), 0);
 
 // memory_copy.wast:2775
-assert_return(() => call($15, "load8_u", [38_804]), 0);
+assert_return(() => call($15, "load8_u", [50_943]), 0);
 
 // memory_copy.wast:2776
-assert_return(() => call($15, "load8_u", [39_003]), 0);
+assert_return(() => call($15, "load8_u", [51_142]), 0);
 
 // memory_copy.wast:2777
-assert_return(() => call($15, "load8_u", [39_202]), 0);
+assert_return(() => call($15, "load8_u", [51_341]), 0);
 
 // memory_copy.wast:2778
-assert_return(() => call($15, "load8_u", [39_401]), 0);
+assert_return(() => call($15, "load8_u", [51_540]), 0);
 
 // memory_copy.wast:2779
-assert_return(() => call($15, "load8_u", [39_600]), 0);
+assert_return(() => call($15, "load8_u", [51_739]), 0);
 
 // memory_copy.wast:2780
-assert_return(() => call($15, "load8_u", [39_799]), 0);
+assert_return(() => call($15, "load8_u", [51_938]), 0);
 
 // memory_copy.wast:2781
-assert_return(() => call($15, "load8_u", [39_998]), 0);
+assert_return(() => call($15, "load8_u", [52_137]), 0);
 
 // memory_copy.wast:2782
-assert_return(() => call($15, "load8_u", [40_197]), 0);
+assert_return(() => call($15, "load8_u", [52_336]), 0);
 
 // memory_copy.wast:2783
-assert_return(() => call($15, "load8_u", [40_396]), 0);
+assert_return(() => call($15, "load8_u", [52_535]), 0);
 
 // memory_copy.wast:2784
-assert_return(() => call($15, "load8_u", [40_595]), 0);
+assert_return(() => call($15, "load8_u", [52_734]), 0);
 
 // memory_copy.wast:2785
-assert_return(() => call($15, "load8_u", [40_794]), 0);
+assert_return(() => call($15, "load8_u", [52_933]), 0);
 
 // memory_copy.wast:2786
-assert_return(() => call($15, "load8_u", [40_993]), 0);
+assert_return(() => call($15, "load8_u", [53_132]), 0);
 
 // memory_copy.wast:2787
-assert_return(() => call($15, "load8_u", [41_192]), 0);
+assert_return(() => call($15, "load8_u", [53_331]), 0);
 
 // memory_copy.wast:2788
-assert_return(() => call($15, "load8_u", [41_391]), 0);
+assert_return(() => call($15, "load8_u", [53_530]), 0);
 
 // memory_copy.wast:2789
-assert_return(() => call($15, "load8_u", [41_590]), 0);
+assert_return(() => call($15, "load8_u", [53_729]), 0);
 
 // memory_copy.wast:2790
-assert_return(() => call($15, "load8_u", [41_789]), 0);
+assert_return(() => call($15, "load8_u", [53_928]), 0);
 
 // memory_copy.wast:2791
-assert_return(() => call($15, "load8_u", [41_988]), 0);
+assert_return(() => call($15, "load8_u", [54_127]), 0);
 
 // memory_copy.wast:2792
-assert_return(() => call($15, "load8_u", [42_187]), 0);
+assert_return(() => call($15, "load8_u", [54_326]), 0);
 
 // memory_copy.wast:2793
-assert_return(() => call($15, "load8_u", [42_386]), 0);
+assert_return(() => call($15, "load8_u", [54_525]), 0);
 
 // memory_copy.wast:2794
-assert_return(() => call($15, "load8_u", [42_585]), 0);
+assert_return(() => call($15, "load8_u", [54_724]), 0);
 
 // memory_copy.wast:2795
-assert_return(() => call($15, "load8_u", [42_784]), 0);
+assert_return(() => call($15, "load8_u", [54_923]), 0);
 
 // memory_copy.wast:2796
-assert_return(() => call($15, "load8_u", [42_983]), 0);
+assert_return(() => call($15, "load8_u", [55_122]), 0);
 
 // memory_copy.wast:2797
-assert_return(() => call($15, "load8_u", [43_182]), 0);
+assert_return(() => call($15, "load8_u", [55_321]), 0);
 
 // memory_copy.wast:2798
-assert_return(() => call($15, "load8_u", [43_381]), 0);
+assert_return(() => call($15, "load8_u", [55_520]), 0);
 
 // memory_copy.wast:2799
-assert_return(() => call($15, "load8_u", [43_580]), 0);
+assert_return(() => call($15, "load8_u", [55_719]), 0);
 
 // memory_copy.wast:2800
-assert_return(() => call($15, "load8_u", [43_779]), 0);
+assert_return(() => call($15, "load8_u", [55_918]), 0);
 
 // memory_copy.wast:2801
-assert_return(() => call($15, "load8_u", [43_978]), 0);
+assert_return(() => call($15, "load8_u", [56_117]), 0);
 
 // memory_copy.wast:2802
-assert_return(() => call($15, "load8_u", [44_177]), 0);
+assert_return(() => call($15, "load8_u", [56_316]), 0);
 
 // memory_copy.wast:2803
-assert_return(() => call($15, "load8_u", [44_376]), 0);
+assert_return(() => call($15, "load8_u", [56_515]), 0);
 
 // memory_copy.wast:2804
-assert_return(() => call($15, "load8_u", [44_575]), 0);
+assert_return(() => call($15, "load8_u", [56_714]), 0);
 
 // memory_copy.wast:2805
-assert_return(() => call($15, "load8_u", [44_774]), 0);
+assert_return(() => call($15, "load8_u", [56_913]), 0);
 
 // memory_copy.wast:2806
-assert_return(() => call($15, "load8_u", [44_973]), 0);
+assert_return(() => call($15, "load8_u", [57_112]), 0);
 
 // memory_copy.wast:2807
-assert_return(() => call($15, "load8_u", [45_172]), 0);
+assert_return(() => call($15, "load8_u", [57_311]), 0);
 
 // memory_copy.wast:2808
-assert_return(() => call($15, "load8_u", [45_371]), 0);
+assert_return(() => call($15, "load8_u", [57_510]), 0);
 
 // memory_copy.wast:2809
-assert_return(() => call($15, "load8_u", [45_570]), 0);
+assert_return(() => call($15, "load8_u", [57_709]), 0);
 
 // memory_copy.wast:2810
-assert_return(() => call($15, "load8_u", [45_769]), 0);
+assert_return(() => call($15, "load8_u", [57_908]), 0);
 
 // memory_copy.wast:2811
-assert_return(() => call($15, "load8_u", [45_968]), 0);
+assert_return(() => call($15, "load8_u", [58_107]), 0);
 
 // memory_copy.wast:2812
-assert_return(() => call($15, "load8_u", [46_167]), 0);
+assert_return(() => call($15, "load8_u", [58_306]), 0);
 
 // memory_copy.wast:2813
-assert_return(() => call($15, "load8_u", [46_366]), 0);
+assert_return(() => call($15, "load8_u", [58_505]), 0);
 
 // memory_copy.wast:2814
-assert_return(() => call($15, "load8_u", [46_565]), 0);
+assert_return(() => call($15, "load8_u", [58_704]), 0);
 
 // memory_copy.wast:2815
-assert_return(() => call($15, "load8_u", [46_764]), 0);
+assert_return(() => call($15, "load8_u", [58_903]), 0);
 
 // memory_copy.wast:2816
-assert_return(() => call($15, "load8_u", [46_963]), 0);
+assert_return(() => call($15, "load8_u", [59_102]), 0);
 
 // memory_copy.wast:2817
-assert_return(() => call($15, "load8_u", [47_162]), 0);
+assert_return(() => call($15, "load8_u", [59_301]), 0);
 
 // memory_copy.wast:2818
-assert_return(() => call($15, "load8_u", [47_361]), 0);
+assert_return(() => call($15, "load8_u", [59_500]), 0);
 
 // memory_copy.wast:2819
-assert_return(() => call($15, "load8_u", [47_560]), 0);
+assert_return(() => call($15, "load8_u", [59_699]), 0);
 
 // memory_copy.wast:2820
-assert_return(() => call($15, "load8_u", [47_759]), 0);
+assert_return(() => call($15, "load8_u", [59_898]), 0);
 
 // memory_copy.wast:2821
-assert_return(() => call($15, "load8_u", [47_958]), 0);
+assert_return(() => call($15, "load8_u", [60_097]), 0);
 
 // memory_copy.wast:2822
-assert_return(() => call($15, "load8_u", [48_157]), 0);
+assert_return(() => call($15, "load8_u", [60_296]), 0);
 
 // memory_copy.wast:2823
-assert_return(() => call($15, "load8_u", [48_356]), 0);
+assert_return(() => call($15, "load8_u", [60_495]), 0);
 
 // memory_copy.wast:2824
-assert_return(() => call($15, "load8_u", [48_555]), 0);
+assert_return(() => call($15, "load8_u", [60_694]), 0);
 
 // memory_copy.wast:2825
-assert_return(() => call($15, "load8_u", [48_754]), 0);
+assert_return(() => call($15, "load8_u", [60_893]), 0);
 
 // memory_copy.wast:2826
-assert_return(() => call($15, "load8_u", [48_953]), 0);
+assert_return(() => call($15, "load8_u", [61_092]), 0);
 
 // memory_copy.wast:2827
-assert_return(() => call($15, "load8_u", [49_152]), 0);
+assert_return(() => call($15, "load8_u", [61_291]), 0);
 
 // memory_copy.wast:2828
-assert_return(() => call($15, "load8_u", [49_351]), 0);
+assert_return(() => call($15, "load8_u", [61_490]), 0);
 
 // memory_copy.wast:2829
-assert_return(() => call($15, "load8_u", [49_550]), 0);
+assert_return(() => call($15, "load8_u", [61_689]), 0);
 
 // memory_copy.wast:2830
-assert_return(() => call($15, "load8_u", [49_749]), 0);
+assert_return(() => call($15, "load8_u", [61_888]), 0);
 
 // memory_copy.wast:2831
-assert_return(() => call($15, "load8_u", [49_948]), 0);
+assert_return(() => call($15, "load8_u", [62_087]), 0);
 
 // memory_copy.wast:2832
-assert_return(() => call($15, "load8_u", [50_147]), 0);
+assert_return(() => call($15, "load8_u", [62_286]), 0);
 
 // memory_copy.wast:2833
-assert_return(() => call($15, "load8_u", [50_346]), 0);
+assert_return(() => call($15, "load8_u", [62_485]), 0);
 
 // memory_copy.wast:2834
-assert_return(() => call($15, "load8_u", [50_545]), 0);
+assert_return(() => call($15, "load8_u", [62_684]), 0);
 
 // memory_copy.wast:2835
-assert_return(() => call($15, "load8_u", [50_744]), 0);
+assert_return(() => call($15, "load8_u", [62_883]), 0);
 
 // memory_copy.wast:2836
-assert_return(() => call($15, "load8_u", [50_943]), 0);
+assert_return(() => call($15, "load8_u", [63_082]), 0);
 
 // memory_copy.wast:2837
-assert_return(() => call($15, "load8_u", [51_142]), 0);
+assert_return(() => call($15, "load8_u", [63_281]), 0);
 
 // memory_copy.wast:2838
-assert_return(() => call($15, "load8_u", [51_341]), 0);
+assert_return(() => call($15, "load8_u", [63_480]), 0);
 
 // memory_copy.wast:2839
-assert_return(() => call($15, "load8_u", [51_540]), 0);
+assert_return(() => call($15, "load8_u", [63_679]), 0);
 
 // memory_copy.wast:2840
-assert_return(() => call($15, "load8_u", [51_739]), 0);
+assert_return(() => call($15, "load8_u", [63_878]), 0);
 
 // memory_copy.wast:2841
-assert_return(() => call($15, "load8_u", [51_938]), 0);
+assert_return(() => call($15, "load8_u", [64_077]), 0);
 
 // memory_copy.wast:2842
-assert_return(() => call($15, "load8_u", [52_137]), 0);
+assert_return(() => call($15, "load8_u", [64_276]), 0);
 
 // memory_copy.wast:2843
-assert_return(() => call($15, "load8_u", [52_336]), 0);
+assert_return(() => call($15, "load8_u", [64_475]), 0);
 
 // memory_copy.wast:2844
-assert_return(() => call($15, "load8_u", [52_535]), 0);
+assert_return(() => call($15, "load8_u", [64_674]), 0);
 
 // memory_copy.wast:2845
-assert_return(() => call($15, "load8_u", [52_734]), 0);
+assert_return(() => call($15, "load8_u", [64_873]), 0);
 
 // memory_copy.wast:2846
-assert_return(() => call($15, "load8_u", [52_933]), 0);
+assert_return(() => call($15, "load8_u", [65_072]), 0);
 
 // memory_copy.wast:2847
-assert_return(() => call($15, "load8_u", [53_132]), 0);
+assert_return(() => call($15, "load8_u", [65_271]), 0);
 
 // memory_copy.wast:2848
-assert_return(() => call($15, "load8_u", [53_331]), 0);
+assert_return(() => call($15, "load8_u", [65_470]), 0);
 
 // memory_copy.wast:2849
-assert_return(() => call($15, "load8_u", [53_530]), 0);
+assert_return(() => call($15, "load8_u", [65_506]), 0);
 
 // memory_copy.wast:2850
-assert_return(() => call($15, "load8_u", [53_729]), 0);
+assert_return(() => call($15, "load8_u", [65_507]), 1);
 
 // memory_copy.wast:2851
-assert_return(() => call($15, "load8_u", [53_928]), 0);
+assert_return(() => call($15, "load8_u", [65_508]), 2);
 
 // memory_copy.wast:2852
-assert_return(() => call($15, "load8_u", [54_127]), 0);
+assert_return(() => call($15, "load8_u", [65_509]), 3);
 
 // memory_copy.wast:2853
-assert_return(() => call($15, "load8_u", [54_326]), 0);
+assert_return(() => call($15, "load8_u", [65_510]), 4);
 
 // memory_copy.wast:2854
-assert_return(() => call($15, "load8_u", [54_525]), 0);
+assert_return(() => call($15, "load8_u", [65_511]), 5);
 
 // memory_copy.wast:2855
-assert_return(() => call($15, "load8_u", [54_724]), 0);
+assert_return(() => call($15, "load8_u", [65_512]), 6);
 
 // memory_copy.wast:2856
-assert_return(() => call($15, "load8_u", [54_923]), 0);
+assert_return(() => call($15, "load8_u", [65_513]), 7);
 
 // memory_copy.wast:2857
-assert_return(() => call($15, "load8_u", [55_122]), 0);
+assert_return(() => call($15, "load8_u", [65_514]), 8);
 
 // memory_copy.wast:2858
-assert_return(() => call($15, "load8_u", [55_321]), 0);
+assert_return(() => call($15, "load8_u", [65_515]), 9);
 
 // memory_copy.wast:2859
-assert_return(() => call($15, "load8_u", [55_520]), 0);
+assert_return(() => call($15, "load8_u", [65_516]), 10);
 
 // memory_copy.wast:2860
-assert_return(() => call($15, "load8_u", [55_719]), 0);
+assert_return(() => call($15, "load8_u", [65_517]), 11);
 
 // memory_copy.wast:2861
-assert_return(() => call($15, "load8_u", [55_918]), 0);
+assert_return(() => call($15, "load8_u", [65_518]), 12);
 
 // memory_copy.wast:2862
-assert_return(() => call($15, "load8_u", [56_117]), 0);
+assert_return(() => call($15, "load8_u", [65_519]), 13);
 
 // memory_copy.wast:2863
-assert_return(() => call($15, "load8_u", [56_316]), 0);
+assert_return(() => call($15, "load8_u", [65_520]), 14);
 
 // memory_copy.wast:2864
-assert_return(() => call($15, "load8_u", [56_515]), 0);
+assert_return(() => call($15, "load8_u", [65_521]), 15);
 
 // memory_copy.wast:2865
-assert_return(() => call($15, "load8_u", [56_714]), 0);
+assert_return(() => call($15, "load8_u", [65_522]), 16);
 
 // memory_copy.wast:2866
-assert_return(() => call($15, "load8_u", [56_913]), 0);
+assert_return(() => call($15, "load8_u", [65_523]), 17);
 
 // memory_copy.wast:2867
-assert_return(() => call($15, "load8_u", [57_112]), 0);
+assert_return(() => call($15, "load8_u", [65_524]), 18);
 
 // memory_copy.wast:2868
-assert_return(() => call($15, "load8_u", [57_311]), 0);
-
-// memory_copy.wast:2869
-assert_return(() => call($15, "load8_u", [57_510]), 0);
+assert_return(() => call($15, "load8_u", [65_525]), 19);
 
 // memory_copy.wast:2870
-assert_return(() => call($15, "load8_u", [57_709]), 0);
-
-// memory_copy.wast:2871
-assert_return(() => call($15, "load8_u", [57_908]), 0);
-
-// memory_copy.wast:2872
-assert_return(() => call($15, "load8_u", [58_107]), 0);
-
-// memory_copy.wast:2873
-assert_return(() => call($15, "load8_u", [58_306]), 0);
-
-// memory_copy.wast:2874
-assert_return(() => call($15, "load8_u", [58_505]), 0);
-
-// memory_copy.wast:2875
-assert_return(() => call($15, "load8_u", [58_704]), 0);
-
-// memory_copy.wast:2876
-assert_return(() => call($15, "load8_u", [58_903]), 0);
-
-// memory_copy.wast:2877
-assert_return(() => call($15, "load8_u", [59_102]), 0);
+let $16 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8c\x80\x80\x80\x00\x02\x60\x03\x7f\x7f\x7f\x00\x60\x01\x7f\x01\x7f\x03\x83\x80\x80\x80\x00\x02\x00\x01\x05\x84\x80\x80\x80\x00\x01\x01\x01\x01\x07\x97\x80\x80\x80\x00\x03\x03\x6d\x65\x6d\x02\x00\x03\x72\x75\x6e\x00\x00\x07\x6c\x6f\x61\x64\x38\x5f\x75\x00\x01\x0a\x9e\x80\x80\x80\x00\x02\x8c\x80\x80\x80\x00\x00\x20\x00\x20\x01\x20\x02\xfc\x0a\x00\x00\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x2d\x00\x00\x0b\x0b\x9c\x80\x80\x80\x00\x01\x00\x41\xec\xff\x03\x0b\x14\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10\x11\x12\x13");
 
 // memory_copy.wast:2878
-assert_return(() => call($15, "load8_u", [59_301]), 0);
-
-// memory_copy.wast:2879
-assert_return(() => call($15, "load8_u", [59_500]), 0);
-
-// memory_copy.wast:2880
-assert_return(() => call($15, "load8_u", [59_699]), 0);
+assert_trap(() => call($16, "run", [65_506, 65_516, 40]));
 
 // memory_copy.wast:2881
-assert_return(() => call($15, "load8_u", [59_898]), 0);
+assert_return(() => call($16, "load8_u", [198]), 0);
 
 // memory_copy.wast:2882
-assert_return(() => call($15, "load8_u", [60_097]), 0);
+assert_return(() => call($16, "load8_u", [397]), 0);
 
 // memory_copy.wast:2883
-assert_return(() => call($15, "load8_u", [60_296]), 0);
+assert_return(() => call($16, "load8_u", [596]), 0);
 
 // memory_copy.wast:2884
-assert_return(() => call($15, "load8_u", [60_495]), 0);
+assert_return(() => call($16, "load8_u", [795]), 0);
 
 // memory_copy.wast:2885
-assert_return(() => call($15, "load8_u", [60_694]), 0);
+assert_return(() => call($16, "load8_u", [994]), 0);
 
 // memory_copy.wast:2886
-assert_return(() => call($15, "load8_u", [60_893]), 0);
+assert_return(() => call($16, "load8_u", [1_193]), 0);
 
 // memory_copy.wast:2887
-assert_return(() => call($15, "load8_u", [61_092]), 0);
+assert_return(() => call($16, "load8_u", [1_392]), 0);
 
 // memory_copy.wast:2888
-assert_return(() => call($15, "load8_u", [61_291]), 0);
+assert_return(() => call($16, "load8_u", [1_591]), 0);
 
 // memory_copy.wast:2889
-assert_return(() => call($15, "load8_u", [61_490]), 0);
+assert_return(() => call($16, "load8_u", [1_790]), 0);
 
 // memory_copy.wast:2890
-assert_return(() => call($15, "load8_u", [61_689]), 0);
+assert_return(() => call($16, "load8_u", [1_989]), 0);
 
 // memory_copy.wast:2891
-assert_return(() => call($15, "load8_u", [61_888]), 0);
+assert_return(() => call($16, "load8_u", [2_188]), 0);
 
 // memory_copy.wast:2892
-assert_return(() => call($15, "load8_u", [62_087]), 0);
+assert_return(() => call($16, "load8_u", [2_387]), 0);
 
 // memory_copy.wast:2893
-assert_return(() => call($15, "load8_u", [62_286]), 0);
+assert_return(() => call($16, "load8_u", [2_586]), 0);
 
 // memory_copy.wast:2894
-assert_return(() => call($15, "load8_u", [62_485]), 0);
+assert_return(() => call($16, "load8_u", [2_785]), 0);
 
 // memory_copy.wast:2895
-assert_return(() => call($15, "load8_u", [62_684]), 0);
+assert_return(() => call($16, "load8_u", [2_984]), 0);
 
 // memory_copy.wast:2896
-assert_return(() => call($15, "load8_u", [62_883]), 0);
+assert_return(() => call($16, "load8_u", [3_183]), 0);
 
 // memory_copy.wast:2897
-assert_return(() => call($15, "load8_u", [63_082]), 0);
+assert_return(() => call($16, "load8_u", [3_382]), 0);
 
 // memory_copy.wast:2898
-assert_return(() => call($15, "load8_u", [63_281]), 0);
+assert_return(() => call($16, "load8_u", [3_581]), 0);
 
 // memory_copy.wast:2899
-assert_return(() => call($15, "load8_u", [63_480]), 0);
+assert_return(() => call($16, "load8_u", [3_780]), 0);
 
 // memory_copy.wast:2900
-assert_return(() => call($15, "load8_u", [63_679]), 0);
+assert_return(() => call($16, "load8_u", [3_979]), 0);
 
 // memory_copy.wast:2901
-assert_return(() => call($15, "load8_u", [63_878]), 0);
+assert_return(() => call($16, "load8_u", [4_178]), 0);
 
 // memory_copy.wast:2902
-assert_return(() => call($15, "load8_u", [64_077]), 0);
+assert_return(() => call($16, "load8_u", [4_377]), 0);
 
 // memory_copy.wast:2903
-assert_return(() => call($15, "load8_u", [64_276]), 0);
+assert_return(() => call($16, "load8_u", [4_576]), 0);
 
 // memory_copy.wast:2904
-assert_return(() => call($15, "load8_u", [64_475]), 0);
+assert_return(() => call($16, "load8_u", [4_775]), 0);
 
 // memory_copy.wast:2905
-assert_return(() => call($15, "load8_u", [64_674]), 0);
+assert_return(() => call($16, "load8_u", [4_974]), 0);
 
 // memory_copy.wast:2906
-assert_return(() => call($15, "load8_u", [64_873]), 0);
+assert_return(() => call($16, "load8_u", [5_173]), 0);
 
 // memory_copy.wast:2907
-assert_return(() => call($15, "load8_u", [65_072]), 0);
+assert_return(() => call($16, "load8_u", [5_372]), 0);
 
 // memory_copy.wast:2908
-assert_return(() => call($15, "load8_u", [65_271]), 0);
+assert_return(() => call($16, "load8_u", [5_571]), 0);
 
 // memory_copy.wast:2909
-assert_return(() => call($15, "load8_u", [65_470]), 0);
+assert_return(() => call($16, "load8_u", [5_770]), 0);
 
 // memory_copy.wast:2910
-assert_return(() => call($15, "load8_u", [65_506]), 0);
+assert_return(() => call($16, "load8_u", [5_969]), 0);
 
 // memory_copy.wast:2911
-assert_return(() => call($15, "load8_u", [65_507]), 1);
+assert_return(() => call($16, "load8_u", [6_168]), 0);
 
 // memory_copy.wast:2912
-assert_return(() => call($15, "load8_u", [65_508]), 2);
+assert_return(() => call($16, "load8_u", [6_367]), 0);
 
 // memory_copy.wast:2913
-assert_return(() => call($15, "load8_u", [65_509]), 3);
+assert_return(() => call($16, "load8_u", [6_566]), 0);
 
 // memory_copy.wast:2914
-assert_return(() => call($15, "load8_u", [65_510]), 4);
+assert_return(() => call($16, "load8_u", [6_765]), 0);
 
 // memory_copy.wast:2915
-assert_return(() => call($15, "load8_u", [65_511]), 5);
+assert_return(() => call($16, "load8_u", [6_964]), 0);
 
 // memory_copy.wast:2916
-assert_return(() => call($15, "load8_u", [65_512]), 6);
+assert_return(() => call($16, "load8_u", [7_163]), 0);
 
 // memory_copy.wast:2917
-assert_return(() => call($15, "load8_u", [65_513]), 7);
+assert_return(() => call($16, "load8_u", [7_362]), 0);
 
 // memory_copy.wast:2918
-assert_return(() => call($15, "load8_u", [65_514]), 8);
+assert_return(() => call($16, "load8_u", [7_561]), 0);
 
 // memory_copy.wast:2919
-assert_return(() => call($15, "load8_u", [65_515]), 9);
+assert_return(() => call($16, "load8_u", [7_760]), 0);
 
 // memory_copy.wast:2920
-assert_return(() => call($15, "load8_u", [65_516]), 10);
+assert_return(() => call($16, "load8_u", [7_959]), 0);
 
 // memory_copy.wast:2921
-assert_return(() => call($15, "load8_u", [65_517]), 11);
+assert_return(() => call($16, "load8_u", [8_158]), 0);
 
 // memory_copy.wast:2922
-assert_return(() => call($15, "load8_u", [65_518]), 12);
+assert_return(() => call($16, "load8_u", [8_357]), 0);
 
 // memory_copy.wast:2923
-assert_return(() => call($15, "load8_u", [65_519]), 13);
+assert_return(() => call($16, "load8_u", [8_556]), 0);
 
 // memory_copy.wast:2924
-assert_return(() => call($15, "load8_u", [65_520]), 14);
+assert_return(() => call($16, "load8_u", [8_755]), 0);
 
 // memory_copy.wast:2925
-assert_return(() => call($15, "load8_u", [65_521]), 15);
+assert_return(() => call($16, "load8_u", [8_954]), 0);
 
 // memory_copy.wast:2926
-assert_return(() => call($15, "load8_u", [65_522]), 16);
+assert_return(() => call($16, "load8_u", [9_153]), 0);
 
 // memory_copy.wast:2927
-assert_return(() => call($15, "load8_u", [65_523]), 17);
+assert_return(() => call($16, "load8_u", [9_352]), 0);
 
 // memory_copy.wast:2928
-assert_return(() => call($15, "load8_u", [65_524]), 18);
+assert_return(() => call($16, "load8_u", [9_551]), 0);
 
 // memory_copy.wast:2929
-assert_return(() => call($15, "load8_u", [65_525]), 19);
+assert_return(() => call($16, "load8_u", [9_750]), 0);
+
+// memory_copy.wast:2930
+assert_return(() => call($16, "load8_u", [9_949]), 0);
 
 // memory_copy.wast:2931
-let $16 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8c\x80\x80\x80\x00\x02\x60\x03\x7f\x7f\x7f\x00\x60\x01\x7f\x01\x7f\x03\x83\x80\x80\x80\x00\x02\x00\x01\x05\x84\x80\x80\x80\x00\x01\x01\x01\x01\x07\x97\x80\x80\x80\x00\x03\x03\x6d\x65\x6d\x02\x00\x03\x72\x75\x6e\x00\x00\x07\x6c\x6f\x61\x64\x38\x5f\x75\x00\x01\x0a\x9e\x80\x80\x80\x00\x02\x8c\x80\x80\x80\x00\x00\x20\x00\x20\x01\x20\x02\xfc\x0a\x00\x00\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x2d\x00\x00\x0b\x0b\x9c\x80\x80\x80\x00\x01\x00\x41\xec\xff\x03\x0b\x14\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10\x11\x12\x13");
+assert_return(() => call($16, "load8_u", [10_148]), 0);
+
+// memory_copy.wast:2932
+assert_return(() => call($16, "load8_u", [10_347]), 0);
+
+// memory_copy.wast:2933
+assert_return(() => call($16, "load8_u", [10_546]), 0);
+
+// memory_copy.wast:2934
+assert_return(() => call($16, "load8_u", [10_745]), 0);
+
+// memory_copy.wast:2935
+assert_return(() => call($16, "load8_u", [10_944]), 0);
+
+// memory_copy.wast:2936
+assert_return(() => call($16, "load8_u", [11_143]), 0);
+
+// memory_copy.wast:2937
+assert_return(() => call($16, "load8_u", [11_342]), 0);
+
+// memory_copy.wast:2938
+assert_return(() => call($16, "load8_u", [11_541]), 0);
 
 // memory_copy.wast:2939
-assert_trap(() => call($16, "run", [65_506, 65_516, 40]));
+assert_return(() => call($16, "load8_u", [11_740]), 0);
+
+// memory_copy.wast:2940
+assert_return(() => call($16, "load8_u", [11_939]), 0);
+
+// memory_copy.wast:2941
+assert_return(() => call($16, "load8_u", [12_138]), 0);
 
 // memory_copy.wast:2942
-assert_return(() => call($16, "load8_u", [198]), 0);
+assert_return(() => call($16, "load8_u", [12_337]), 0);
 
 // memory_copy.wast:2943
-assert_return(() => call($16, "load8_u", [397]), 0);
+assert_return(() => call($16, "load8_u", [12_536]), 0);
 
 // memory_copy.wast:2944
-assert_return(() => call($16, "load8_u", [596]), 0);
+assert_return(() => call($16, "load8_u", [12_735]), 0);
 
 // memory_copy.wast:2945
-assert_return(() => call($16, "load8_u", [795]), 0);
+assert_return(() => call($16, "load8_u", [12_934]), 0);
 
 // memory_copy.wast:2946
-assert_return(() => call($16, "load8_u", [994]), 0);
+assert_return(() => call($16, "load8_u", [13_133]), 0);
 
 // memory_copy.wast:2947
-assert_return(() => call($16, "load8_u", [1_193]), 0);
+assert_return(() => call($16, "load8_u", [13_332]), 0);
 
 // memory_copy.wast:2948
-assert_return(() => call($16, "load8_u", [1_392]), 0);
+assert_return(() => call($16, "load8_u", [13_531]), 0);
 
 // memory_copy.wast:2949
-assert_return(() => call($16, "load8_u", [1_591]), 0);
+assert_return(() => call($16, "load8_u", [13_730]), 0);
 
 // memory_copy.wast:2950
-assert_return(() => call($16, "load8_u", [1_790]), 0);
+assert_return(() => call($16, "load8_u", [13_929]), 0);
 
 // memory_copy.wast:2951
-assert_return(() => call($16, "load8_u", [1_989]), 0);
+assert_return(() => call($16, "load8_u", [14_128]), 0);
 
 // memory_copy.wast:2952
-assert_return(() => call($16, "load8_u", [2_188]), 0);
+assert_return(() => call($16, "load8_u", [14_327]), 0);
 
 // memory_copy.wast:2953
-assert_return(() => call($16, "load8_u", [2_387]), 0);
+assert_return(() => call($16, "load8_u", [14_526]), 0);
 
 // memory_copy.wast:2954
-assert_return(() => call($16, "load8_u", [2_586]), 0);
+assert_return(() => call($16, "load8_u", [14_725]), 0);
 
 // memory_copy.wast:2955
-assert_return(() => call($16, "load8_u", [2_785]), 0);
+assert_return(() => call($16, "load8_u", [14_924]), 0);
 
 // memory_copy.wast:2956
-assert_return(() => call($16, "load8_u", [2_984]), 0);
+assert_return(() => call($16, "load8_u", [15_123]), 0);
 
 // memory_copy.wast:2957
-assert_return(() => call($16, "load8_u", [3_183]), 0);
+assert_return(() => call($16, "load8_u", [15_322]), 0);
 
 // memory_copy.wast:2958
-assert_return(() => call($16, "load8_u", [3_382]), 0);
+assert_return(() => call($16, "load8_u", [15_521]), 0);
 
 // memory_copy.wast:2959
-assert_return(() => call($16, "load8_u", [3_581]), 0);
+assert_return(() => call($16, "load8_u", [15_720]), 0);
 
 // memory_copy.wast:2960
-assert_return(() => call($16, "load8_u", [3_780]), 0);
+assert_return(() => call($16, "load8_u", [15_919]), 0);
 
 // memory_copy.wast:2961
-assert_return(() => call($16, "load8_u", [3_979]), 0);
+assert_return(() => call($16, "load8_u", [16_118]), 0);
 
 // memory_copy.wast:2962
-assert_return(() => call($16, "load8_u", [4_178]), 0);
+assert_return(() => call($16, "load8_u", [16_317]), 0);
 
 // memory_copy.wast:2963
-assert_return(() => call($16, "load8_u", [4_377]), 0);
+assert_return(() => call($16, "load8_u", [16_516]), 0);
 
 // memory_copy.wast:2964
-assert_return(() => call($16, "load8_u", [4_576]), 0);
+assert_return(() => call($16, "load8_u", [16_715]), 0);
 
 // memory_copy.wast:2965
-assert_return(() => call($16, "load8_u", [4_775]), 0);
+assert_return(() => call($16, "load8_u", [16_914]), 0);
 
 // memory_copy.wast:2966
-assert_return(() => call($16, "load8_u", [4_974]), 0);
+assert_return(() => call($16, "load8_u", [17_113]), 0);
 
 // memory_copy.wast:2967
-assert_return(() => call($16, "load8_u", [5_173]), 0);
+assert_return(() => call($16, "load8_u", [17_312]), 0);
 
 // memory_copy.wast:2968
-assert_return(() => call($16, "load8_u", [5_372]), 0);
+assert_return(() => call($16, "load8_u", [17_511]), 0);
 
 // memory_copy.wast:2969
-assert_return(() => call($16, "load8_u", [5_571]), 0);
+assert_return(() => call($16, "load8_u", [17_710]), 0);
 
 // memory_copy.wast:2970
-assert_return(() => call($16, "load8_u", [5_770]), 0);
+assert_return(() => call($16, "load8_u", [17_909]), 0);
 
 // memory_copy.wast:2971
-assert_return(() => call($16, "load8_u", [5_969]), 0);
+assert_return(() => call($16, "load8_u", [18_108]), 0);
 
 // memory_copy.wast:2972
-assert_return(() => call($16, "load8_u", [6_168]), 0);
+assert_return(() => call($16, "load8_u", [18_307]), 0);
 
 // memory_copy.wast:2973
-assert_return(() => call($16, "load8_u", [6_367]), 0);
+assert_return(() => call($16, "load8_u", [18_506]), 0);
 
 // memory_copy.wast:2974
-assert_return(() => call($16, "load8_u", [6_566]), 0);
+assert_return(() => call($16, "load8_u", [18_705]), 0);
 
 // memory_copy.wast:2975
-assert_return(() => call($16, "load8_u", [6_765]), 0);
+assert_return(() => call($16, "load8_u", [18_904]), 0);
 
 // memory_copy.wast:2976
-assert_return(() => call($16, "load8_u", [6_964]), 0);
+assert_return(() => call($16, "load8_u", [19_103]), 0);
 
 // memory_copy.wast:2977
-assert_return(() => call($16, "load8_u", [7_163]), 0);
+assert_return(() => call($16, "load8_u", [19_302]), 0);
 
 // memory_copy.wast:2978
-assert_return(() => call($16, "load8_u", [7_362]), 0);
+assert_return(() => call($16, "load8_u", [19_501]), 0);
 
 // memory_copy.wast:2979
-assert_return(() => call($16, "load8_u", [7_561]), 0);
+assert_return(() => call($16, "load8_u", [19_700]), 0);
 
 // memory_copy.wast:2980
-assert_return(() => call($16, "load8_u", [7_760]), 0);
+assert_return(() => call($16, "load8_u", [19_899]), 0);
 
 // memory_copy.wast:2981
-assert_return(() => call($16, "load8_u", [7_959]), 0);
+assert_return(() => call($16, "load8_u", [20_098]), 0);
 
 // memory_copy.wast:2982
-assert_return(() => call($16, "load8_u", [8_158]), 0);
+assert_return(() => call($16, "load8_u", [20_297]), 0);
 
 // memory_copy.wast:2983
-assert_return(() => call($16, "load8_u", [8_357]), 0);
+assert_return(() => call($16, "load8_u", [20_496]), 0);
 
 // memory_copy.wast:2984
-assert_return(() => call($16, "load8_u", [8_556]), 0);
+assert_return(() => call($16, "load8_u", [20_695]), 0);
 
 // memory_copy.wast:2985
-assert_return(() => call($16, "load8_u", [8_755]), 0);
+assert_return(() => call($16, "load8_u", [20_894]), 0);
 
 // memory_copy.wast:2986
-assert_return(() => call($16, "load8_u", [8_954]), 0);
+assert_return(() => call($16, "load8_u", [21_093]), 0);
 
 // memory_copy.wast:2987
-assert_return(() => call($16, "load8_u", [9_153]), 0);
+assert_return(() => call($16, "load8_u", [21_292]), 0);
 
 // memory_copy.wast:2988
-assert_return(() => call($16, "load8_u", [9_352]), 0);
+assert_return(() => call($16, "load8_u", [21_491]), 0);
 
 // memory_copy.wast:2989
-assert_return(() => call($16, "load8_u", [9_551]), 0);
+assert_return(() => call($16, "load8_u", [21_690]), 0);
 
 // memory_copy.wast:2990
-assert_return(() => call($16, "load8_u", [9_750]), 0);
+assert_return(() => call($16, "load8_u", [21_889]), 0);
 
 // memory_copy.wast:2991
-assert_return(() => call($16, "load8_u", [9_949]), 0);
+assert_return(() => call($16, "load8_u", [22_088]), 0);
 
 // memory_copy.wast:2992
-assert_return(() => call($16, "load8_u", [10_148]), 0);
+assert_return(() => call($16, "load8_u", [22_287]), 0);
 
 // memory_copy.wast:2993
-assert_return(() => call($16, "load8_u", [10_347]), 0);
+assert_return(() => call($16, "load8_u", [22_486]), 0);
 
 // memory_copy.wast:2994
-assert_return(() => call($16, "load8_u", [10_546]), 0);
+assert_return(() => call($16, "load8_u", [22_685]), 0);
 
 // memory_copy.wast:2995
-assert_return(() => call($16, "load8_u", [10_745]), 0);
+assert_return(() => call($16, "load8_u", [22_884]), 0);
 
 // memory_copy.wast:2996
-assert_return(() => call($16, "load8_u", [10_944]), 0);
+assert_return(() => call($16, "load8_u", [23_083]), 0);
 
 // memory_copy.wast:2997
-assert_return(() => call($16, "load8_u", [11_143]), 0);
+assert_return(() => call($16, "load8_u", [23_282]), 0);
 
 // memory_copy.wast:2998
-assert_return(() => call($16, "load8_u", [11_342]), 0);
+assert_return(() => call($16, "load8_u", [23_481]), 0);
 
 // memory_copy.wast:2999
-assert_return(() => call($16, "load8_u", [11_541]), 0);
+assert_return(() => call($16, "load8_u", [23_680]), 0);
 
 // memory_copy.wast:3000
-assert_return(() => call($16, "load8_u", [11_740]), 0);
+assert_return(() => call($16, "load8_u", [23_879]), 0);
 
 // memory_copy.wast:3001
-assert_return(() => call($16, "load8_u", [11_939]), 0);
+assert_return(() => call($16, "load8_u", [24_078]), 0);
 
 // memory_copy.wast:3002
-assert_return(() => call($16, "load8_u", [12_138]), 0);
+assert_return(() => call($16, "load8_u", [24_277]), 0);
 
 // memory_copy.wast:3003
-assert_return(() => call($16, "load8_u", [12_337]), 0);
+assert_return(() => call($16, "load8_u", [24_476]), 0);
 
 // memory_copy.wast:3004
-assert_return(() => call($16, "load8_u", [12_536]), 0);
+assert_return(() => call($16, "load8_u", [24_675]), 0);
 
 // memory_copy.wast:3005
-assert_return(() => call($16, "load8_u", [12_735]), 0);
+assert_return(() => call($16, "load8_u", [24_874]), 0);
 
 // memory_copy.wast:3006
-assert_return(() => call($16, "load8_u", [12_934]), 0);
+assert_return(() => call($16, "load8_u", [25_073]), 0);
 
 // memory_copy.wast:3007
-assert_return(() => call($16, "load8_u", [13_133]), 0);
+assert_return(() => call($16, "load8_u", [25_272]), 0);
 
 // memory_copy.wast:3008
-assert_return(() => call($16, "load8_u", [13_332]), 0);
+assert_return(() => call($16, "load8_u", [25_471]), 0);
 
 // memory_copy.wast:3009
-assert_return(() => call($16, "load8_u", [13_531]), 0);
+assert_return(() => call($16, "load8_u", [25_670]), 0);
 
 // memory_copy.wast:3010
-assert_return(() => call($16, "load8_u", [13_730]), 0);
+assert_return(() => call($16, "load8_u", [25_869]), 0);
 
 // memory_copy.wast:3011
-assert_return(() => call($16, "load8_u", [13_929]), 0);
+assert_return(() => call($16, "load8_u", [26_068]), 0);
 
 // memory_copy.wast:3012
-assert_return(() => call($16, "load8_u", [14_128]), 0);
+assert_return(() => call($16, "load8_u", [26_267]), 0);
 
 // memory_copy.wast:3013
-assert_return(() => call($16, "load8_u", [14_327]), 0);
+assert_return(() => call($16, "load8_u", [26_466]), 0);
 
 // memory_copy.wast:3014
-assert_return(() => call($16, "load8_u", [14_526]), 0);
+assert_return(() => call($16, "load8_u", [26_665]), 0);
 
 // memory_copy.wast:3015
-assert_return(() => call($16, "load8_u", [14_725]), 0);
+assert_return(() => call($16, "load8_u", [26_864]), 0);
 
 // memory_copy.wast:3016
-assert_return(() => call($16, "load8_u", [14_924]), 0);
+assert_return(() => call($16, "load8_u", [27_063]), 0);
 
 // memory_copy.wast:3017
-assert_return(() => call($16, "load8_u", [15_123]), 0);
+assert_return(() => call($16, "load8_u", [27_262]), 0);
 
 // memory_copy.wast:3018
-assert_return(() => call($16, "load8_u", [15_322]), 0);
+assert_return(() => call($16, "load8_u", [27_461]), 0);
 
 // memory_copy.wast:3019
-assert_return(() => call($16, "load8_u", [15_521]), 0);
+assert_return(() => call($16, "load8_u", [27_660]), 0);
 
 // memory_copy.wast:3020
-assert_return(() => call($16, "load8_u", [15_720]), 0);
+assert_return(() => call($16, "load8_u", [27_859]), 0);
 
 // memory_copy.wast:3021
-assert_return(() => call($16, "load8_u", [15_919]), 0);
+assert_return(() => call($16, "load8_u", [28_058]), 0);
 
 // memory_copy.wast:3022
-assert_return(() => call($16, "load8_u", [16_118]), 0);
+assert_return(() => call($16, "load8_u", [28_257]), 0);
 
 // memory_copy.wast:3023
-assert_return(() => call($16, "load8_u", [16_317]), 0);
+assert_return(() => call($16, "load8_u", [28_456]), 0);
 
 // memory_copy.wast:3024
-assert_return(() => call($16, "load8_u", [16_516]), 0);
+assert_return(() => call($16, "load8_u", [28_655]), 0);
 
 // memory_copy.wast:3025
-assert_return(() => call($16, "load8_u", [16_715]), 0);
+assert_return(() => call($16, "load8_u", [28_854]), 0);
 
 // memory_copy.wast:3026
-assert_return(() => call($16, "load8_u", [16_914]), 0);
+assert_return(() => call($16, "load8_u", [29_053]), 0);
 
 // memory_copy.wast:3027
-assert_return(() => call($16, "load8_u", [17_113]), 0);
+assert_return(() => call($16, "load8_u", [29_252]), 0);
 
 // memory_copy.wast:3028
-assert_return(() => call($16, "load8_u", [17_312]), 0);
+assert_return(() => call($16, "load8_u", [29_451]), 0);
 
 // memory_copy.wast:3029
-assert_return(() => call($16, "load8_u", [17_511]), 0);
+assert_return(() => call($16, "load8_u", [29_650]), 0);
 
 // memory_copy.wast:3030
-assert_return(() => call($16, "load8_u", [17_710]), 0);
+assert_return(() => call($16, "load8_u", [29_849]), 0);
 
 // memory_copy.wast:3031
-assert_return(() => call($16, "load8_u", [17_909]), 0);
+assert_return(() => call($16, "load8_u", [30_048]), 0);
 
 // memory_copy.wast:3032
-assert_return(() => call($16, "load8_u", [18_108]), 0);
+assert_return(() => call($16, "load8_u", [30_247]), 0);
 
 // memory_copy.wast:3033
-assert_return(() => call($16, "load8_u", [18_307]), 0);
+assert_return(() => call($16, "load8_u", [30_446]), 0);
 
 // memory_copy.wast:3034
-assert_return(() => call($16, "load8_u", [18_506]), 0);
+assert_return(() => call($16, "load8_u", [30_645]), 0);
 
 // memory_copy.wast:3035
-assert_return(() => call($16, "load8_u", [18_705]), 0);
+assert_return(() => call($16, "load8_u", [30_844]), 0);
 
 // memory_copy.wast:3036
-assert_return(() => call($16, "load8_u", [18_904]), 0);
+assert_return(() => call($16, "load8_u", [31_043]), 0);
 
 // memory_copy.wast:3037
-assert_return(() => call($16, "load8_u", [19_103]), 0);
+assert_return(() => call($16, "load8_u", [31_242]), 0);
 
 // memory_copy.wast:3038
-assert_return(() => call($16, "load8_u", [19_302]), 0);
+assert_return(() => call($16, "load8_u", [31_441]), 0);
 
 // memory_copy.wast:3039
-assert_return(() => call($16, "load8_u", [19_501]), 0);
+assert_return(() => call($16, "load8_u", [31_640]), 0);
 
 // memory_copy.wast:3040
-assert_return(() => call($16, "load8_u", [19_700]), 0);
+assert_return(() => call($16, "load8_u", [31_839]), 0);
 
 // memory_copy.wast:3041
-assert_return(() => call($16, "load8_u", [19_899]), 0);
+assert_return(() => call($16, "load8_u", [32_038]), 0);
 
 // memory_copy.wast:3042
-assert_return(() => call($16, "load8_u", [20_098]), 0);
+assert_return(() => call($16, "load8_u", [32_237]), 0);
 
 // memory_copy.wast:3043
-assert_return(() => call($16, "load8_u", [20_297]), 0);
+assert_return(() => call($16, "load8_u", [32_436]), 0);
 
 // memory_copy.wast:3044
-assert_return(() => call($16, "load8_u", [20_496]), 0);
+assert_return(() => call($16, "load8_u", [32_635]), 0);
 
 // memory_copy.wast:3045
-assert_return(() => call($16, "load8_u", [20_695]), 0);
+assert_return(() => call($16, "load8_u", [32_834]), 0);
 
 // memory_copy.wast:3046
-assert_return(() => call($16, "load8_u", [20_894]), 0);
+assert_return(() => call($16, "load8_u", [33_033]), 0);
 
 // memory_copy.wast:3047
-assert_return(() => call($16, "load8_u", [21_093]), 0);
+assert_return(() => call($16, "load8_u", [33_232]), 0);
 
 // memory_copy.wast:3048
-assert_return(() => call($16, "load8_u", [21_292]), 0);
+assert_return(() => call($16, "load8_u", [33_431]), 0);
 
 // memory_copy.wast:3049
-assert_return(() => call($16, "load8_u", [21_491]), 0);
+assert_return(() => call($16, "load8_u", [33_630]), 0);
 
 // memory_copy.wast:3050
-assert_return(() => call($16, "load8_u", [21_690]), 0);
+assert_return(() => call($16, "load8_u", [33_829]), 0);
 
 // memory_copy.wast:3051
-assert_return(() => call($16, "load8_u", [21_889]), 0);
+assert_return(() => call($16, "load8_u", [34_028]), 0);
 
 // memory_copy.wast:3052
-assert_return(() => call($16, "load8_u", [22_088]), 0);
+assert_return(() => call($16, "load8_u", [34_227]), 0);
 
 // memory_copy.wast:3053
-assert_return(() => call($16, "load8_u", [22_287]), 0);
+assert_return(() => call($16, "load8_u", [34_426]), 0);
 
 // memory_copy.wast:3054
-assert_return(() => call($16, "load8_u", [22_486]), 0);
+assert_return(() => call($16, "load8_u", [34_625]), 0);
 
 // memory_copy.wast:3055
-assert_return(() => call($16, "load8_u", [22_685]), 0);
+assert_return(() => call($16, "load8_u", [34_824]), 0);
 
 // memory_copy.wast:3056
-assert_return(() => call($16, "load8_u", [22_884]), 0);
+assert_return(() => call($16, "load8_u", [35_023]), 0);
 
 // memory_copy.wast:3057
-assert_return(() => call($16, "load8_u", [23_083]), 0);
+assert_return(() => call($16, "load8_u", [35_222]), 0);
 
 // memory_copy.wast:3058
-assert_return(() => call($16, "load8_u", [23_282]), 0);
+assert_return(() => call($16, "load8_u", [35_421]), 0);
 
 // memory_copy.wast:3059
-assert_return(() => call($16, "load8_u", [23_481]), 0);
+assert_return(() => call($16, "load8_u", [35_620]), 0);
 
 // memory_copy.wast:3060
-assert_return(() => call($16, "load8_u", [23_680]), 0);
+assert_return(() => call($16, "load8_u", [35_819]), 0);
 
 // memory_copy.wast:3061
-assert_return(() => call($16, "load8_u", [23_879]), 0);
+assert_return(() => call($16, "load8_u", [36_018]), 0);
 
 // memory_copy.wast:3062
-assert_return(() => call($16, "load8_u", [24_078]), 0);
+assert_return(() => call($16, "load8_u", [36_217]), 0);
 
 // memory_copy.wast:3063
-assert_return(() => call($16, "load8_u", [24_277]), 0);
+assert_return(() => call($16, "load8_u", [36_416]), 0);
 
 // memory_copy.wast:3064
-assert_return(() => call($16, "load8_u", [24_476]), 0);
+assert_return(() => call($16, "load8_u", [36_615]), 0);
 
 // memory_copy.wast:3065
-assert_return(() => call($16, "load8_u", [24_675]), 0);
+assert_return(() => call($16, "load8_u", [36_814]), 0);
 
 // memory_copy.wast:3066
-assert_return(() => call($16, "load8_u", [24_874]), 0);
+assert_return(() => call($16, "load8_u", [37_013]), 0);
 
 // memory_copy.wast:3067
-assert_return(() => call($16, "load8_u", [25_073]), 0);
+assert_return(() => call($16, "load8_u", [37_212]), 0);
 
 // memory_copy.wast:3068
-assert_return(() => call($16, "load8_u", [25_272]), 0);
+assert_return(() => call($16, "load8_u", [37_411]), 0);
 
 // memory_copy.wast:3069
-assert_return(() => call($16, "load8_u", [25_471]), 0);
+assert_return(() => call($16, "load8_u", [37_610]), 0);
 
 // memory_copy.wast:3070
-assert_return(() => call($16, "load8_u", [25_670]), 0);
+assert_return(() => call($16, "load8_u", [37_809]), 0);
 
 // memory_copy.wast:3071
-assert_return(() => call($16, "load8_u", [25_869]), 0);
+assert_return(() => call($16, "load8_u", [38_008]), 0);
 
 // memory_copy.wast:3072
-assert_return(() => call($16, "load8_u", [26_068]), 0);
+assert_return(() => call($16, "load8_u", [38_207]), 0);
 
 // memory_copy.wast:3073
-assert_return(() => call($16, "load8_u", [26_267]), 0);
+assert_return(() => call($16, "load8_u", [38_406]), 0);
 
 // memory_copy.wast:3074
-assert_return(() => call($16, "load8_u", [26_466]), 0);
+assert_return(() => call($16, "load8_u", [38_605]), 0);
 
 // memory_copy.wast:3075
-assert_return(() => call($16, "load8_u", [26_665]), 0);
+assert_return(() => call($16, "load8_u", [38_804]), 0);
 
 // memory_copy.wast:3076
-assert_return(() => call($16, "load8_u", [26_864]), 0);
+assert_return(() => call($16, "load8_u", [39_003]), 0);
 
 // memory_copy.wast:3077
-assert_return(() => call($16, "load8_u", [27_063]), 0);
+assert_return(() => call($16, "load8_u", [39_202]), 0);
 
 // memory_copy.wast:3078
-assert_return(() => call($16, "load8_u", [27_262]), 0);
+assert_return(() => call($16, "load8_u", [39_401]), 0);
 
 // memory_copy.wast:3079
-assert_return(() => call($16, "load8_u", [27_461]), 0);
+assert_return(() => call($16, "load8_u", [39_600]), 0);
 
 // memory_copy.wast:3080
-assert_return(() => call($16, "load8_u", [27_660]), 0);
+assert_return(() => call($16, "load8_u", [39_799]), 0);
 
 // memory_copy.wast:3081
-assert_return(() => call($16, "load8_u", [27_859]), 0);
+assert_return(() => call($16, "load8_u", [39_998]), 0);
 
 // memory_copy.wast:3082
-assert_return(() => call($16, "load8_u", [28_058]), 0);
+assert_return(() => call($16, "load8_u", [40_197]), 0);
 
 // memory_copy.wast:3083
-assert_return(() => call($16, "load8_u", [28_257]), 0);
+assert_return(() => call($16, "load8_u", [40_396]), 0);
 
 // memory_copy.wast:3084
-assert_return(() => call($16, "load8_u", [28_456]), 0);
+assert_return(() => call($16, "load8_u", [40_595]), 0);
 
 // memory_copy.wast:3085
-assert_return(() => call($16, "load8_u", [28_655]), 0);
+assert_return(() => call($16, "load8_u", [40_794]), 0);
 
 // memory_copy.wast:3086
-assert_return(() => call($16, "load8_u", [28_854]), 0);
+assert_return(() => call($16, "load8_u", [40_993]), 0);
 
 // memory_copy.wast:3087
-assert_return(() => call($16, "load8_u", [29_053]), 0);
+assert_return(() => call($16, "load8_u", [41_192]), 0);
 
 // memory_copy.wast:3088
-assert_return(() => call($16, "load8_u", [29_252]), 0);
+assert_return(() => call($16, "load8_u", [41_391]), 0);
 
 // memory_copy.wast:3089
-assert_return(() => call($16, "load8_u", [29_451]), 0);
+assert_return(() => call($16, "load8_u", [41_590]), 0);
 
 // memory_copy.wast:3090
-assert_return(() => call($16, "load8_u", [29_650]), 0);
+assert_return(() => call($16, "load8_u", [41_789]), 0);
 
 // memory_copy.wast:3091
-assert_return(() => call($16, "load8_u", [29_849]), 0);
+assert_return(() => call($16, "load8_u", [41_988]), 0);
 
 // memory_copy.wast:3092
-assert_return(() => call($16, "load8_u", [30_048]), 0);
+assert_return(() => call($16, "load8_u", [42_187]), 0);
 
 // memory_copy.wast:3093
-assert_return(() => call($16, "load8_u", [30_247]), 0);
+assert_return(() => call($16, "load8_u", [42_386]), 0);
 
 // memory_copy.wast:3094
-assert_return(() => call($16, "load8_u", [30_446]), 0);
+assert_return(() => call($16, "load8_u", [42_585]), 0);
 
 // memory_copy.wast:3095
-assert_return(() => call($16, "load8_u", [30_645]), 0);
+assert_return(() => call($16, "load8_u", [42_784]), 0);
 
 // memory_copy.wast:3096
-assert_return(() => call($16, "load8_u", [30_844]), 0);
+assert_return(() => call($16, "load8_u", [42_983]), 0);
 
 // memory_copy.wast:3097
-assert_return(() => call($16, "load8_u", [31_043]), 0);
+assert_return(() => call($16, "load8_u", [43_182]), 0);
 
 // memory_copy.wast:3098
-assert_return(() => call($16, "load8_u", [31_242]), 0);
+assert_return(() => call($16, "load8_u", [43_381]), 0);
 
 // memory_copy.wast:3099
-assert_return(() => call($16, "load8_u", [31_441]), 0);
+assert_return(() => call($16, "load8_u", [43_580]), 0);
 
 // memory_copy.wast:3100
-assert_return(() => call($16, "load8_u", [31_640]), 0);
+assert_return(() => call($16, "load8_u", [43_779]), 0);
 
 // memory_copy.wast:3101
-assert_return(() => call($16, "load8_u", [31_839]), 0);
+assert_return(() => call($16, "load8_u", [43_978]), 0);
 
 // memory_copy.wast:3102
-assert_return(() => call($16, "load8_u", [32_038]), 0);
+assert_return(() => call($16, "load8_u", [44_177]), 0);
 
 // memory_copy.wast:3103
-assert_return(() => call($16, "load8_u", [32_237]), 0);
+assert_return(() => call($16, "load8_u", [44_376]), 0);
 
 // memory_copy.wast:3104
-assert_return(() => call($16, "load8_u", [32_436]), 0);
+assert_return(() => call($16, "load8_u", [44_575]), 0);
 
 // memory_copy.wast:3105
-assert_return(() => call($16, "load8_u", [32_635]), 0);
+assert_return(() => call($16, "load8_u", [44_774]), 0);
 
 // memory_copy.wast:3106
-assert_return(() => call($16, "load8_u", [32_834]), 0);
+assert_return(() => call($16, "load8_u", [44_973]), 0);
 
 // memory_copy.wast:3107
-assert_return(() => call($16, "load8_u", [33_033]), 0);
+assert_return(() => call($16, "load8_u", [45_172]), 0);
 
 // memory_copy.wast:3108
-assert_return(() => call($16, "load8_u", [33_232]), 0);
+assert_return(() => call($16, "load8_u", [45_371]), 0);
 
 // memory_copy.wast:3109
-assert_return(() => call($16, "load8_u", [33_431]), 0);
+assert_return(() => call($16, "load8_u", [45_570]), 0);
 
 // memory_copy.wast:3110
-assert_return(() => call($16, "load8_u", [33_630]), 0);
+assert_return(() => call($16, "load8_u", [45_769]), 0);
 
 // memory_copy.wast:3111
-assert_return(() => call($16, "load8_u", [33_829]), 0);
+assert_return(() => call($16, "load8_u", [45_968]), 0);
 
 // memory_copy.wast:3112
-assert_return(() => call($16, "load8_u", [34_028]), 0);
+assert_return(() => call($16, "load8_u", [46_167]), 0);
 
 // memory_copy.wast:3113
-assert_return(() => call($16, "load8_u", [34_227]), 0);
+assert_return(() => call($16, "load8_u", [46_366]), 0);
 
 // memory_copy.wast:3114
-assert_return(() => call($16, "load8_u", [34_426]), 0);
+assert_return(() => call($16, "load8_u", [46_565]), 0);
 
 // memory_copy.wast:3115
-assert_return(() => call($16, "load8_u", [34_625]), 0);
+assert_return(() => call($16, "load8_u", [46_764]), 0);
 
 // memory_copy.wast:3116
-assert_return(() => call($16, "load8_u", [34_824]), 0);
+assert_return(() => call($16, "load8_u", [46_963]), 0);
 
 // memory_copy.wast:3117
-assert_return(() => call($16, "load8_u", [35_023]), 0);
+assert_return(() => call($16, "load8_u", [47_162]), 0);
 
 // memory_copy.wast:3118
-assert_return(() => call($16, "load8_u", [35_222]), 0);
+assert_return(() => call($16, "load8_u", [47_361]), 0);
 
 // memory_copy.wast:3119
-assert_return(() => call($16, "load8_u", [35_421]), 0);
+assert_return(() => call($16, "load8_u", [47_560]), 0);
 
 // memory_copy.wast:3120
-assert_return(() => call($16, "load8_u", [35_620]), 0);
+assert_return(() => call($16, "load8_u", [47_759]), 0);
 
 // memory_copy.wast:3121
-assert_return(() => call($16, "load8_u", [35_819]), 0);
+assert_return(() => call($16, "load8_u", [47_958]), 0);
 
 // memory_copy.wast:3122
-assert_return(() => call($16, "load8_u", [36_018]), 0);
+assert_return(() => call($16, "load8_u", [48_157]), 0);
 
 // memory_copy.wast:3123
-assert_return(() => call($16, "load8_u", [36_217]), 0);
+assert_return(() => call($16, "load8_u", [48_356]), 0);
 
 // memory_copy.wast:3124
-assert_return(() => call($16, "load8_u", [36_416]), 0);
+assert_return(() => call($16, "load8_u", [48_555]), 0);
 
 // memory_copy.wast:3125
-assert_return(() => call($16, "load8_u", [36_615]), 0);
+assert_return(() => call($16, "load8_u", [48_754]), 0);
 
 // memory_copy.wast:3126
-assert_return(() => call($16, "load8_u", [36_814]), 0);
+assert_return(() => call($16, "load8_u", [48_953]), 0);
 
 // memory_copy.wast:3127
-assert_return(() => call($16, "load8_u", [37_013]), 0);
+assert_return(() => call($16, "load8_u", [49_152]), 0);
 
 // memory_copy.wast:3128
-assert_return(() => call($16, "load8_u", [37_212]), 0);
+assert_return(() => call($16, "load8_u", [49_351]), 0);
 
 // memory_copy.wast:3129
-assert_return(() => call($16, "load8_u", [37_411]), 0);
+assert_return(() => call($16, "load8_u", [49_550]), 0);
 
 // memory_copy.wast:3130
-assert_return(() => call($16, "load8_u", [37_610]), 0);
+assert_return(() => call($16, "load8_u", [49_749]), 0);
 
 // memory_copy.wast:3131
-assert_return(() => call($16, "load8_u", [37_809]), 0);
+assert_return(() => call($16, "load8_u", [49_948]), 0);
 
 // memory_copy.wast:3132
-assert_return(() => call($16, "load8_u", [38_008]), 0);
+assert_return(() => call($16, "load8_u", [50_147]), 0);
 
 // memory_copy.wast:3133
-assert_return(() => call($16, "load8_u", [38_207]), 0);
+assert_return(() => call($16, "load8_u", [50_346]), 0);
 
 // memory_copy.wast:3134
-assert_return(() => call($16, "load8_u", [38_406]), 0);
+assert_return(() => call($16, "load8_u", [50_545]), 0);
 
 // memory_copy.wast:3135
-assert_return(() => call($16, "load8_u", [38_605]), 0);
+assert_return(() => call($16, "load8_u", [50_744]), 0);
 
 // memory_copy.wast:3136
-assert_return(() => call($16, "load8_u", [38_804]), 0);
+assert_return(() => call($16, "load8_u", [50_943]), 0);
 
 // memory_copy.wast:3137
-assert_return(() => call($16, "load8_u", [39_003]), 0);
+assert_return(() => call($16, "load8_u", [51_142]), 0);
 
 // memory_copy.wast:3138
-assert_return(() => call($16, "load8_u", [39_202]), 0);
+assert_return(() => call($16, "load8_u", [51_341]), 0);
 
 // memory_copy.wast:3139
-assert_return(() => call($16, "load8_u", [39_401]), 0);
+assert_return(() => call($16, "load8_u", [51_540]), 0);
 
 // memory_copy.wast:3140
-assert_return(() => call($16, "load8_u", [39_600]), 0);
+assert_return(() => call($16, "load8_u", [51_739]), 0);
 
 // memory_copy.wast:3141
-assert_return(() => call($16, "load8_u", [39_799]), 0);
+assert_return(() => call($16, "load8_u", [51_938]), 0);
 
 // memory_copy.wast:3142
-assert_return(() => call($16, "load8_u", [39_998]), 0);
+assert_return(() => call($16, "load8_u", [52_137]), 0);
 
 // memory_copy.wast:3143
-assert_return(() => call($16, "load8_u", [40_197]), 0);
+assert_return(() => call($16, "load8_u", [52_336]), 0);
 
 // memory_copy.wast:3144
-assert_return(() => call($16, "load8_u", [40_396]), 0);
+assert_return(() => call($16, "load8_u", [52_535]), 0);
 
 // memory_copy.wast:3145
-assert_return(() => call($16, "load8_u", [40_595]), 0);
+assert_return(() => call($16, "load8_u", [52_734]), 0);
 
 // memory_copy.wast:3146
-assert_return(() => call($16, "load8_u", [40_794]), 0);
+assert_return(() => call($16, "load8_u", [52_933]), 0);
 
 // memory_copy.wast:3147
-assert_return(() => call($16, "load8_u", [40_993]), 0);
+assert_return(() => call($16, "load8_u", [53_132]), 0);
 
 // memory_copy.wast:3148
-assert_return(() => call($16, "load8_u", [41_192]), 0);
+assert_return(() => call($16, "load8_u", [53_331]), 0);
 
 // memory_copy.wast:3149
-assert_return(() => call($16, "load8_u", [41_391]), 0);
+assert_return(() => call($16, "load8_u", [53_530]), 0);
 
 // memory_copy.wast:3150
-assert_return(() => call($16, "load8_u", [41_590]), 0);
+assert_return(() => call($16, "load8_u", [53_729]), 0);
 
 // memory_copy.wast:3151
-assert_return(() => call($16, "load8_u", [41_789]), 0);
+assert_return(() => call($16, "load8_u", [53_928]), 0);
 
 // memory_copy.wast:3152
-assert_return(() => call($16, "load8_u", [41_988]), 0);
+assert_return(() => call($16, "load8_u", [54_127]), 0);
 
 // memory_copy.wast:3153
-assert_return(() => call($16, "load8_u", [42_187]), 0);
+assert_return(() => call($16, "load8_u", [54_326]), 0);
 
 // memory_copy.wast:3154
-assert_return(() => call($16, "load8_u", [42_386]), 0);
+assert_return(() => call($16, "load8_u", [54_525]), 0);
 
 // memory_copy.wast:3155
-assert_return(() => call($16, "load8_u", [42_585]), 0);
+assert_return(() => call($16, "load8_u", [54_724]), 0);
 
 // memory_copy.wast:3156
-assert_return(() => call($16, "load8_u", [42_784]), 0);
+assert_return(() => call($16, "load8_u", [54_923]), 0);
 
 // memory_copy.wast:3157
-assert_return(() => call($16, "load8_u", [42_983]), 0);
+assert_return(() => call($16, "load8_u", [55_122]), 0);
 
 // memory_copy.wast:3158
-assert_return(() => call($16, "load8_u", [43_182]), 0);
+assert_return(() => call($16, "load8_u", [55_321]), 0);
 
 // memory_copy.wast:3159
-assert_return(() => call($16, "load8_u", [43_381]), 0);
+assert_return(() => call($16, "load8_u", [55_520]), 0);
 
 // memory_copy.wast:3160
-assert_return(() => call($16, "load8_u", [43_580]), 0);
+assert_return(() => call($16, "load8_u", [55_719]), 0);
 
 // memory_copy.wast:3161
-assert_return(() => call($16, "load8_u", [43_779]), 0);
+assert_return(() => call($16, "load8_u", [55_918]), 0);
 
 // memory_copy.wast:3162
-assert_return(() => call($16, "load8_u", [43_978]), 0);
+assert_return(() => call($16, "load8_u", [56_117]), 0);
 
 // memory_copy.wast:3163
-assert_return(() => call($16, "load8_u", [44_177]), 0);
+assert_return(() => call($16, "load8_u", [56_316]), 0);
 
 // memory_copy.wast:3164
-assert_return(() => call($16, "load8_u", [44_376]), 0);
+assert_return(() => call($16, "load8_u", [56_515]), 0);
 
 // memory_copy.wast:3165
-assert_return(() => call($16, "load8_u", [44_575]), 0);
+assert_return(() => call($16, "load8_u", [56_714]), 0);
 
 // memory_copy.wast:3166
-assert_return(() => call($16, "load8_u", [44_774]), 0);
+assert_return(() => call($16, "load8_u", [56_913]), 0);
 
 // memory_copy.wast:3167
-assert_return(() => call($16, "load8_u", [44_973]), 0);
+assert_return(() => call($16, "load8_u", [57_112]), 0);
 
 // memory_copy.wast:3168
-assert_return(() => call($16, "load8_u", [45_172]), 0);
+assert_return(() => call($16, "load8_u", [57_311]), 0);
 
 // memory_copy.wast:3169
-assert_return(() => call($16, "load8_u", [45_371]), 0);
+assert_return(() => call($16, "load8_u", [57_510]), 0);
 
 // memory_copy.wast:3170
-assert_return(() => call($16, "load8_u", [45_570]), 0);
+assert_return(() => call($16, "load8_u", [57_709]), 0);
 
 // memory_copy.wast:3171
-assert_return(() => call($16, "load8_u", [45_769]), 0);
+assert_return(() => call($16, "load8_u", [57_908]), 0);
 
 // memory_copy.wast:3172
-assert_return(() => call($16, "load8_u", [45_968]), 0);
+assert_return(() => call($16, "load8_u", [58_107]), 0);
 
 // memory_copy.wast:3173
-assert_return(() => call($16, "load8_u", [46_167]), 0);
+assert_return(() => call($16, "load8_u", [58_306]), 0);
 
 // memory_copy.wast:3174
-assert_return(() => call($16, "load8_u", [46_366]), 0);
+assert_return(() => call($16, "load8_u", [58_505]), 0);
 
 // memory_copy.wast:3175
-assert_return(() => call($16, "load8_u", [46_565]), 0);
+assert_return(() => call($16, "load8_u", [58_704]), 0);
 
 // memory_copy.wast:3176
-assert_return(() => call($16, "load8_u", [46_764]), 0);
+assert_return(() => call($16, "load8_u", [58_903]), 0);
 
 // memory_copy.wast:3177
-assert_return(() => call($16, "load8_u", [46_963]), 0);
+assert_return(() => call($16, "load8_u", [59_102]), 0);
 
 // memory_copy.wast:3178
-assert_return(() => call($16, "load8_u", [47_162]), 0);
+assert_return(() => call($16, "load8_u", [59_301]), 0);
 
 // memory_copy.wast:3179
-assert_return(() => call($16, "load8_u", [47_361]), 0);
+assert_return(() => call($16, "load8_u", [59_500]), 0);
 
 // memory_copy.wast:3180
-assert_return(() => call($16, "load8_u", [47_560]), 0);
+assert_return(() => call($16, "load8_u", [59_699]), 0);
 
 // memory_copy.wast:3181
-assert_return(() => call($16, "load8_u", [47_759]), 0);
+assert_return(() => call($16, "load8_u", [59_898]), 0);
 
 // memory_copy.wast:3182
-assert_return(() => call($16, "load8_u", [47_958]), 0);
+assert_return(() => call($16, "load8_u", [60_097]), 0);
 
 // memory_copy.wast:3183
-assert_return(() => call($16, "load8_u", [48_157]), 0);
+assert_return(() => call($16, "load8_u", [60_296]), 0);
 
 // memory_copy.wast:3184
-assert_return(() => call($16, "load8_u", [48_356]), 0);
+assert_return(() => call($16, "load8_u", [60_495]), 0);
 
 // memory_copy.wast:3185
-assert_return(() => call($16, "load8_u", [48_555]), 0);
+assert_return(() => call($16, "load8_u", [60_694]), 0);
 
 // memory_copy.wast:3186
-assert_return(() => call($16, "load8_u", [48_754]), 0);
+assert_return(() => call($16, "load8_u", [60_893]), 0);
 
 // memory_copy.wast:3187
-assert_return(() => call($16, "load8_u", [48_953]), 0);
+assert_return(() => call($16, "load8_u", [61_092]), 0);
 
 // memory_copy.wast:3188
-assert_return(() => call($16, "load8_u", [49_152]), 0);
+assert_return(() => call($16, "load8_u", [61_291]), 0);
 
 // memory_copy.wast:3189
-assert_return(() => call($16, "load8_u", [49_351]), 0);
+assert_return(() => call($16, "load8_u", [61_490]), 0);
 
 // memory_copy.wast:3190
-assert_return(() => call($16, "load8_u", [49_550]), 0);
+assert_return(() => call($16, "load8_u", [61_689]), 0);
 
 // memory_copy.wast:3191
-assert_return(() => call($16, "load8_u", [49_749]), 0);
+assert_return(() => call($16, "load8_u", [61_888]), 0);
 
 // memory_copy.wast:3192
-assert_return(() => call($16, "load8_u", [49_948]), 0);
+assert_return(() => call($16, "load8_u", [62_087]), 0);
 
 // memory_copy.wast:3193
-assert_return(() => call($16, "load8_u", [50_147]), 0);
+assert_return(() => call($16, "load8_u", [62_286]), 0);
 
 // memory_copy.wast:3194
-assert_return(() => call($16, "load8_u", [50_346]), 0);
+assert_return(() => call($16, "load8_u", [62_485]), 0);
 
 // memory_copy.wast:3195
-assert_return(() => call($16, "load8_u", [50_545]), 0);
+assert_return(() => call($16, "load8_u", [62_684]), 0);
 
 // memory_copy.wast:3196
-assert_return(() => call($16, "load8_u", [50_744]), 0);
+assert_return(() => call($16, "load8_u", [62_883]), 0);
 
 // memory_copy.wast:3197
-assert_return(() => call($16, "load8_u", [50_943]), 0);
+assert_return(() => call($16, "load8_u", [63_082]), 0);
 
 // memory_copy.wast:3198
-assert_return(() => call($16, "load8_u", [51_142]), 0);
+assert_return(() => call($16, "load8_u", [63_281]), 0);
 
 // memory_copy.wast:3199
-assert_return(() => call($16, "load8_u", [51_341]), 0);
+assert_return(() => call($16, "load8_u", [63_480]), 0);
 
 // memory_copy.wast:3200
-assert_return(() => call($16, "load8_u", [51_540]), 0);
+assert_return(() => call($16, "load8_u", [63_679]), 0);
 
 // memory_copy.wast:3201
-assert_return(() => call($16, "load8_u", [51_739]), 0);
+assert_return(() => call($16, "load8_u", [63_878]), 0);
 
 // memory_copy.wast:3202
-assert_return(() => call($16, "load8_u", [51_938]), 0);
+assert_return(() => call($16, "load8_u", [64_077]), 0);
 
 // memory_copy.wast:3203
-assert_return(() => call($16, "load8_u", [52_137]), 0);
+assert_return(() => call($16, "load8_u", [64_276]), 0);
 
 // memory_copy.wast:3204
-assert_return(() => call($16, "load8_u", [52_336]), 0);
+assert_return(() => call($16, "load8_u", [64_475]), 0);
 
 // memory_copy.wast:3205
-assert_return(() => call($16, "load8_u", [52_535]), 0);
+assert_return(() => call($16, "load8_u", [64_674]), 0);
 
 // memory_copy.wast:3206
-assert_return(() => call($16, "load8_u", [52_734]), 0);
+assert_return(() => call($16, "load8_u", [64_873]), 0);
 
 // memory_copy.wast:3207
-assert_return(() => call($16, "load8_u", [52_933]), 0);
+assert_return(() => call($16, "load8_u", [65_072]), 0);
 
 // memory_copy.wast:3208
-assert_return(() => call($16, "load8_u", [53_132]), 0);
+assert_return(() => call($16, "load8_u", [65_271]), 0);
 
 // memory_copy.wast:3209
-assert_return(() => call($16, "load8_u", [53_331]), 0);
+assert_return(() => call($16, "load8_u", [65_470]), 0);
 
 // memory_copy.wast:3210
-assert_return(() => call($16, "load8_u", [53_530]), 0);
+assert_return(() => call($16, "load8_u", [65_516]), 0);
 
 // memory_copy.wast:3211
-assert_return(() => call($16, "load8_u", [53_729]), 0);
+assert_return(() => call($16, "load8_u", [65_517]), 1);
 
 // memory_copy.wast:3212
-assert_return(() => call($16, "load8_u", [53_928]), 0);
+assert_return(() => call($16, "load8_u", [65_518]), 2);
 
 // memory_copy.wast:3213
-assert_return(() => call($16, "load8_u", [54_127]), 0);
+assert_return(() => call($16, "load8_u", [65_519]), 3);
 
 // memory_copy.wast:3214
-assert_return(() => call($16, "load8_u", [54_326]), 0);
+assert_return(() => call($16, "load8_u", [65_520]), 4);
 
 // memory_copy.wast:3215
-assert_return(() => call($16, "load8_u", [54_525]), 0);
+assert_return(() => call($16, "load8_u", [65_521]), 5);
 
 // memory_copy.wast:3216
-assert_return(() => call($16, "load8_u", [54_724]), 0);
+assert_return(() => call($16, "load8_u", [65_522]), 6);
 
 // memory_copy.wast:3217
-assert_return(() => call($16, "load8_u", [54_923]), 0);
+assert_return(() => call($16, "load8_u", [65_523]), 7);
 
 // memory_copy.wast:3218
-assert_return(() => call($16, "load8_u", [55_122]), 0);
+assert_return(() => call($16, "load8_u", [65_524]), 8);
 
 // memory_copy.wast:3219
-assert_return(() => call($16, "load8_u", [55_321]), 0);
+assert_return(() => call($16, "load8_u", [65_525]), 9);
 
 // memory_copy.wast:3220
-assert_return(() => call($16, "load8_u", [55_520]), 0);
+assert_return(() => call($16, "load8_u", [65_526]), 10);
 
 // memory_copy.wast:3221
-assert_return(() => call($16, "load8_u", [55_719]), 0);
+assert_return(() => call($16, "load8_u", [65_527]), 11);
 
 // memory_copy.wast:3222
-assert_return(() => call($16, "load8_u", [55_918]), 0);
+assert_return(() => call($16, "load8_u", [65_528]), 12);
 
 // memory_copy.wast:3223
-assert_return(() => call($16, "load8_u", [56_117]), 0);
+assert_return(() => call($16, "load8_u", [65_529]), 13);
 
 // memory_copy.wast:3224
-assert_return(() => call($16, "load8_u", [56_316]), 0);
+assert_return(() => call($16, "load8_u", [65_530]), 14);
 
 // memory_copy.wast:3225
-assert_return(() => call($16, "load8_u", [56_515]), 0);
+assert_return(() => call($16, "load8_u", [65_531]), 15);
 
 // memory_copy.wast:3226
-assert_return(() => call($16, "load8_u", [56_714]), 0);
+assert_return(() => call($16, "load8_u", [65_532]), 16);
 
 // memory_copy.wast:3227
-assert_return(() => call($16, "load8_u", [56_913]), 0);
+assert_return(() => call($16, "load8_u", [65_533]), 17);
 
 // memory_copy.wast:3228
-assert_return(() => call($16, "load8_u", [57_112]), 0);
+assert_return(() => call($16, "load8_u", [65_534]), 18);
 
 // memory_copy.wast:3229
-assert_return(() => call($16, "load8_u", [57_311]), 0);
-
-// memory_copy.wast:3230
-assert_return(() => call($16, "load8_u", [57_510]), 0);
+assert_return(() => call($16, "load8_u", [65_535]), 19);
 
 // memory_copy.wast:3231
-assert_return(() => call($16, "load8_u", [57_709]), 0);
-
-// memory_copy.wast:3232
-assert_return(() => call($16, "load8_u", [57_908]), 0);
-
-// memory_copy.wast:3233
-assert_return(() => call($16, "load8_u", [58_107]), 0);
-
-// memory_copy.wast:3234
-assert_return(() => call($16, "load8_u", [58_306]), 0);
-
-// memory_copy.wast:3235
-assert_return(() => call($16, "load8_u", [58_505]), 0);
-
-// memory_copy.wast:3236
-assert_return(() => call($16, "load8_u", [58_704]), 0);
-
-// memory_copy.wast:3237
-assert_return(() => call($16, "load8_u", [58_903]), 0);
-
-// memory_copy.wast:3238
-assert_return(() => call($16, "load8_u", [59_102]), 0);
+let $17 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8c\x80\x80\x80\x00\x02\x60\x03\x7f\x7f\x7f\x00\x60\x01\x7f\x01\x7f\x03\x83\x80\x80\x80\x00\x02\x00\x01\x05\x84\x80\x80\x80\x00\x01\x01\x01\x01\x07\x97\x80\x80\x80\x00\x03\x03\x6d\x65\x6d\x02\x00\x03\x72\x75\x6e\x00\x00\x07\x6c\x6f\x61\x64\x38\x5f\x75\x00\x01\x0a\x9e\x80\x80\x80\x00\x02\x8c\x80\x80\x80\x00\x00\x20\x00\x20\x01\x20\x02\xfc\x0a\x00\x00\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x2d\x00\x00\x0b\x0b\x9c\x80\x80\x80\x00\x01\x00\x41\xec\xff\x03\x0b\x14\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10\x11\x12\x13");
 
 // memory_copy.wast:3239
-assert_return(() => call($16, "load8_u", [59_301]), 0);
-
-// memory_copy.wast:3240
-assert_return(() => call($16, "load8_u", [59_500]), 0);
-
-// memory_copy.wast:3241
-assert_return(() => call($16, "load8_u", [59_699]), 0);
+assert_trap(() => call($17, "run", [65_516, 65_516, 40]));
 
 // memory_copy.wast:3242
-assert_return(() => call($16, "load8_u", [59_898]), 0);
+assert_return(() => call($17, "load8_u", [198]), 0);
 
 // memory_copy.wast:3243
-assert_return(() => call($16, "load8_u", [60_097]), 0);
+assert_return(() => call($17, "load8_u", [397]), 0);
 
 // memory_copy.wast:3244
-assert_return(() => call($16, "load8_u", [60_296]), 0);
+assert_return(() => call($17, "load8_u", [596]), 0);
 
 // memory_copy.wast:3245
-assert_return(() => call($16, "load8_u", [60_495]), 0);
+assert_return(() => call($17, "load8_u", [795]), 0);
 
 // memory_copy.wast:3246
-assert_return(() => call($16, "load8_u", [60_694]), 0);
+assert_return(() => call($17, "load8_u", [994]), 0);
 
 // memory_copy.wast:3247
-assert_return(() => call($16, "load8_u", [60_893]), 0);
+assert_return(() => call($17, "load8_u", [1_193]), 0);
 
 // memory_copy.wast:3248
-assert_return(() => call($16, "load8_u", [61_092]), 0);
+assert_return(() => call($17, "load8_u", [1_392]), 0);
 
 // memory_copy.wast:3249
-assert_return(() => call($16, "load8_u", [61_291]), 0);
+assert_return(() => call($17, "load8_u", [1_591]), 0);
 
 // memory_copy.wast:3250
-assert_return(() => call($16, "load8_u", [61_490]), 0);
+assert_return(() => call($17, "load8_u", [1_790]), 0);
 
 // memory_copy.wast:3251
-assert_return(() => call($16, "load8_u", [61_689]), 0);
+assert_return(() => call($17, "load8_u", [1_989]), 0);
 
 // memory_copy.wast:3252
-assert_return(() => call($16, "load8_u", [61_888]), 0);
+assert_return(() => call($17, "load8_u", [2_188]), 0);
 
 // memory_copy.wast:3253
-assert_return(() => call($16, "load8_u", [62_087]), 0);
+assert_return(() => call($17, "load8_u", [2_387]), 0);
 
 // memory_copy.wast:3254
-assert_return(() => call($16, "load8_u", [62_286]), 0);
+assert_return(() => call($17, "load8_u", [2_586]), 0);
 
 // memory_copy.wast:3255
-assert_return(() => call($16, "load8_u", [62_485]), 0);
+assert_return(() => call($17, "load8_u", [2_785]), 0);
 
 // memory_copy.wast:3256
-assert_return(() => call($16, "load8_u", [62_684]), 0);
+assert_return(() => call($17, "load8_u", [2_984]), 0);
 
 // memory_copy.wast:3257
-assert_return(() => call($16, "load8_u", [62_883]), 0);
+assert_return(() => call($17, "load8_u", [3_183]), 0);
 
 // memory_copy.wast:3258
-assert_return(() => call($16, "load8_u", [63_082]), 0);
+assert_return(() => call($17, "load8_u", [3_382]), 0);
 
 // memory_copy.wast:3259
-assert_return(() => call($16, "load8_u", [63_281]), 0);
+assert_return(() => call($17, "load8_u", [3_581]), 0);
 
 // memory_copy.wast:3260
-assert_return(() => call($16, "load8_u", [63_480]), 0);
+assert_return(() => call($17, "load8_u", [3_780]), 0);
 
 // memory_copy.wast:3261
-assert_return(() => call($16, "load8_u", [63_679]), 0);
+assert_return(() => call($17, "load8_u", [3_979]), 0);
 
 // memory_copy.wast:3262
-assert_return(() => call($16, "load8_u", [63_878]), 0);
+assert_return(() => call($17, "load8_u", [4_178]), 0);
 
 // memory_copy.wast:3263
-assert_return(() => call($16, "load8_u", [64_077]), 0);
+assert_return(() => call($17, "load8_u", [4_377]), 0);
 
 // memory_copy.wast:3264
-assert_return(() => call($16, "load8_u", [64_276]), 0);
+assert_return(() => call($17, "load8_u", [4_576]), 0);
 
 // memory_copy.wast:3265
-assert_return(() => call($16, "load8_u", [64_475]), 0);
+assert_return(() => call($17, "load8_u", [4_775]), 0);
 
 // memory_copy.wast:3266
-assert_return(() => call($16, "load8_u", [64_674]), 0);
+assert_return(() => call($17, "load8_u", [4_974]), 0);
 
 // memory_copy.wast:3267
-assert_return(() => call($16, "load8_u", [64_873]), 0);
+assert_return(() => call($17, "load8_u", [5_173]), 0);
 
 // memory_copy.wast:3268
-assert_return(() => call($16, "load8_u", [65_072]), 0);
+assert_return(() => call($17, "load8_u", [5_372]), 0);
 
 // memory_copy.wast:3269
-assert_return(() => call($16, "load8_u", [65_271]), 0);
+assert_return(() => call($17, "load8_u", [5_571]), 0);
 
 // memory_copy.wast:3270
-assert_return(() => call($16, "load8_u", [65_470]), 0);
+assert_return(() => call($17, "load8_u", [5_770]), 0);
 
 // memory_copy.wast:3271
-assert_return(() => call($16, "load8_u", [65_506]), 0);
+assert_return(() => call($17, "load8_u", [5_969]), 0);
 
 // memory_copy.wast:3272
-assert_return(() => call($16, "load8_u", [65_507]), 1);
+assert_return(() => call($17, "load8_u", [6_168]), 0);
 
 // memory_copy.wast:3273
-assert_return(() => call($16, "load8_u", [65_508]), 2);
+assert_return(() => call($17, "load8_u", [6_367]), 0);
 
 // memory_copy.wast:3274
-assert_return(() => call($16, "load8_u", [65_509]), 3);
+assert_return(() => call($17, "load8_u", [6_566]), 0);
 
 // memory_copy.wast:3275
-assert_return(() => call($16, "load8_u", [65_510]), 4);
+assert_return(() => call($17, "load8_u", [6_765]), 0);
 
 // memory_copy.wast:3276
-assert_return(() => call($16, "load8_u", [65_511]), 5);
+assert_return(() => call($17, "load8_u", [6_964]), 0);
 
 // memory_copy.wast:3277
-assert_return(() => call($16, "load8_u", [65_512]), 6);
+assert_return(() => call($17, "load8_u", [7_163]), 0);
 
 // memory_copy.wast:3278
-assert_return(() => call($16, "load8_u", [65_513]), 7);
+assert_return(() => call($17, "load8_u", [7_362]), 0);
 
 // memory_copy.wast:3279
-assert_return(() => call($16, "load8_u", [65_514]), 8);
+assert_return(() => call($17, "load8_u", [7_561]), 0);
 
 // memory_copy.wast:3280
-assert_return(() => call($16, "load8_u", [65_515]), 9);
+assert_return(() => call($17, "load8_u", [7_760]), 0);
 
 // memory_copy.wast:3281
-assert_return(() => call($16, "load8_u", [65_516]), 10);
+assert_return(() => call($17, "load8_u", [7_959]), 0);
 
 // memory_copy.wast:3282
-assert_return(() => call($16, "load8_u", [65_517]), 11);
+assert_return(() => call($17, "load8_u", [8_158]), 0);
 
 // memory_copy.wast:3283
-assert_return(() => call($16, "load8_u", [65_518]), 12);
+assert_return(() => call($17, "load8_u", [8_357]), 0);
 
 // memory_copy.wast:3284
-assert_return(() => call($16, "load8_u", [65_519]), 13);
+assert_return(() => call($17, "load8_u", [8_556]), 0);
 
 // memory_copy.wast:3285
-assert_return(() => call($16, "load8_u", [65_520]), 14);
+assert_return(() => call($17, "load8_u", [8_755]), 0);
 
 // memory_copy.wast:3286
-assert_return(() => call($16, "load8_u", [65_521]), 15);
+assert_return(() => call($17, "load8_u", [8_954]), 0);
 
 // memory_copy.wast:3287
-assert_return(() => call($16, "load8_u", [65_522]), 16);
+assert_return(() => call($17, "load8_u", [9_153]), 0);
 
 // memory_copy.wast:3288
-assert_return(() => call($16, "load8_u", [65_523]), 17);
+assert_return(() => call($17, "load8_u", [9_352]), 0);
 
 // memory_copy.wast:3289
-assert_return(() => call($16, "load8_u", [65_524]), 18);
+assert_return(() => call($17, "load8_u", [9_551]), 0);
 
 // memory_copy.wast:3290
-assert_return(() => call($16, "load8_u", [65_525]), 19);
+assert_return(() => call($17, "load8_u", [9_750]), 0);
 
 // memory_copy.wast:3291
-assert_return(() => call($16, "load8_u", [65_526]), 10);
+assert_return(() => call($17, "load8_u", [9_949]), 0);
 
 // memory_copy.wast:3292
-assert_return(() => call($16, "load8_u", [65_527]), 11);
+assert_return(() => call($17, "load8_u", [10_148]), 0);
 
 // memory_copy.wast:3293
-assert_return(() => call($16, "load8_u", [65_528]), 12);
+assert_return(() => call($17, "load8_u", [10_347]), 0);
 
 // memory_copy.wast:3294
-assert_return(() => call($16, "load8_u", [65_529]), 13);
+assert_return(() => call($17, "load8_u", [10_546]), 0);
 
 // memory_copy.wast:3295
-assert_return(() => call($16, "load8_u", [65_530]), 14);
+assert_return(() => call($17, "load8_u", [10_745]), 0);
 
 // memory_copy.wast:3296
-assert_return(() => call($16, "load8_u", [65_531]), 15);
+assert_return(() => call($17, "load8_u", [10_944]), 0);
 
 // memory_copy.wast:3297
-assert_return(() => call($16, "load8_u", [65_532]), 16);
+assert_return(() => call($17, "load8_u", [11_143]), 0);
 
 // memory_copy.wast:3298
-assert_return(() => call($16, "load8_u", [65_533]), 17);
+assert_return(() => call($17, "load8_u", [11_342]), 0);
 
 // memory_copy.wast:3299
-assert_return(() => call($16, "load8_u", [65_534]), 18);
+assert_return(() => call($17, "load8_u", [11_541]), 0);
 
 // memory_copy.wast:3300
-assert_return(() => call($16, "load8_u", [65_535]), 19);
+assert_return(() => call($17, "load8_u", [11_740]), 0);
+
+// memory_copy.wast:3301
+assert_return(() => call($17, "load8_u", [11_939]), 0);
 
 // memory_copy.wast:3302
-let $17 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8c\x80\x80\x80\x00\x02\x60\x03\x7f\x7f\x7f\x00\x60\x01\x7f\x01\x7f\x03\x83\x80\x80\x80\x00\x02\x00\x01\x05\x84\x80\x80\x80\x00\x01\x01\x01\x01\x07\x97\x80\x80\x80\x00\x03\x03\x6d\x65\x6d\x02\x00\x03\x72\x75\x6e\x00\x00\x07\x6c\x6f\x61\x64\x38\x5f\x75\x00\x01\x0a\x9e\x80\x80\x80\x00\x02\x8c\x80\x80\x80\x00\x00\x20\x00\x20\x01\x20\x02\xfc\x0a\x00\x00\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x2d\x00\x00\x0b\x0b\x9c\x80\x80\x80\x00\x01\x00\x41\xec\xff\x03\x0b\x14\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10\x11\x12\x13");
+assert_return(() => call($17, "load8_u", [12_138]), 0);
+
+// memory_copy.wast:3303
+assert_return(() => call($17, "load8_u", [12_337]), 0);
+
+// memory_copy.wast:3304
+assert_return(() => call($17, "load8_u", [12_536]), 0);
+
+// memory_copy.wast:3305
+assert_return(() => call($17, "load8_u", [12_735]), 0);
+
+// memory_copy.wast:3306
+assert_return(() => call($17, "load8_u", [12_934]), 0);
+
+// memory_copy.wast:3307
+assert_return(() => call($17, "load8_u", [13_133]), 0);
+
+// memory_copy.wast:3308
+assert_return(() => call($17, "load8_u", [13_332]), 0);
+
+// memory_copy.wast:3309
+assert_return(() => call($17, "load8_u", [13_531]), 0);
 
 // memory_copy.wast:3310
-assert_trap(() => call($17, "run", [65_516, 65_516, 40]));
+assert_return(() => call($17, "load8_u", [13_730]), 0);
+
+// memory_copy.wast:3311
+assert_return(() => call($17, "load8_u", [13_929]), 0);
+
+// memory_copy.wast:3312
+assert_return(() => call($17, "load8_u", [14_128]), 0);
 
 // memory_copy.wast:3313
-assert_return(() => call($17, "load8_u", [198]), 0);
+assert_return(() => call($17, "load8_u", [14_327]), 0);
 
 // memory_copy.wast:3314
-assert_return(() => call($17, "load8_u", [397]), 0);
+assert_return(() => call($17, "load8_u", [14_526]), 0);
 
 // memory_copy.wast:3315
-assert_return(() => call($17, "load8_u", [596]), 0);
+assert_return(() => call($17, "load8_u", [14_725]), 0);
 
 // memory_copy.wast:3316
-assert_return(() => call($17, "load8_u", [795]), 0);
+assert_return(() => call($17, "load8_u", [14_924]), 0);
 
 // memory_copy.wast:3317
-assert_return(() => call($17, "load8_u", [994]), 0);
+assert_return(() => call($17, "load8_u", [15_123]), 0);
 
 // memory_copy.wast:3318
-assert_return(() => call($17, "load8_u", [1_193]), 0);
+assert_return(() => call($17, "load8_u", [15_322]), 0);
 
 // memory_copy.wast:3319
-assert_return(() => call($17, "load8_u", [1_392]), 0);
+assert_return(() => call($17, "load8_u", [15_521]), 0);
 
 // memory_copy.wast:3320
-assert_return(() => call($17, "load8_u", [1_591]), 0);
+assert_return(() => call($17, "load8_u", [15_720]), 0);
 
 // memory_copy.wast:3321
-assert_return(() => call($17, "load8_u", [1_790]), 0);
+assert_return(() => call($17, "load8_u", [15_919]), 0);
 
 // memory_copy.wast:3322
-assert_return(() => call($17, "load8_u", [1_989]), 0);
+assert_return(() => call($17, "load8_u", [16_118]), 0);
 
 // memory_copy.wast:3323
-assert_return(() => call($17, "load8_u", [2_188]), 0);
+assert_return(() => call($17, "load8_u", [16_317]), 0);
 
 // memory_copy.wast:3324
-assert_return(() => call($17, "load8_u", [2_387]), 0);
+assert_return(() => call($17, "load8_u", [16_516]), 0);
 
 // memory_copy.wast:3325
-assert_return(() => call($17, "load8_u", [2_586]), 0);
+assert_return(() => call($17, "load8_u", [16_715]), 0);
 
 // memory_copy.wast:3326
-assert_return(() => call($17, "load8_u", [2_785]), 0);
+assert_return(() => call($17, "load8_u", [16_914]), 0);
 
 // memory_copy.wast:3327
-assert_return(() => call($17, "load8_u", [2_984]), 0);
+assert_return(() => call($17, "load8_u", [17_113]), 0);
 
 // memory_copy.wast:3328
-assert_return(() => call($17, "load8_u", [3_183]), 0);
+assert_return(() => call($17, "load8_u", [17_312]), 0);
 
 // memory_copy.wast:3329
-assert_return(() => call($17, "load8_u", [3_382]), 0);
+assert_return(() => call($17, "load8_u", [17_511]), 0);
 
 // memory_copy.wast:3330
-assert_return(() => call($17, "load8_u", [3_581]), 0);
+assert_return(() => call($17, "load8_u", [17_710]), 0);
 
 // memory_copy.wast:3331
-assert_return(() => call($17, "load8_u", [3_780]), 0);
+assert_return(() => call($17, "load8_u", [17_909]), 0);
 
 // memory_copy.wast:3332
-assert_return(() => call($17, "load8_u", [3_979]), 0);
+assert_return(() => call($17, "load8_u", [18_108]), 0);
 
 // memory_copy.wast:3333
-assert_return(() => call($17, "load8_u", [4_178]), 0);
+assert_return(() => call($17, "load8_u", [18_307]), 0);
 
 // memory_copy.wast:3334
-assert_return(() => call($17, "load8_u", [4_377]), 0);
+assert_return(() => call($17, "load8_u", [18_506]), 0);
 
 // memory_copy.wast:3335
-assert_return(() => call($17, "load8_u", [4_576]), 0);
+assert_return(() => call($17, "load8_u", [18_705]), 0);
 
 // memory_copy.wast:3336
-assert_return(() => call($17, "load8_u", [4_775]), 0);
+assert_return(() => call($17, "load8_u", [18_904]), 0);
 
 // memory_copy.wast:3337
-assert_return(() => call($17, "load8_u", [4_974]), 0);
+assert_return(() => call($17, "load8_u", [19_103]), 0);
 
 // memory_copy.wast:3338
-assert_return(() => call($17, "load8_u", [5_173]), 0);
+assert_return(() => call($17, "load8_u", [19_302]), 0);
 
 // memory_copy.wast:3339
-assert_return(() => call($17, "load8_u", [5_372]), 0);
+assert_return(() => call($17, "load8_u", [19_501]), 0);
 
 // memory_copy.wast:3340
-assert_return(() => call($17, "load8_u", [5_571]), 0);
+assert_return(() => call($17, "load8_u", [19_700]), 0);
 
 // memory_copy.wast:3341
-assert_return(() => call($17, "load8_u", [5_770]), 0);
+assert_return(() => call($17, "load8_u", [19_899]), 0);
 
 // memory_copy.wast:3342
-assert_return(() => call($17, "load8_u", [5_969]), 0);
+assert_return(() => call($17, "load8_u", [20_098]), 0);
 
 // memory_copy.wast:3343
-assert_return(() => call($17, "load8_u", [6_168]), 0);
+assert_return(() => call($17, "load8_u", [20_297]), 0);
 
 // memory_copy.wast:3344
-assert_return(() => call($17, "load8_u", [6_367]), 0);
+assert_return(() => call($17, "load8_u", [20_496]), 0);
 
 // memory_copy.wast:3345
-assert_return(() => call($17, "load8_u", [6_566]), 0);
+assert_return(() => call($17, "load8_u", [20_695]), 0);
 
 // memory_copy.wast:3346
-assert_return(() => call($17, "load8_u", [6_765]), 0);
+assert_return(() => call($17, "load8_u", [20_894]), 0);
 
 // memory_copy.wast:3347
-assert_return(() => call($17, "load8_u", [6_964]), 0);
+assert_return(() => call($17, "load8_u", [21_093]), 0);
 
 // memory_copy.wast:3348
-assert_return(() => call($17, "load8_u", [7_163]), 0);
+assert_return(() => call($17, "load8_u", [21_292]), 0);
 
 // memory_copy.wast:3349
-assert_return(() => call($17, "load8_u", [7_362]), 0);
+assert_return(() => call($17, "load8_u", [21_491]), 0);
 
 // memory_copy.wast:3350
-assert_return(() => call($17, "load8_u", [7_561]), 0);
+assert_return(() => call($17, "load8_u", [21_690]), 0);
 
 // memory_copy.wast:3351
-assert_return(() => call($17, "load8_u", [7_760]), 0);
+assert_return(() => call($17, "load8_u", [21_889]), 0);
 
 // memory_copy.wast:3352
-assert_return(() => call($17, "load8_u", [7_959]), 0);
+assert_return(() => call($17, "load8_u", [22_088]), 0);
 
 // memory_copy.wast:3353
-assert_return(() => call($17, "load8_u", [8_158]), 0);
+assert_return(() => call($17, "load8_u", [22_287]), 0);
 
 // memory_copy.wast:3354
-assert_return(() => call($17, "load8_u", [8_357]), 0);
+assert_return(() => call($17, "load8_u", [22_486]), 0);
 
 // memory_copy.wast:3355
-assert_return(() => call($17, "load8_u", [8_556]), 0);
+assert_return(() => call($17, "load8_u", [22_685]), 0);
 
 // memory_copy.wast:3356
-assert_return(() => call($17, "load8_u", [8_755]), 0);
+assert_return(() => call($17, "load8_u", [22_884]), 0);
 
 // memory_copy.wast:3357
-assert_return(() => call($17, "load8_u", [8_954]), 0);
+assert_return(() => call($17, "load8_u", [23_083]), 0);
 
 // memory_copy.wast:3358
-assert_return(() => call($17, "load8_u", [9_153]), 0);
+assert_return(() => call($17, "load8_u", [23_282]), 0);
 
 // memory_copy.wast:3359
-assert_return(() => call($17, "load8_u", [9_352]), 0);
+assert_return(() => call($17, "load8_u", [23_481]), 0);
 
 // memory_copy.wast:3360
-assert_return(() => call($17, "load8_u", [9_551]), 0);
+assert_return(() => call($17, "load8_u", [23_680]), 0);
 
 // memory_copy.wast:3361
-assert_return(() => call($17, "load8_u", [9_750]), 0);
+assert_return(() => call($17, "load8_u", [23_879]), 0);
 
 // memory_copy.wast:3362
-assert_return(() => call($17, "load8_u", [9_949]), 0);
+assert_return(() => call($17, "load8_u", [24_078]), 0);
 
 // memory_copy.wast:3363
-assert_return(() => call($17, "load8_u", [10_148]), 0);
+assert_return(() => call($17, "load8_u", [24_277]), 0);
 
 // memory_copy.wast:3364
-assert_return(() => call($17, "load8_u", [10_347]), 0);
+assert_return(() => call($17, "load8_u", [24_476]), 0);
 
 // memory_copy.wast:3365
-assert_return(() => call($17, "load8_u", [10_546]), 0);
+assert_return(() => call($17, "load8_u", [24_675]), 0);
 
 // memory_copy.wast:3366
-assert_return(() => call($17, "load8_u", [10_745]), 0);
+assert_return(() => call($17, "load8_u", [24_874]), 0);
 
 // memory_copy.wast:3367
-assert_return(() => call($17, "load8_u", [10_944]), 0);
+assert_return(() => call($17, "load8_u", [25_073]), 0);
 
 // memory_copy.wast:3368
-assert_return(() => call($17, "load8_u", [11_143]), 0);
+assert_return(() => call($17, "load8_u", [25_272]), 0);
 
 // memory_copy.wast:3369
-assert_return(() => call($17, "load8_u", [11_342]), 0);
+assert_return(() => call($17, "load8_u", [25_471]), 0);
 
 // memory_copy.wast:3370
-assert_return(() => call($17, "load8_u", [11_541]), 0);
+assert_return(() => call($17, "load8_u", [25_670]), 0);
 
 // memory_copy.wast:3371
-assert_return(() => call($17, "load8_u", [11_740]), 0);
+assert_return(() => call($17, "load8_u", [25_869]), 0);
 
 // memory_copy.wast:3372
-assert_return(() => call($17, "load8_u", [11_939]), 0);
+assert_return(() => call($17, "load8_u", [26_068]), 0);
 
 // memory_copy.wast:3373
-assert_return(() => call($17, "load8_u", [12_138]), 0);
+assert_return(() => call($17, "load8_u", [26_267]), 0);
 
 // memory_copy.wast:3374
-assert_return(() => call($17, "load8_u", [12_337]), 0);
+assert_return(() => call($17, "load8_u", [26_466]), 0);
 
 // memory_copy.wast:3375
-assert_return(() => call($17, "load8_u", [12_536]), 0);
+assert_return(() => call($17, "load8_u", [26_665]), 0);
 
 // memory_copy.wast:3376
-assert_return(() => call($17, "load8_u", [12_735]), 0);
+assert_return(() => call($17, "load8_u", [26_864]), 0);
 
 // memory_copy.wast:3377
-assert_return(() => call($17, "load8_u", [12_934]), 0);
+assert_return(() => call($17, "load8_u", [27_063]), 0);
 
 // memory_copy.wast:3378
-assert_return(() => call($17, "load8_u", [13_133]), 0);
+assert_return(() => call($17, "load8_u", [27_262]), 0);
 
 // memory_copy.wast:3379
-assert_return(() => call($17, "load8_u", [13_332]), 0);
+assert_return(() => call($17, "load8_u", [27_461]), 0);
 
 // memory_copy.wast:3380
-assert_return(() => call($17, "load8_u", [13_531]), 0);
+assert_return(() => call($17, "load8_u", [27_660]), 0);
 
 // memory_copy.wast:3381
-assert_return(() => call($17, "load8_u", [13_730]), 0);
+assert_return(() => call($17, "load8_u", [27_859]), 0);
 
 // memory_copy.wast:3382
-assert_return(() => call($17, "load8_u", [13_929]), 0);
+assert_return(() => call($17, "load8_u", [28_058]), 0);
 
 // memory_copy.wast:3383
-assert_return(() => call($17, "load8_u", [14_128]), 0);
+assert_return(() => call($17, "load8_u", [28_257]), 0);
 
 // memory_copy.wast:3384
-assert_return(() => call($17, "load8_u", [14_327]), 0);
+assert_return(() => call($17, "load8_u", [28_456]), 0);
 
 // memory_copy.wast:3385
-assert_return(() => call($17, "load8_u", [14_526]), 0);
+assert_return(() => call($17, "load8_u", [28_655]), 0);
 
 // memory_copy.wast:3386
-assert_return(() => call($17, "load8_u", [14_725]), 0);
+assert_return(() => call($17, "load8_u", [28_854]), 0);
 
 // memory_copy.wast:3387
-assert_return(() => call($17, "load8_u", [14_924]), 0);
+assert_return(() => call($17, "load8_u", [29_053]), 0);
 
 // memory_copy.wast:3388
-assert_return(() => call($17, "load8_u", [15_123]), 0);
+assert_return(() => call($17, "load8_u", [29_252]), 0);
 
 // memory_copy.wast:3389
-assert_return(() => call($17, "load8_u", [15_322]), 0);
+assert_return(() => call($17, "load8_u", [29_451]), 0);
 
 // memory_copy.wast:3390
-assert_return(() => call($17, "load8_u", [15_521]), 0);
+assert_return(() => call($17, "load8_u", [29_650]), 0);
 
 // memory_copy.wast:3391
-assert_return(() => call($17, "load8_u", [15_720]), 0);
+assert_return(() => call($17, "load8_u", [29_849]), 0);
 
 // memory_copy.wast:3392
-assert_return(() => call($17, "load8_u", [15_919]), 0);
+assert_return(() => call($17, "load8_u", [30_048]), 0);
 
 // memory_copy.wast:3393
-assert_return(() => call($17, "load8_u", [16_118]), 0);
+assert_return(() => call($17, "load8_u", [30_247]), 0);
 
 // memory_copy.wast:3394
-assert_return(() => call($17, "load8_u", [16_317]), 0);
+assert_return(() => call($17, "load8_u", [30_446]), 0);
 
 // memory_copy.wast:3395
-assert_return(() => call($17, "load8_u", [16_516]), 0);
+assert_return(() => call($17, "load8_u", [30_645]), 0);
 
 // memory_copy.wast:3396
-assert_return(() => call($17, "load8_u", [16_715]), 0);
+assert_return(() => call($17, "load8_u", [30_844]), 0);
 
 // memory_copy.wast:3397
-assert_return(() => call($17, "load8_u", [16_914]), 0);
+assert_return(() => call($17, "load8_u", [31_043]), 0);
 
 // memory_copy.wast:3398
-assert_return(() => call($17, "load8_u", [17_113]), 0);
+assert_return(() => call($17, "load8_u", [31_242]), 0);
 
 // memory_copy.wast:3399
-assert_return(() => call($17, "load8_u", [17_312]), 0);
+assert_return(() => call($17, "load8_u", [31_441]), 0);
 
 // memory_copy.wast:3400
-assert_return(() => call($17, "load8_u", [17_511]), 0);
+assert_return(() => call($17, "load8_u", [31_640]), 0);
 
 // memory_copy.wast:3401
-assert_return(() => call($17, "load8_u", [17_710]), 0);
+assert_return(() => call($17, "load8_u", [31_839]), 0);
 
 // memory_copy.wast:3402
-assert_return(() => call($17, "load8_u", [17_909]), 0);
+assert_return(() => call($17, "load8_u", [32_038]), 0);
 
 // memory_copy.wast:3403
-assert_return(() => call($17, "load8_u", [18_108]), 0);
+assert_return(() => call($17, "load8_u", [32_237]), 0);
 
 // memory_copy.wast:3404
-assert_return(() => call($17, "load8_u", [18_307]), 0);
+assert_return(() => call($17, "load8_u", [32_436]), 0);
 
 // memory_copy.wast:3405
-assert_return(() => call($17, "load8_u", [18_506]), 0);
+assert_return(() => call($17, "load8_u", [32_635]), 0);
 
 // memory_copy.wast:3406
-assert_return(() => call($17, "load8_u", [18_705]), 0);
+assert_return(() => call($17, "load8_u", [32_834]), 0);
 
 // memory_copy.wast:3407
-assert_return(() => call($17, "load8_u", [18_904]), 0);
+assert_return(() => call($17, "load8_u", [33_033]), 0);
 
 // memory_copy.wast:3408
-assert_return(() => call($17, "load8_u", [19_103]), 0);
+assert_return(() => call($17, "load8_u", [33_232]), 0);
 
 // memory_copy.wast:3409
-assert_return(() => call($17, "load8_u", [19_302]), 0);
+assert_return(() => call($17, "load8_u", [33_431]), 0);
 
 // memory_copy.wast:3410
-assert_return(() => call($17, "load8_u", [19_501]), 0);
+assert_return(() => call($17, "load8_u", [33_630]), 0);
 
 // memory_copy.wast:3411
-assert_return(() => call($17, "load8_u", [19_700]), 0);
+assert_return(() => call($17, "load8_u", [33_829]), 0);
 
 // memory_copy.wast:3412
-assert_return(() => call($17, "load8_u", [19_899]), 0);
+assert_return(() => call($17, "load8_u", [34_028]), 0);
 
 // memory_copy.wast:3413
-assert_return(() => call($17, "load8_u", [20_098]), 0);
+assert_return(() => call($17, "load8_u", [34_227]), 0);
 
 // memory_copy.wast:3414
-assert_return(() => call($17, "load8_u", [20_297]), 0);
+assert_return(() => call($17, "load8_u", [34_426]), 0);
 
 // memory_copy.wast:3415
-assert_return(() => call($17, "load8_u", [20_496]), 0);
+assert_return(() => call($17, "load8_u", [34_625]), 0);
 
 // memory_copy.wast:3416
-assert_return(() => call($17, "load8_u", [20_695]), 0);
+assert_return(() => call($17, "load8_u", [34_824]), 0);
 
 // memory_copy.wast:3417
-assert_return(() => call($17, "load8_u", [20_894]), 0);
+assert_return(() => call($17, "load8_u", [35_023]), 0);
 
 // memory_copy.wast:3418
-assert_return(() => call($17, "load8_u", [21_093]), 0);
+assert_return(() => call($17, "load8_u", [35_222]), 0);
 
 // memory_copy.wast:3419
-assert_return(() => call($17, "load8_u", [21_292]), 0);
+assert_return(() => call($17, "load8_u", [35_421]), 0);
 
 // memory_copy.wast:3420
-assert_return(() => call($17, "load8_u", [21_491]), 0);
+assert_return(() => call($17, "load8_u", [35_620]), 0);
 
 // memory_copy.wast:3421
-assert_return(() => call($17, "load8_u", [21_690]), 0);
+assert_return(() => call($17, "load8_u", [35_819]), 0);
 
 // memory_copy.wast:3422
-assert_return(() => call($17, "load8_u", [21_889]), 0);
+assert_return(() => call($17, "load8_u", [36_018]), 0);
 
 // memory_copy.wast:3423
-assert_return(() => call($17, "load8_u", [22_088]), 0);
+assert_return(() => call($17, "load8_u", [36_217]), 0);
 
 // memory_copy.wast:3424
-assert_return(() => call($17, "load8_u", [22_287]), 0);
+assert_return(() => call($17, "load8_u", [36_416]), 0);
 
 // memory_copy.wast:3425
-assert_return(() => call($17, "load8_u", [22_486]), 0);
+assert_return(() => call($17, "load8_u", [36_615]), 0);
 
 // memory_copy.wast:3426
-assert_return(() => call($17, "load8_u", [22_685]), 0);
+assert_return(() => call($17, "load8_u", [36_814]), 0);
 
 // memory_copy.wast:3427
-assert_return(() => call($17, "load8_u", [22_884]), 0);
+assert_return(() => call($17, "load8_u", [37_013]), 0);
 
 // memory_copy.wast:3428
-assert_return(() => call($17, "load8_u", [23_083]), 0);
+assert_return(() => call($17, "load8_u", [37_212]), 0);
 
 // memory_copy.wast:3429
-assert_return(() => call($17, "load8_u", [23_282]), 0);
+assert_return(() => call($17, "load8_u", [37_411]), 0);
 
 // memory_copy.wast:3430
-assert_return(() => call($17, "load8_u", [23_481]), 0);
+assert_return(() => call($17, "load8_u", [37_610]), 0);
 
 // memory_copy.wast:3431
-assert_return(() => call($17, "load8_u", [23_680]), 0);
+assert_return(() => call($17, "load8_u", [37_809]), 0);
 
 // memory_copy.wast:3432
-assert_return(() => call($17, "load8_u", [23_879]), 0);
+assert_return(() => call($17, "load8_u", [38_008]), 0);
 
 // memory_copy.wast:3433
-assert_return(() => call($17, "load8_u", [24_078]), 0);
+assert_return(() => call($17, "load8_u", [38_207]), 0);
 
 // memory_copy.wast:3434
-assert_return(() => call($17, "load8_u", [24_277]), 0);
+assert_return(() => call($17, "load8_u", [38_406]), 0);
 
 // memory_copy.wast:3435
-assert_return(() => call($17, "load8_u", [24_476]), 0);
+assert_return(() => call($17, "load8_u", [38_605]), 0);
 
 // memory_copy.wast:3436
-assert_return(() => call($17, "load8_u", [24_675]), 0);
+assert_return(() => call($17, "load8_u", [38_804]), 0);
 
 // memory_copy.wast:3437
-assert_return(() => call($17, "load8_u", [24_874]), 0);
+assert_return(() => call($17, "load8_u", [39_003]), 0);
 
 // memory_copy.wast:3438
-assert_return(() => call($17, "load8_u", [25_073]), 0);
+assert_return(() => call($17, "load8_u", [39_202]), 0);
 
 // memory_copy.wast:3439
-assert_return(() => call($17, "load8_u", [25_272]), 0);
+assert_return(() => call($17, "load8_u", [39_401]), 0);
 
 // memory_copy.wast:3440
-assert_return(() => call($17, "load8_u", [25_471]), 0);
+assert_return(() => call($17, "load8_u", [39_600]), 0);
 
 // memory_copy.wast:3441
-assert_return(() => call($17, "load8_u", [25_670]), 0);
+assert_return(() => call($17, "load8_u", [39_799]), 0);
 
 // memory_copy.wast:3442
-assert_return(() => call($17, "load8_u", [25_869]), 0);
+assert_return(() => call($17, "load8_u", [39_998]), 0);
 
 // memory_copy.wast:3443
-assert_return(() => call($17, "load8_u", [26_068]), 0);
+assert_return(() => call($17, "load8_u", [40_197]), 0);
 
 // memory_copy.wast:3444
-assert_return(() => call($17, "load8_u", [26_267]), 0);
+assert_return(() => call($17, "load8_u", [40_396]), 0);
 
 // memory_copy.wast:3445
-assert_return(() => call($17, "load8_u", [26_466]), 0);
+assert_return(() => call($17, "load8_u", [40_595]), 0);
 
 // memory_copy.wast:3446
-assert_return(() => call($17, "load8_u", [26_665]), 0);
+assert_return(() => call($17, "load8_u", [40_794]), 0);
 
 // memory_copy.wast:3447
-assert_return(() => call($17, "load8_u", [26_864]), 0);
+assert_return(() => call($17, "load8_u", [40_993]), 0);
 
 // memory_copy.wast:3448
-assert_return(() => call($17, "load8_u", [27_063]), 0);
+assert_return(() => call($17, "load8_u", [