| |
| // memory_copy.wast:6 |
| let $1 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\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\x9c\x80\x80\x80\x00\x03\x07\x6d\x65\x6d\x6f\x72\x79\x30\x02\x00\x04\x74\x65\x73\x74\x00\x00\x07\x6c\x6f\x61\x64\x38\x5f\x75\x00\x01\x0a\x95\x80\x80\x80\x00\x02\x83\x80\x80\x80\x00\x00\x01\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x2d\x00\x00\x0b\x0b\x94\x80\x80\x80\x00\x02\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06"); |
| |
| // memory_copy.wast:15 |
| run(() => call($1, "test", [])); |
| |
| // memory_copy.wast:17 |
| assert_return(() => call($1, "load8_u", [0]), 0); |
| |
| // memory_copy.wast:18 |
| assert_return(() => call($1, "load8_u", [1]), 0); |
| |
| // memory_copy.wast:19 |
| assert_return(() => call($1, "load8_u", [2]), 3); |
| |
| // memory_copy.wast:20 |
| assert_return(() => call($1, "load8_u", [3]), 1); |
| |
| // memory_copy.wast:21 |
| assert_return(() => call($1, "load8_u", [4]), 4); |
| |
| // memory_copy.wast:22 |
| assert_return(() => call($1, "load8_u", [5]), 1); |
| |
| // memory_copy.wast:23 |
| assert_return(() => call($1, "load8_u", [6]), 0); |
| |
| // memory_copy.wast:24 |
| assert_return(() => call($1, "load8_u", [7]), 0); |
| |
| // memory_copy.wast:25 |
| assert_return(() => call($1, "load8_u", [8]), 0); |
| |
| // memory_copy.wast:26 |
| assert_return(() => call($1, "load8_u", [9]), 0); |
| |
| // memory_copy.wast:27 |
| assert_return(() => call($1, "load8_u", [10]), 0); |
| |
| // memory_copy.wast:28 |
| assert_return(() => call($1, "load8_u", [11]), 0); |
| |
| // memory_copy.wast:29 |
| assert_return(() => call($1, "load8_u", [12]), 7); |
| |
| // memory_copy.wast:30 |
| assert_return(() => call($1, "load8_u", [13]), 5); |
| |
| // memory_copy.wast:31 |
| assert_return(() => call($1, "load8_u", [14]), 2); |
| |
| // memory_copy.wast:32 |
| assert_return(() => call($1, "load8_u", [15]), 3); |
| |
| // memory_copy.wast:33 |
| assert_return(() => call($1, "load8_u", [16]), 6); |
| |
| // memory_copy.wast:34 |
| assert_return(() => call($1, "load8_u", [17]), 0); |
| |
| // memory_copy.wast:35 |
| assert_return(() => call($1, "load8_u", [18]), 0); |
| |
| // memory_copy.wast:36 |
| assert_return(() => call($1, "load8_u", [19]), 0); |
| |
| // memory_copy.wast:37 |
| assert_return(() => call($1, "load8_u", [20]), 0); |
| |
| // memory_copy.wast:38 |
| assert_return(() => call($1, "load8_u", [21]), 0); |
| |
| // memory_copy.wast:39 |
| assert_return(() => call($1, "load8_u", [22]), 0); |
| |
| // memory_copy.wast:40 |
| assert_return(() => call($1, "load8_u", [23]), 0); |
| |
| // memory_copy.wast:41 |
| assert_return(() => call($1, "load8_u", [24]), 0); |
| |
| // memory_copy.wast:42 |
| assert_return(() => call($1, "load8_u", [25]), 0); |
| |
| // memory_copy.wast:43 |
| assert_return(() => call($1, "load8_u", [26]), 0); |
| |
| // memory_copy.wast:44 |
| assert_return(() => call($1, "load8_u", [27]), 0); |
| |
| // memory_copy.wast:45 |
| assert_return(() => call($1, "load8_u", [28]), 0); |
| |
| // memory_copy.wast:46 |
| assert_return(() => call($1, "load8_u", [29]), 0); |
| |
| // memory_copy.wast:48 |
| let $2 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\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\x9c\x80\x80\x80\x00\x03\x07\x6d\x65\x6d\x6f\x72\x79\x30\x02\x00\x04\x74\x65\x73\x74\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\x41\x0d\x41\x02\x41\x03\xfc\x0a\x00\x00\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x2d\x00\x00\x0b\x0b\x94\x80\x80\x80\x00\x02\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06"); |
| |
| // memory_copy.wast:57 |
| run(() => call($2, "test", [])); |
| |
| // memory_copy.wast:59 |
| assert_return(() => call($2, "load8_u", [0]), 0); |
| |
| // memory_copy.wast:60 |
| assert_return(() => call($2, "load8_u", [1]), 0); |
| |
| // memory_copy.wast:61 |
| assert_return(() => call($2, "load8_u", [2]), 3); |
| |
| // memory_copy.wast:62 |
| assert_return(() => call($2, "load8_u", [3]), 1); |
| |
| // memory_copy.wast:63 |
| assert_return(() => call($2, "load8_u", [4]), 4); |
| |
| // memory_copy.wast:64 |
| assert_return(() => call($2, "load8_u", [5]), 1); |
| |
| // memory_copy.wast:65 |
| assert_return(() => call($2, "load8_u", [6]), 0); |
| |
| // memory_copy.wast:66 |
| assert_return(() => call($2, "load8_u", [7]), 0); |
| |
| // memory_copy.wast:67 |
| assert_return(() => call($2, "load8_u", [8]), 0); |
| |
| // memory_copy.wast:68 |
| assert_return(() => call($2, "load8_u", [9]), 0); |
| |
| // memory_copy.wast:69 |
| assert_return(() => call($2, "load8_u", [10]), 0); |
| |
| // memory_copy.wast:70 |
| assert_return(() => call($2, "load8_u", [11]), 0); |
| |
| // memory_copy.wast:71 |
| assert_return(() => call($2, "load8_u", [12]), 7); |
| |
| // memory_copy.wast:72 |
| assert_return(() => call($2, "load8_u", [13]), 3); |
| |
| // memory_copy.wast:73 |
| assert_return(() => call($2, "load8_u", [14]), 1); |
| |
| // memory_copy.wast:74 |
| assert_return(() => call($2, "load8_u", [15]), 4); |
| |
| // memory_copy.wast:75 |
| assert_return(() => call($2, "load8_u", [16]), 6); |
| |
| // memory_copy.wast:76 |
| assert_return(() => call($2, "load8_u", [17]), 0); |
| |
| // memory_copy.wast:77 |
| assert_return(() => call($2, "load8_u", [18]), 0); |
| |
| // memory_copy.wast:78 |
| assert_return(() => call($2, "load8_u", [19]), 0); |
| |
| // memory_copy.wast:79 |
| assert_return(() => call($2, "load8_u", [20]), 0); |
| |
| // memory_copy.wast:80 |
| assert_return(() => call($2, "load8_u", [21]), 0); |
| |
| // memory_copy.wast:81 |
| assert_return(() => call($2, "load8_u", [22]), 0); |
| |
| // memory_copy.wast:82 |
| assert_return(() => call($2, "load8_u", [23]), 0); |
| |
| // memory_copy.wast:83 |
| assert_return(() => call($2, "load8_u", [24]), 0); |
| |
| // memory_copy.wast:84 |
| assert_return(() => call($2, "load8_u", [25]), 0); |
| |
| // memory_copy.wast:85 |
| assert_return(() => call($2, "load8_u", [26]), 0); |
| |
| // memory_copy.wast:86 |
| assert_return(() => call($2, "load8_u", [27]), 0); |
| |
| // memory_copy.wast:87 |
| assert_return(() => call($2, "load8_u", [28]), 0); |
| |
| // memory_copy.wast:88 |
| assert_return(() => call($2, "load8_u", [29]), 0); |
| |
| // memory_copy.wast:90 |
| let $3 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\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\x9c\x80\x80\x80\x00\x03\x07\x6d\x65\x6d\x6f\x72\x79\x30\x02\x00\x04\x74\x65\x73\x74\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\x41\x19\x41\x0f\x41\x02\xfc\x0a\x00\x00\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x2d\x00\x00\x0b\x0b\x94\x80\x80\x80\x00\x02\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06"); |
| |
| // memory_copy.wast:99 |
| run(() => call($3, "test", [])); |
| |
| // memory_copy.wast:101 |
| assert_return(() => call($3, "load8_u", [0]), 0); |
| |
| // memory_copy.wast:102 |
| assert_return(() => call($3, "load8_u", [1]), 0); |
| |
| // memory_copy.wast:103 |
| assert_return(() => call($3, "load8_u", [2]), 3); |
| |
| // memory_copy.wast:104 |
| assert_return(() => call($3, "load8_u", [3]), 1); |
| |
| // memory_copy.wast:105 |
| assert_return(() => call($3, "load8_u", [4]), 4); |
| |
| // memory_copy.wast:106 |
| assert_return(() => call($3, "load8_u", [5]), 1); |
| |
| // memory_copy.wast:107 |
| assert_return(() => call($3, "load8_u", [6]), 0); |
| |
| // memory_copy.wast:108 |
| assert_return(() => call($3, "load8_u", [7]), 0); |
| |
| // memory_copy.wast:109 |
| assert_return(() => call($3, "load8_u", [8]), 0); |
| |
| // memory_copy.wast:110 |
| assert_return(() => call($3, "load8_u", [9]), 0); |
| |
| // memory_copy.wast:111 |
| assert_return(() => call($3, "load8_u", [10]), 0); |
| |
| // memory_copy.wast:112 |
| assert_return(() => call($3, "load8_u", [11]), 0); |
| |
| // memory_copy.wast:113 |
| assert_return(() => call($3, "load8_u", [12]), 7); |
| |
| // memory_copy.wast:114 |
| assert_return(() => call($3, "load8_u", [13]), 5); |
| |
| // memory_copy.wast:115 |
| assert_return(() => call($3, "load8_u", [14]), 2); |
| |
| // memory_copy.wast:116 |
| assert_return(() => call($3, "load8_u", [15]), 3); |
| |
| // memory_copy.wast:117 |
| assert_return(() => call($3, "load8_u", [16]), 6); |
| |
| // memory_copy.wast:118 |
| assert_return(() => call($3, "load8_u", [17]), 0); |
| |
| // memory_copy.wast:119 |
| assert_return(() => call($3, "load8_u", [18]), 0); |
| |
| // memory_copy.wast:120 |
| assert_return(() => call($3, "load8_u", [19]), 0); |
| |
| // memory_copy.wast:121 |
| assert_return(() => call($3, "load8_u", [20]), 0); |
| |
| // memory_copy.wast:122 |
| assert_return(() => call($3, "load8_u", [21]), 0); |
| |
| // memory_copy.wast:123 |
| assert_return(() => call($3, "load8_u", [22]), 0); |
| |
| // memory_copy.wast:124 |
| assert_return(() => call($3, "load8_u", [23]), 0); |
| |
| // memory_copy.wast:125 |
| assert_return(() => call($3, "load8_u", [24]), 0); |
| |
| // memory_copy.wast:126 |
| assert_return(() => call($3, "load8_u", [25]), 3); |
| |
| // memory_copy.wast:127 |
| assert_return(() => call($3, "load8_u", [26]), 6); |
| |
| // memory_copy.wast:128 |
| assert_return(() => call($3, "load8_u", [27]), 0); |
| |
| // memory_copy.wast:129 |
| assert_return(() => call($3, "load8_u", [28]), 0); |
| |
| // memory_copy.wast:130 |
| assert_return(() => call($3, "load8_u", [29]), 0); |
| |
| // memory_copy.wast:132 |
| let $4 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\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\x9c\x80\x80\x80\x00\x03\x07\x6d\x65\x6d\x6f\x72\x79\x30\x02\x00\x04\x74\x65\x73\x74\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\x41\x0d\x41\x19\x41\x03\xfc\x0a\x00\x00\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x2d\x00\x00\x0b\x0b\x94\x80\x80\x80\x00\x02\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06"); |
| |
| // memory_copy.wast:141 |
| run(() => call($4, "test", [])); |
| |
| // memory_copy.wast:143 |
| assert_return(() => call($4, "load8_u", [0]), 0); |
| |
| // memory_copy.wast:144 |
| assert_return(() => call($4, "load8_u", [1]), 0); |
| |
| // memory_copy.wast:145 |
| assert_return(() => call($4, "load8_u", [2]), 3); |
| |
| // memory_copy.wast:146 |
| assert_return(() => call($4, "load8_u", [3]), 1); |
| |
| // memory_copy.wast:147 |
| assert_return(() => call($4, "load8_u", [4]), 4); |
| |
| // memory_copy.wast:148 |
| assert_return(() => call($4, "load8_u", [5]), 1); |
| |
| // memory_copy.wast:149 |
| assert_return(() => call($4, "load8_u", [6]), 0); |
| |
| // memory_copy.wast:150 |
| assert_return(() => call($4, "load8_u", [7]), 0); |
| |
| // memory_copy.wast:151 |
| assert_return(() => call($4, "load8_u", [8]), 0); |
| |
| // memory_copy.wast:152 |
| assert_return(() => call($4, "load8_u", [9]), 0); |
| |
| // memory_copy.wast:153 |
| assert_return(() => call($4, "load8_u", [10]), 0); |
| |
| // memory_copy.wast:154 |
| assert_return(() => call($4, "load8_u", [11]), 0); |
| |
| // memory_copy.wast:155 |
| assert_return(() => call($4, "load8_u", [12]), 7); |
| |
| // memory_copy.wast:156 |
| assert_return(() => call($4, "load8_u", [13]), 0); |
| |
| // memory_copy.wast:157 |
| assert_return(() => call($4, "load8_u", [14]), 0); |
| |
| // memory_copy.wast:158 |
| assert_return(() => call($4, "load8_u", [15]), 0); |
| |
| // memory_copy.wast:159 |
| assert_return(() => call($4, "load8_u", [16]), 6); |
| |
| // memory_copy.wast:160 |
| assert_return(() => call($4, "load8_u", [17]), 0); |
| |
| // memory_copy.wast:161 |
| assert_return(() => call($4, "load8_u", [18]), 0); |
| |
| // memory_copy.wast:162 |
| assert_return(() => call($4, "load8_u", [19]), 0); |
| |
| // memory_copy.wast:163 |
| assert_return(() => call($4, "load8_u", [20]), 0); |
| |
| // memory_copy.wast:164 |
| assert_return(() => call($4, "load8_u", [21]), 0); |
| |
| // memory_copy.wast:165 |
| assert_return(() => call($4, "load8_u", [22]), 0); |
| |
| // memory_copy.wast:166 |
| assert_return(() => call($4, "load8_u", [23]), 0); |
| |
| // memory_copy.wast:167 |
| assert_return(() => call($4, "load8_u", [24]), 0); |
| |
| // memory_copy.wast:168 |
| assert_return(() => call($4, "load8_u", [25]), 0); |
| |
| // memory_copy.wast:169 |
| assert_return(() => call($4, "load8_u", [26]), 0); |
| |
| // memory_copy.wast:170 |
| assert_return(() => call($4, "load8_u", [27]), 0); |
| |
| // memory_copy.wast:171 |
| assert_return(() => call($4, "load8_u", [28]), 0); |
| |
| // memory_copy.wast:172 |
| assert_return(() => call($4, "load8_u", [29]), 0); |
| |
| // memory_copy.wast:174 |
| let $5 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\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\x9c\x80\x80\x80\x00\x03\x07\x6d\x65\x6d\x6f\x72\x79\x30\x02\x00\x04\x74\x65\x73\x74\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\x41\x14\x41\x16\x41\x04\xfc\x0a\x00\x00\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x2d\x00\x00\x0b\x0b\x94\x80\x80\x80\x00\x02\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06"); |
| |
| // memory_copy.wast:183 |
| run(() => call($5, "test", [])); |
| |
| // memory_copy.wast:185 |
| assert_return(() => call($5, "load8_u", [0]), 0); |
| |
| // memory_copy.wast:186 |
| assert_return(() => call($5, "load8_u", [1]), 0); |
| |
| // memory_copy.wast:187 |
| assert_return(() => call($5, "load8_u", [2]), 3); |
| |
| // memory_copy.wast:188 |
| assert_return(() => call($5, "load8_u", [3]), 1); |
| |
| // memory_copy.wast:189 |
| assert_return(() => call($5, "load8_u", [4]), 4); |
| |
| // memory_copy.wast:190 |
| assert_return(() => call($5, "load8_u", [5]), 1); |
| |
| // memory_copy.wast:191 |
| assert_return(() => call($5, "load8_u", [6]), 0); |
| |
| // memory_copy.wast:192 |
| assert_return(() => call($5, "load8_u", [7]), 0); |
| |
| // memory_copy.wast:193 |
| assert_return(() => call($5, "load8_u", [8]), 0); |
| |
| // memory_copy.wast:194 |
| assert_return(() => call($5, "load8_u", [9]), 0); |
| |
| // memory_copy.wast:195 |
| assert_return(() => call($5, "load8_u", [10]), 0); |
| |
| // memory_copy.wast:196 |
| assert_return(() => call($5, "load8_u", [11]), 0); |
| |
| // memory_copy.wast:197 |
| assert_return(() => call($5, "load8_u", [12]), 7); |
| |
| // memory_copy.wast:198 |
| assert_return(() => call($5, "load8_u", [13]), 5); |
| |
| // memory_copy.wast:199 |
| assert_return(() => call($5, "load8_u", [14]), 2); |
| |
| // memory_copy.wast:200 |
| assert_return(() => call($5, "load8_u", [15]), 3); |
| |
| // memory_copy.wast:201 |
| assert_return(() => call($5, "load8_u", [16]), 6); |
| |
| // memory_copy.wast:202 |
| assert_return(() => call($5, "load8_u", [17]), 0); |
| |
| // memory_copy.wast:203 |
| assert_return(() => call($5, "load8_u", [18]), 0); |
| |
| // memory_copy.wast:204 |
| assert_return(() => call($5, "load8_u", [19]), 0); |
| |
| // memory_copy.wast:205 |
| assert_return(() => call($5, "load8_u", [20]), 0); |
| |
| // memory_copy.wast:206 |
| assert_return(() => call($5, "load8_u", [21]), 0); |
| |
| // memory_copy.wast:207 |
| assert_return(() => call($5, "load8_u", [22]), 0); |
| |
| // memory_copy.wast:208 |
| assert_return(() => call($5, "load8_u", [23]), 0); |
| |
| // memory_copy.wast:209 |
| assert_return(() => call($5, "load8_u", [24]), 0); |
| |
| // memory_copy.wast:210 |
| assert_return(() => call($5, "load8_u", [25]), 0); |
| |
| // memory_copy.wast:211 |
| assert_return(() => call($5, "load8_u", [26]), 0); |
| |
| // memory_copy.wast:212 |
| assert_return(() => call($5, "load8_u", [27]), 0); |
| |
| // memory_copy.wast:213 |
| assert_return(() => call($5, "load8_u", [28]), 0); |
| |
| // memory_copy.wast:214 |
| assert_return(() => call($5, "load8_u", [29]), 0); |
| |
| // memory_copy.wast:216 |
| let $6 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\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\x9c\x80\x80\x80\x00\x03\x07\x6d\x65\x6d\x6f\x72\x79\x30\x02\x00\x04\x74\x65\x73\x74\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\x41\x19\x41\x01\x41\x03\xfc\x0a\x00\x00\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x2d\x00\x00\x0b\x0b\x94\x80\x80\x80\x00\x02\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06"); |
| |
| // memory_copy.wast:225 |
| run(() => call($6, "test", [])); |
| |
| // memory_copy.wast:227 |
| assert_return(() => call($6, "load8_u", [0]), 0); |
| |
| // memory_copy.wast:228 |
| assert_return(() => call($6, "load8_u", [1]), 0); |
| |
| // memory_copy.wast:229 |
| assert_return(() => call($6, "load8_u", [2]), 3); |
| |
| // memory_copy.wast:230 |
| assert_return(() => call($6, "load8_u", [3]), 1); |
| |
| // memory_copy.wast:231 |
| assert_return(() => call($6, "load8_u", [4]), 4); |
| |
| // memory_copy.wast:232 |
| assert_return(() => call($6, "load8_u", [5]), 1); |
| |
| // memory_copy.wast:233 |
| assert_return(() => call($6, "load8_u", [6]), 0); |
| |
| // memory_copy.wast:234 |
| assert_return(() => call($6, "load8_u", [7]), 0); |
| |
| // memory_copy.wast:235 |
| assert_return(() => call($6, "load8_u", [8]), 0); |
| |
| // memory_copy.wast:236 |
| assert_return(() => call($6, "load8_u", [9]), 0); |
| |
| // memory_copy.wast:237 |
| assert_return(() => call($6, "load8_u", [10]), 0); |
| |
| // memory_copy.wast:238 |
| assert_return(() => call($6, "load8_u", [11]), 0); |
| |
| // memory_copy.wast:239 |
| assert_return(() => call($6, "load8_u", [12]), 7); |
| |
| // memory_copy.wast:240 |
| assert_return(() => call($6, "load8_u", [13]), 5); |
| |
| // memory_copy.wast:241 |
| assert_return(() => call($6, "load8_u", [14]), 2); |
| |
| // memory_copy.wast:242 |
| assert_return(() => call($6, "load8_u", [15]), 3); |
| |
| // memory_copy.wast:243 |
| assert_return(() => call($6, "load8_u", [16]), 6); |
| |
| // memory_copy.wast:244 |
| assert_return(() => call($6, "load8_u", [17]), 0); |
| |
| // memory_copy.wast:245 |
| assert_return(() => call($6, "load8_u", [18]), 0); |
| |
| // memory_copy.wast:246 |
| assert_return(() => call($6, "load8_u", [19]), 0); |
| |
| // memory_copy.wast:247 |
| assert_return(() => call($6, "load8_u", [20]), 0); |
| |
| // memory_copy.wast:248 |
| assert_return(() => call($6, "load8_u", [21]), 0); |
| |
| // memory_copy.wast:249 |
| assert_return(() => call($6, "load8_u", [22]), 0); |
| |
| // memory_copy.wast:250 |
| assert_return(() => call($6, "load8_u", [23]), 0); |
| |
| // memory_copy.wast:251 |
| assert_return(() => call($6, "load8_u", [24]), 0); |
| |
| // memory_copy.wast:252 |
| assert_return(() => call($6, "load8_u", [25]), 0); |
| |
| // memory_copy.wast:253 |
| assert_return(() => call($6, "load8_u", [26]), 3); |
| |
| // memory_copy.wast:254 |
| assert_return(() => call($6, "load8_u", [27]), 1); |
| |
| // memory_copy.wast:255 |
| assert_return(() => call($6, "load8_u", [28]), 0); |
| |
| // memory_copy.wast:256 |
| assert_return(() => call($6, "load8_u", [29]), 0); |
| |
| // memory_copy.wast:258 |
| let $7 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\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\x9c\x80\x80\x80\x00\x03\x07\x6d\x65\x6d\x6f\x72\x79\x30\x02\x00\x04\x74\x65\x73\x74\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\x41\x0a\x41\x0c\x41\x07\xfc\x0a\x00\x00\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x2d\x00\x00\x0b\x0b\x94\x80\x80\x80\x00\x02\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06"); |
| |
| // memory_copy.wast:267 |
| run(() => call($7, "test", [])); |
| |
| // memory_copy.wast:269 |
| assert_return(() => call($7, "load8_u", [0]), 0); |
| |
| // memory_copy.wast:270 |
| assert_return(() => call($7, "load8_u", [1]), 0); |
| |
| // memory_copy.wast:271 |
| assert_return(() => call($7, "load8_u", [2]), 3); |
| |
| // memory_copy.wast:272 |
| assert_return(() => call($7, "load8_u", [3]), 1); |
| |
| // memory_copy.wast:273 |
| assert_return(() => call($7, "load8_u", [4]), 4); |
| |
| // memory_copy.wast:274 |
| assert_return(() => call($7, "load8_u", [5]), 1); |
| |
| // memory_copy.wast:275 |
| assert_return(() => call($7, "load8_u", [6]), 0); |
| |
| // memory_copy.wast:276 |
| assert_return(() => call($7, "load8_u", [7]), 0); |
| |
| // memory_copy.wast:277 |
| assert_return(() => call($7, "load8_u", [8]), 0); |
| |
| // memory_copy.wast:278 |
| assert_return(() => call($7, "load8_u", [9]), 0); |
| |
| // memory_copy.wast:279 |
| assert_return(() => call($7, "load8_u", [10]), 7); |
| |
| // memory_copy.wast:280 |
| assert_return(() => call($7, "load8_u", [11]), 5); |
| |
| // memory_copy.wast:281 |
| assert_return(() => call($7, "load8_u", [12]), 2); |
| |
| // memory_copy.wast:282 |
| assert_return(() => call($7, "load8_u", [13]), 3); |
| |
| // memory_copy.wast:283 |
| assert_return(() => call($7, "load8_u", [14]), 6); |
| |
| // memory_copy.wast:284 |
| assert_return(() => call($7, "load8_u", [15]), 0); |
| |
| // memory_copy.wast:285 |
| assert_return(() => call($7, "load8_u", [16]), 0); |
| |
| // memory_copy.wast:286 |
| assert_return(() => call($7, "load8_u", [17]), 0); |
| |
| // memory_copy.wast:287 |
| assert_return(() => call($7, "load8_u", [18]), 0); |
| |
| // memory_copy.wast:288 |
| assert_return(() => call($7, "load8_u", [19]), 0); |
| |
| // memory_copy.wast:289 |
| assert_return(() => call($7, "load8_u", [20]), 0); |
| |
| // memory_copy.wast:290 |
| assert_return(() => call($7, "load8_u", [21]), 0); |
| |
| // memory_copy.wast:291 |
| assert_return(() => call($7, "load8_u", [22]), 0); |
| |
| // memory_copy.wast:292 |
| assert_return(() => call($7, "load8_u", [23]), 0); |
| |
| // memory_copy.wast:293 |
| assert_return(() => call($7, "load8_u", [24]), 0); |
| |
| // memory_copy.wast:294 |
| assert_return(() => call($7, "load8_u", [25]), 0); |
| |
| // memory_copy.wast:295 |
| assert_return(() => call($7, "load8_u", [26]), 0); |
| |
| // memory_copy.wast:296 |
| assert_return(() => call($7, "load8_u", [27]), 0); |
| |
| // memory_copy.wast:297 |
| assert_return(() => call($7, "load8_u", [28]), 0); |
| |
| // memory_copy.wast:298 |
| assert_return(() => call($7, "load8_u", [29]), 0); |
| |
| // memory_copy.wast:300 |
| let $8 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\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\x9c\x80\x80\x80\x00\x03\x07\x6d\x65\x6d\x6f\x72\x79\x30\x02\x00\x04\x74\x65\x73\x74\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\x41\x0c\x41\x0a\x41\x07\xfc\x0a\x00\x00\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x2d\x00\x00\x0b\x0b\x94\x80\x80\x80\x00\x02\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06"); |
| |
| // memory_copy.wast:309 |
| run(() => call($8, "test", [])); |
| |
| // memory_copy.wast:311 |
| assert_return(() => call($8, "load8_u", [0]), 0); |
| |
| // memory_copy.wast:312 |
| assert_return(() => call($8, "load8_u", [1]), 0); |
| |
| // memory_copy.wast:313 |
| assert_return(() => call($8, "load8_u", [2]), 3); |
| |
| // memory_copy.wast:314 |
| assert_return(() => call($8, "load8_u", [3]), 1); |
| |
| // memory_copy.wast:315 |
| assert_return(() => call($8, "load8_u", [4]), 4); |
| |
| // memory_copy.wast:316 |
| assert_return(() => call($8, "load8_u", [5]), 1); |
| |
| // memory_copy.wast:317 |
| assert_return(() => call($8, "load8_u", [6]), 0); |
| |
| // memory_copy.wast:318 |
| assert_return(() => call($8, "load8_u", [7]), 0); |
| |
| // memory_copy.wast:319 |
| assert_return(() => call($8, "load8_u", [8]), 0); |
| |
| // memory_copy.wast:320 |
| assert_return(() => call($8, "load8_u", [9]), 0); |
| |
| // memory_copy.wast:321 |
| assert_return(() => call($8, "load8_u", [10]), 0); |
| |
| // memory_copy.wast:322 |
| assert_return(() => call($8, "load8_u", [11]), 0); |
| |
| // memory_copy.wast:323 |
| assert_return(() => call($8, "load8_u", [12]), 0); |
| |
| // memory_copy.wast:324 |
| assert_return(() => call($8, "load8_u", [13]), 0); |
| |
| // memory_copy.wast:325 |
| assert_return(() => call($8, "load8_u", [14]), 7); |
| |
| // memory_copy.wast:326 |
| assert_return(() => call($8, "load8_u", [15]), 5); |
| |
| // memory_copy.wast:327 |
| assert_return(() => call($8, "load8_u", [16]), 2); |
| |
| // memory_copy.wast:328 |
| assert_return(() => call($8, "load8_u", [17]), 3); |
| |
| // memory_copy.wast:329 |
| assert_return(() => call($8, "load8_u", [18]), 6); |
| |
| // memory_copy.wast:330 |
| assert_return(() => call($8, "load8_u", [19]), 0); |
| |
| // memory_copy.wast:331 |
| assert_return(() => call($8, "load8_u", [20]), 0); |
| |
| // memory_copy.wast:332 |
| assert_return(() => call($8, "load8_u", [21]), 0); |
| |
| // memory_copy.wast:333 |
| assert_return(() => call($8, "load8_u", [22]), 0); |
| |
| // memory_copy.wast:334 |
| assert_return(() => call($8, "load8_u", [23]), 0); |
| |
| // memory_copy.wast:335 |
| assert_return(() => call($8, "load8_u", [24]), 0); |
| |
| // memory_copy.wast:336 |
| assert_return(() => call($8, "load8_u", [25]), 0); |
| |
| // memory_copy.wast:337 |
| assert_return(() => call($8, "load8_u", [26]), 0); |
| |
| // memory_copy.wast:338 |
| assert_return(() => call($8, "load8_u", [27]), 0); |
| |
| // memory_copy.wast:339 |
| assert_return(() => call($8, "load8_u", [28]), 0); |
| |
| // memory_copy.wast:340 |
| assert_return(() => call($8, "load8_u", [29]), 0); |
| |
| // memory_copy.wast:342 |
| let $9 = 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\x9a\x80\x80\x80\x00\x01\x00\x41\x00\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:350 |
| assert_trap(() => call($9, "run", [65_516, 0, 40])); |
| |
| // memory_copy.wast:353 |
| assert_return(() => call($9, "load8_u", [0]), 0); |
| |
| // memory_copy.wast:354 |
| assert_return(() => call($9, "load8_u", [1]), 1); |
| |
| // memory_copy.wast:355 |
| assert_return(() => call($9, "load8_u", [2]), 2); |
| |
| // memory_copy.wast:356 |
| assert_return(() => call($9, "load8_u", [3]), 3); |
| |
| // memory_copy.wast:357 |
| assert_return(() => call($9, "load8_u", [4]), 4); |
| |
| // memory_copy.wast:358 |
| assert_return(() => call($9, "load8_u", [5]), 5); |
| |
| // memory_copy.wast:359 |
| assert_return(() => call($9, "load8_u", [6]), 6); |
| |
| // memory_copy.wast:360 |
| assert_return(() => call($9, "load8_u", [7]), 7); |
| |
| // memory_copy.wast:361 |
| assert_return(() => call($9, "load8_u", [8]), 8); |
| |
| // memory_copy.wast:362 |
| assert_return(() => call($9, "load8_u", [9]), 9); |
| |
| // memory_copy.wast:363 |
| assert_return(() => call($9, "load8_u", [10]), 10); |
| |
| // memory_copy.wast:364 |
| assert_return(() => call($9, "load8_u", [11]), 11); |
| |
| // memory_copy.wast:365 |
| assert_return(() => call($9, "load8_u", [12]), 12); |
| |
| // memory_copy.wast:366 |
| assert_return(() => call($9, "load8_u", [13]), 13); |
| |
| // memory_copy.wast:367 |
| assert_return(() => call($9, "load8_u", [14]), 14); |
| |
| // memory_copy.wast:368 |
| assert_return(() => call($9, "load8_u", [15]), 15); |
| |
| // memory_copy.wast:369 |
| assert_return(() => call($9, "load8_u", [16]), 16); |
| |
| // memory_copy.wast:370 |
| assert_return(() => call($9, "load8_u", [17]), 17); |
| |
| // memory_copy.wast:371 |
| assert_return(() => call($9, "load8_u", [18]), 18); |
| |
| // memory_copy.wast:372 |
| assert_return(() => call($9, "load8_u", [19]), 19); |
| |
| // memory_copy.wast:373 |
| assert_return(() => call($9, "load8_u", [218]), 0); |
| |
| // memory_copy.wast:374 |
| assert_return(() => call($9, "load8_u", [417]), 0); |
| |
| // memory_copy.wast:375 |
| assert_return(() => call($9, "load8_u", [616]), 0); |
| |
| // memory_copy.wast:376 |
| assert_return(() => call($9, "load8_u", [815]), 0); |
| |
| // memory_copy.wast:377 |
| assert_return(() => call($9, "load8_u", [1_014]), 0); |
| |
| // memory_copy.wast:378 |
| assert_return(() => call($9, "load8_u", [1_213]), 0); |
| |
| // memory_copy.wast:379 |
| assert_return(() => call($9, "load8_u", [1_412]), 0); |
| |
| // memory_copy.wast:380 |
| assert_return(() => call($9, "load8_u", [1_611]), 0); |
| |
| // memory_copy.wast:381 |
| assert_return(() => call($9, "load8_u", [1_810]), 0); |
| |
| // memory_copy.wast:382 |
| assert_return(() => call($9, "load8_u", [2_009]), 0); |
| |
| // memory_copy.wast:383 |
| assert_return(() => call($9, "load8_u", [2_208]), 0); |
| |
| // memory_copy.wast:384 |
| assert_return(() => call($9, "load8_u", [2_407]), 0); |
| |
| // memory_copy.wast:385 |
| assert_return(() => call($9, "load8_u", [2_606]), 0); |
| |
| // memory_copy.wast:386 |
| assert_return(() => call($9, "load8_u", [2_805]), 0); |
| |
| // memory_copy.wast:387 |
| assert_return(() => call($9, "load8_u", [3_004]), 0); |
| |
| // memory_copy.wast:388 |
| assert_return(() => call($9, "load8_u", [3_203]), 0); |
| |
| // memory_copy.wast:389 |
| assert_return(() => call($9, "load8_u", [3_402]), 0); |
| |
| // memory_copy.wast:390 |
| assert_return(() => call($9, "load8_u", [3_601]), 0); |
| |
| // memory_copy.wast:391 |
| assert_return(() => call($9, "load8_u", [3_800]), 0); |
| |
| // memory_copy.wast:392 |
| assert_return(() => call($9, "load8_u", [3_999]), 0); |
| |
| // memory_copy.wast:393 |
| assert_return(() => call($9, "load8_u", [4_198]), 0); |
| |
| // memory_copy.wast:394 |
| assert_return(() => call($9, "load8_u", [4_397]), 0); |
| |
| // memory_copy.wast:395 |
| assert_return(() => call($9, "load8_u", [4_596]), 0); |
| |
| // memory_copy.wast:396 |
| assert_return(() => call($9, "load8_u", [4_795]), 0); |
| |
| // memory_copy.wast:397 |
| assert_return(() => call($9, "load8_u", [4_994]), 0); |
| |
| // memory_copy.wast:398 |
| assert_return(() => call($9, "load8_u", [5_193]), 0); |
| |
| // memory_copy.wast:399 |
| assert_return(() => call($9, "load8_u", [5_392]), 0); |
| |
| // memory_copy.wast:400 |
| assert_return(() => call($9, "load8_u", [5_591]), 0); |
| |
| // memory_copy.wast:401 |
| assert_return(() => call($9, "load8_u", [5_790]), 0); |
| |
| // memory_copy.wast:402 |
| assert_return(() => call($9, "load8_u", [5_989]), 0); |
| |
| // memory_copy.wast:403 |
| assert_return(() => call($9, "load8_u", [6_188]), 0); |
| |
| // memory_copy.wast:404 |
| assert_return(() => call($9, "load8_u", [6_387]), 0); |
| |
| // memory_copy.wast:405 |
| assert_return(() => call($9, "load8_u", [6_586]), 0); |
| |
| // memory_copy.wast:406 |
| assert_return(() => call($9, "load8_u", [6_785]), 0); |
| |
| // memory_copy.wast:407 |
| assert_return(() => call($9, "load8_u", [6_984]), 0); |
| |
| // memory_copy.wast:408 |
| assert_return(() => call($9, "load8_u", [7_183]), 0); |
| |
| // memory_copy.wast:409 |
| assert_return(() => call($9, "load8_u", [7_382]), 0); |
| |
| // memory_copy.wast:410 |
| assert_return(() => call($9, "load8_u", [7_581]), 0); |
| |
| // memory_copy.wast:411 |
| assert_return(() => call($9, "load8_u", [7_780]), 0); |
| |
| // memory_copy.wast:412 |
| assert_return(() => call($9, "load8_u", [7_979]), 0); |
| |
| // memory_copy.wast:413 |
| assert_return(() => call($9, "load8_u", [8_178]), 0); |
| |
| // memory_copy.wast:414 |
| assert_return(() => call($9, "load8_u", [8_377]), 0); |
| |
| // memory_copy.wast:415 |
| assert_return(() => call($9, "load8_u", [8_576]), 0); |
| |
| // memory_copy.wast:416 |
| assert_return(() => call($9, "load8_u", [8_775]), 0); |
| |
| // memory_copy.wast:417 |
| assert_return(() => call($9, "load8_u", [8_974]), 0); |
| |
| // memory_copy.wast:418 |
| assert_return(() => call($9, "load8_u", [9_173]), 0); |
| |
| // memory_copy.wast:419 |
| assert_return(() => call($9, "load8_u", [9_372]), 0); |
| |
| // memory_copy.wast:420 |
| assert_return(() => call($9, "load8_u", [9_571]), 0); |
| |
| // memory_copy.wast:421 |
| assert_return(() => call($9, "load8_u", [9_770]), 0); |
| |
| // memory_copy.wast:422 |
| assert_return(() => call($9, "load8_u", [9_969]), 0); |
| |
| // memory_copy.wast:423 |
| assert_return(() => call($9, "load8_u", [10_168]), 0); |
| |
| // memory_copy.wast:424 |
| assert_return(() => call($9, "load8_u", [10_367]), 0); |
| |
| // memory_copy.wast:425 |
| assert_return(() => call($9, "load8_u", [10_566]), 0); |
| |
| // memory_copy.wast:426 |
| assert_return(() => call($9, "load8_u", [10_765]), 0); |
| |
| // memory_copy.wast:427 |
| assert_return(() => call($9, "load8_u", [10_964]), 0); |
| |
| // memory_copy.wast:428 |
| assert_return(() => call($9, "load8_u", [11_163]), 0); |
| |
| // memory_copy.wast:429 |
| assert_return(() => call($9, "load8_u", [11_362]), 0); |
| |
| // memory_copy.wast:430 |
| assert_return(() => call($9, "load8_u", [11_561]), 0); |
| |
| // memory_copy.wast:431 |
| assert_return(() => call($9, "load8_u", [11_760]), 0); |
| |
| // memory_copy.wast:432 |
| assert_return(() => call($9, "load8_u", [11_959]), 0); |
| |
| // memory_copy.wast:433 |
| assert_return(() => call($9, "load8_u", [12_158]), 0); |
| |
| // memory_copy.wast:434 |
| assert_return(() => call($9, "load8_u", [12_357]), 0); |
| |
| // memory_copy.wast:435 |
| assert_return(() => call($9, "load8_u", [12_556]), 0); |
| |
| // memory_copy.wast:436 |
| assert_return(() => call($9, "load8_u", [12_755]), 0); |
| |
| // memory_copy.wast:437 |
| assert_return(() => call($9, "load8_u", [12_954]), 0); |
| |
| // memory_copy.wast:438 |
| assert_return(() => call($9, "load8_u", [13_153]), 0); |
| |
| // memory_copy.wast:439 |
| assert_return(() => call($9, "load8_u", [13_352]), 0); |
| |
| // memory_copy.wast:440 |
| assert_return(() => call($9, "load8_u", [13_551]), 0); |
| |
| // memory_copy.wast:441 |
| assert_return(() => call($9, "load8_u", [13_750]), 0); |
| |
| // memory_copy.wast:442 |
| assert_return(() => call($9, "load8_u", [13_949]), 0); |
| |
| // memory_copy.wast:443 |
| assert_return(() => call($9, "load8_u", [14_148]), 0); |
| |
| // memory_copy.wast:444 |
| assert_return(() => call($9, "load8_u", [14_347]), 0); |
| |
| // memory_copy.wast:445 |
| assert_return(() => call($9, "load8_u", [14_546]), 0); |
| |
| // memory_copy.wast:446 |
| assert_return(() => call($9, "load8_u", [14_745]), 0); |
| |
| // memory_copy.wast:447 |
| assert_return(() => call($9, "load8_u", [14_944]), 0); |
| |
| // memory_copy.wast:448 |
| assert_return(() => call($9, "load8_u", [15_143]), 0); |
| |
| // memory_copy.wast:449 |
| assert_return(() => call($9, "load8_u", [15_342]), 0); |
| |
| // memory_copy.wast:450 |
| assert_return(() => call($9, "load8_u", [15_541]), 0); |
| |
| // memory_copy.wast:451 |
| assert_return(() => call($9, "load8_u", [15_740]), 0); |
| |
| // memory_copy.wast:452 |
| assert_return(() => call($9, "load8_u", [15_939]), 0); |
| |
| // memory_copy.wast:453 |
| assert_return(() => call($9, "load8_u", [16_138]), 0); |
| |
| // memory_copy.wast:454 |
| assert_return(() => call($9, "load8_u", [16_337]), 0); |
| |
| // memory_copy.wast:455 |
| assert_return(() => call($9, "load8_u", [16_536]), 0); |
| |
| // memory_copy.wast:456 |
| assert_return(() => call($9, "load8_u", [16_735]), 0); |
| |
| // memory_copy.wast:457 |
| assert_return(() => call($9, "load8_u", [16_934]), 0); |
| |
| // memory_copy.wast:458 |
| assert_return(() => call($9, "load8_u", [17_133]), 0); |
| |
| // memory_copy.wast:459 |
| assert_return(() => call($9, "load8_u", [17_332]), 0); |
| |
| // memory_copy.wast:460 |
| assert_return(() => call($9, "load8_u", [17_531]), 0); |
| |
| // memory_copy.wast:461 |
| assert_return(() => call($9, "load8_u", [17_730]), 0); |
| |
| // memory_copy.wast:462 |
| assert_return(() => call($9, "load8_u", [17_929]), 0); |
| |
| // memory_copy.wast:463 |
| assert_return(() => call($9, "load8_u", [18_128]), 0); |
| |
| // memory_copy.wast:464 |
| assert_return(() => call($9, "load8_u", [18_327]), 0); |
| |
| // memory_copy.wast:465 |
| assert_return(() => call($9, "load8_u", [18_526]), 0); |
| |
| // memory_copy.wast:466 |
| assert_return(() => call($9, "load8_u", [18_725]), 0); |
| |
| // memory_copy.wast:467 |
| assert_return(() => call($9, "load8_u", [18_924]), 0); |
| |
| // memory_copy.wast:468 |
| assert_return(() => call($9, "load8_u", [19_123]), 0); |
| |
| // memory_copy.wast:469 |
| assert_return(() => call($9, "load8_u", [19_322]), 0); |
| |
| // memory_copy.wast:470 |
| assert_return(() => call($9, "load8_u", [19_521]), 0); |
| |
| // memory_copy.wast:471 |
| assert_return(() => call($9, "load8_u", [19_720]), 0); |
| |
| // memory_copy.wast:472 |
| assert_return(() => call($9, "load8_u", [19_919]), 0); |
| |
| // memory_copy.wast:473 |
| assert_return(() => call($9, "load8_u", [20_118]), 0); |
| |
| // memory_copy.wast:474 |
| assert_return(() => call($9, "load8_u", [20_317]), 0); |
| |
| // memory_copy.wast:475 |
| assert_return(() => call($9, "load8_u", [20_516]), 0); |
| |
| // memory_copy.wast:476 |
| assert_return(() => call($9, "load8_u", [20_715]), 0); |
| |
| // memory_copy.wast:477 |
| assert_return(() => call($9, "load8_u", [20_914]), 0); |
| |
| // memory_copy.wast:478 |
| assert_return(() => call($9, "load8_u", [21_113]), 0); |
| |
| // memory_copy.wast:479 |
| assert_return(() => call($9, "load8_u", [21_312]), 0); |
| |
| // memory_copy.wast:480 |
| assert_return(() => call($9, "load8_u", [21_511]), 0); |
| |
| // memory_copy.wast:481 |
| assert_return(() => call($9, "load8_u", [21_710]), 0); |
| |
| // memory_copy.wast:482 |
| assert_return(() => call($9, "load8_u", [21_909]), 0); |
| |
| // memory_copy.wast:483 |
| assert_return(() => call($9, "load8_u", [22_108]), 0); |
| |
| // memory_copy.wast:484 |
| assert_return(() => call($9, "load8_u", [22_307]), 0); |
| |
| // memory_copy.wast:485 |
| assert_return(() => call($9, "load8_u", [22_506]), 0); |
| |
| // memory_copy.wast:486 |
| assert_return(() => call($9, "load8_u", [22_705]), 0); |
| |
| // memory_copy.wast:487 |
| assert_return(() => call($9, "load8_u", [22_904]), 0); |
| |
| // memory_copy.wast:488 |
| assert_return(() => call($9, "load8_u", [23_103]), 0); |
| |
| // memory_copy.wast:489 |
| assert_return(() => call($9, "load8_u", [23_302]), 0); |
| |
| // memory_copy.wast:490 |
| assert_return(() => call($9, "load8_u", [23_501]), 0); |
| |
| // memory_copy.wast:491 |
| assert_return(() => call($9, "load8_u", [23_700]), 0); |
| |
| // memory_copy.wast:492 |
| assert_return(() => call($9, "load8_u", [23_899]), 0); |
| |
| // memory_copy.wast:493 |
| assert_return(() => call($9, "load8_u", [24_098]), 0); |
| |
| // memory_copy.wast:494 |
| assert_return(() => call($9, "load8_u", [24_297]), 0); |
| |
| // memory_copy.wast:495 |
| assert_return(() => call($9, "load8_u", [24_496]), 0); |
| |
| // memory_copy.wast:496 |
| assert_return(() => call($9, "load8_u", [24_695]), 0); |
| |
| // memory_copy.wast:497 |
| assert_return(() => call($9, "load8_u", [24_894]), 0); |
| |
| // memory_copy.wast:498 |
| assert_return(() => call($9, "load8_u", [25_093]), 0); |
| |
| // memory_copy.wast:499 |
| assert_return(() => call($9, "load8_u", [25_292]), 0); |
| |
| // memory_copy.wast:500 |
| assert_return(() => call($9, "load8_u", [25_491]), 0); |
| |
| // memory_copy.wast:501 |
| assert_return(() => call($9, "load8_u", [25_690]), 0); |
| |
| // memory_copy.wast:502 |
| assert_return(() => call($9, "load8_u", [25_889]), 0); |
| |
| // memory_copy.wast:503 |
| assert_return(() => call($9, "load8_u", [26_088]), 0); |
| |
| // memory_copy.wast:504 |
| assert_return(() => call($9, "load8_u", [26_287]), 0); |
| |
| // memory_copy.wast:505 |
| assert_return(() => call($9, "load8_u", [26_486]), 0); |
| |
| // memory_copy.wast:506 |
| assert_return(() => call($9, "load8_u", [26_685]), 0); |
| |
| // memory_copy.wast:507 |
| assert_return(() => call($9, "load8_u", [26_884]), 0); |
| |
| // memory_copy.wast:508 |
| assert_return(() => call($9, "load8_u", [27_083]), 0); |
| |
| // memory_copy.wast:509 |
| assert_return(() => call($9, "load8_u", [27_282]), 0); |
| |
| // memory_copy.wast:510 |
| assert_return(() => call($9, "load8_u", [27_481]), 0); |
| |
| // memory_copy.wast:511 |
| assert_return(() => call($9, "load8_u", [27_680]), 0); |
| |
| // memory_copy.wast:512 |
| assert_return(() => call($9, "load8_u", [27_879]), 0); |
| |
| // memory_copy.wast:513 |
| assert_return(() => call($9, "load8_u", [28_078]), 0); |
| |
| // memory_copy.wast:514 |
| assert_return(() => call($9, "load8_u", [28_277]), 0); |
| |
| // memory_copy.wast:515 |
| assert_return(() => call($9, "load8_u", [28_476]), 0); |
| |
| // memory_copy.wast:516 |
| assert_return(() => call($9, "load8_u", [28_675]), 0); |
| |
| // memory_copy.wast:517 |
| assert_return(() => call($9, "load8_u", [28_874]), 0); |
| |
| // memory_copy.wast:518 |
| assert_return(() => call($9, "load8_u", [29_073]), 0); |
| |
| // memory_copy.wast:519 |
| assert_return(() => call($9, "load8_u", [29_272]), 0); |
| |
| // memory_copy.wast:520 |
| assert_return(() => call($9, "load8_u", [29_471]), 0); |
| |
| // memory_copy.wast:521 |
| assert_return(() => call($9, "load8_u", [29_670]), 0); |
| |
| // memory_copy.wast:522 |
| assert_return(() => call($9, "load8_u", [29_869]), 0); |
| |
| // memory_copy.wast:523 |
| assert_return(() => call($9, "load8_u", [30_068]), 0); |
| |
| // memory_copy.wast:524 |
| assert_return(() => call($9, "load8_u", [30_267]), 0); |
| |
| // memory_copy.wast:525 |
| assert_return(() => call($9, "load8_u", [30_466]), 0); |
| |
| // memory_copy.wast:526 |
| assert_return(() => call($9, "load8_u", [30_665]), 0); |
| |
| // memory_copy.wast:527 |
| assert_return(() => call($9, "load8_u", [30_864]), 0); |
| |
| // memory_copy.wast:528 |
| assert_return(() => call($9, "load8_u", [31_063]), 0); |
| |
| // memory_copy.wast:529 |
| assert_return(() => call($9, "load8_u", [31_262]), 0); |
| |
| // memory_copy.wast:530 |
| assert_return(() => call($9, "load8_u", [31_461]), 0); |
| |
| // memory_copy.wast:531 |
| assert_return(() => call($9, "load8_u", [31_660]), 0); |
| |
| // memory_copy.wast:532 |
| assert_return(() => call($9, "load8_u", [31_859]), 0); |
| |
| // memory_copy.wast:533 |
| assert_return(() => call($9, "load8_u", [32_058]), 0); |
| |
| // memory_copy.wast:534 |
| assert_return(() => call($9, "load8_u", [32_257]), 0); |
| |
| // memory_copy.wast:535 |
| assert_return(() => call($9, "load8_u", [32_456]), 0); |
| |
| // memory_copy.wast:536 |
| assert_return(() => call($9, "load8_u", [32_655]), 0); |
| |
| // memory_copy.wast:537 |
| assert_return(() => call($9, "load8_u", [32_854]), 0); |
| |
| // memory_copy.wast:538 |
| assert_return(() => call($9, "load8_u", [33_053]), 0); |
| |
| // memory_copy.wast:539 |
| assert_return(() => call($9, "load8_u", [33_252]), 0); |
| |
| // memory_copy.wast:540 |
| assert_return(() => call($9, "load8_u", [33_451]), 0); |
| |
| // memory_copy.wast:541 |
| assert_return(() => call($9, "load8_u", [33_650]), 0); |
| |
| // memory_copy.wast:542 |
| assert_return(() => call($9, "load8_u", [33_849]), 0); |
| |
| // memory_copy.wast:543 |
| assert_return(() => call($9, "load8_u", [34_048]), 0); |
| |
| // memory_copy.wast:544 |
| assert_return(() => call($9, "load8_u", [34_247]), 0); |
| |
| // memory_copy.wast:545 |
| assert_return(() => call($9, "load8_u", [34_446]), 0); |
| |
| // memory_copy.wast:546 |
| assert_return(() => call($9, "load8_u", [34_645]), 0); |
| |
| // memory_copy.wast:547 |
| assert_return(() => call($9, "load8_u", [34_844]), 0); |
| |
| // memory_copy.wast:548 |
| assert_return(() => call($9, "load8_u", [35_043]), 0); |
| |
| // memory_copy.wast:549 |
| assert_return(() => call($9, "load8_u", [35_242]), 0); |
| |
| // memory_copy.wast:550 |
| assert_return(() => call($9, "load8_u", [35_441]), 0); |
| |
| // memory_copy.wast:551 |
| assert_return(() => call($9, "load8_u", [35_640]), 0); |
| |
| // memory_copy.wast:552 |
| assert_return(() => call($9, "load8_u", [35_839]), 0); |
| |
| // memory_copy.wast:553 |
| assert_return(() => call($9, "load8_u", [36_038]), 0); |
| |
| // memory_copy.wast:554 |
| assert_return(() => call($9, "load8_u", [36_237]), 0); |
| |
| // memory_copy.wast:555 |
| assert_return(() => call($9, "load8_u", [36_436]), 0); |
| |
| // memory_copy.wast:556 |
| assert_return(() => call($9, "load8_u", [36_635]), 0); |
| |
| // memory_copy.wast:557 |
| assert_return(() => call($9, "load8_u", [36_834]), 0); |
| |
| // memory_copy.wast:558 |
| assert_return(() => call($9, "load8_u", [37_033]), 0); |
| |
| // memory_copy.wast:559 |
| assert_return(() => call($9, "load8_u", [37_232]), 0); |
| |
| // memory_copy.wast:560 |
| assert_return(() => call($9, "load8_u", [37_431]), 0); |
| |
| // memory_copy.wast:561 |
| assert_return(() => call($9, "load8_u", [37_630]), 0); |
| |
| // memory_copy.wast:562 |
| assert_return(() => call($9, "load8_u", [37_829]), 0); |
| |
| // memory_copy.wast:563 |
| assert_return(() => call($9, "load8_u", [38_028]), 0); |
| |
| // memory_copy.wast:564 |
| assert_return(() => call($9, "load8_u", [38_227]), 0); |
| |
| // memory_copy.wast:565 |
| assert_return(() => call($9, "load8_u", [38_426]), 0); |
| |
| // memory_copy.wast:566 |
| assert_return(() => call($9, "load8_u", [38_625]), 0); |
| |
| // memory_copy.wast:567 |
| assert_return(() => call($9, "load8_u", [38_824]), 0); |
| |
| // memory_copy.wast:568 |
| assert_return(() => call($9, "load8_u", [39_023]), 0); |
| |
| // memory_copy.wast:569 |
| assert_return(() => call($9, "load8_u", [39_222]), 0); |
| |
| // memory_copy.wast:570 |
| assert_return(() => call($9, "load8_u", [39_421]), 0); |
| |
| // memory_copy.wast:571 |
| assert_return(() => call($9, "load8_u", [39_620]), 0); |
| |
| // memory_copy.wast:572 |
| assert_return(() => call($9, "load8_u", [39_819]), 0); |
| |
| // memory_copy.wast:573 |
| assert_return(() => call($9, "load8_u", [40_018]), 0); |
| |
| // memory_copy.wast:574 |
| assert_return(() => call($9, "load8_u", [40_217]), 0); |
| |
| // memory_copy.wast:575 |
| assert_return(() => call($9, "load8_u", [40_416]), 0); |
| |
| // memory_copy.wast:576 |
| assert_return(() => call($9, "load8_u", [40_615]), 0); |
| |
| // memory_copy.wast:577 |
| assert_return(() => call($9, "load8_u", [40_814]), 0); |
| |
| // memory_copy.wast:578 |
| assert_return(() => call($9, "load8_u", [41_013]), 0); |
| |
| // memory_copy.wast:579 |
| assert_return(() => call($9, "load8_u", [41_212]), 0); |
| |
| // memory_copy.wast:580 |
| assert_return(() => call($9, "load8_u", [41_411]), 0); |
| |
| // memory_copy.wast:581 |
| assert_return(() => call($9, "load8_u", [41_610]), 0); |
| |
| // memory_copy.wast:582 |
| assert_return(() => call($9, "load8_u", [41_809]), 0); |
| |
| // memory_copy.wast:583 |
| assert_return(() => call($9, "load8_u", [42_008]), 0); |
| |
| // memory_copy.wast:584 |
| assert_return(() => call($9, "load8_u", [42_207]), 0); |
| |
| // memory_copy.wast:585 |
| assert_return(() => call($9, "load8_u", [42_406]), 0); |
| |
| // memory_copy.wast:586 |
| assert_return(() => call($9, "load8_u", [42_605]), 0); |
| |
| // memory_copy.wast:587 |
| assert_return(() => call($9, "load8_u", [42_804]), 0); |
| |
| // memory_copy.wast:588 |
| assert_return(() => call($9, "load8_u", [43_003]), 0); |
| |
| // memory_copy.wast:589 |
| assert_return(() => call($9, "load8_u", [43_202]), 0); |
| |
| // memory_copy.wast:590 |
| assert_return(() => call($9, "load8_u", [43_401]), 0); |
| |
| // memory_copy.wast:591 |
| assert_return(() => call($9, "load8_u", [43_600]), 0); |
| |
| // memory_copy.wast:592 |
| assert_return(() => call($9, "load8_u", [43_799]), 0); |
| |
| // memory_copy.wast:593 |
| assert_return(() => call($9, "load8_u", [43_998]), 0); |
| |
| // memory_copy.wast:594 |
| assert_return(() => call($9, "load8_u", [44_197]), 0); |
| |
| // memory_copy.wast:595 |
| assert_return(() => call($9, "load8_u", [44_396]), 0); |
| |
| // memory_copy.wast:596 |
| assert_return(() => call($9, "load8_u", [44_595]), 0); |
| |
| // memory_copy.wast:597 |
| assert_return(() => call($9, "load8_u", [44_794]), 0); |
| |
| // memory_copy.wast:598 |
| assert_return(() => call($9, "load8_u", [44_993]), 0); |
| |
| // memory_copy.wast:599 |
| assert_return(() => call($9, "load8_u", [45_192]), 0); |
| |
| // memory_copy.wast:600 |
| assert_return(() => call($9, "load8_u", [45_391]), 0); |
| |
| // memory_copy.wast:601 |
| assert_return(() => call($9, "load8_u", [45_590]), 0); |
| |
| // memory_copy.wast:602 |
| assert_return(() => call($9, "load8_u", [45_789]), 0); |
| |
| // memory_copy.wast:603 |
| assert_return(() => call($9, "load8_u", [45_988]), 0); |
| |
| // memory_copy.wast:604 |
| assert_return(() => call($9, "load8_u", [46_187]), 0); |
| |
| // memory_copy.wast:605 |
| assert_return(() => call($9, "load8_u", [46_386]), 0); |
| |
| // memory_copy.wast:606 |
| assert_return(() => call($9, "load8_u", [46_585]), 0); |
| |
| // memory_copy.wast:607 |
| assert_return(() => call($9, "load8_u", [46_784]), 0); |
| |
| // memory_copy.wast:608 |
| assert_return(() => call($9, "load8_u", [46_983]), 0); |
| |
| // memory_copy.wast:609 |
| assert_return(() => call($9, "load8_u", [47_182]), 0); |
| |
| // memory_copy.wast:610 |
| assert_return(() => call($9, "load8_u", [47_381]), 0); |
| |
| // memory_copy.wast:611 |
| assert_return(() => call($9, "load8_u", [47_580]), 0); |
| |
| // memory_copy.wast:612 |
| assert_return(() => call($9, "load8_u", [47_779]), 0); |
| |
| // memory_copy.wast:613 |
| assert_return(() => call($9, "load8_u", [47_978]), 0); |
| |
| // memory_copy.wast:614 |
| assert_return(() => call($9, "load8_u", [48_177]), 0); |
| |
| // memory_copy.wast:615 |
| assert_return(() => call($9, "load8_u", [48_376]), 0); |
| |
| // memory_copy.wast:616 |
| assert_return(() => call($9, "load8_u", [48_575]), 0); |
| |
| // memory_copy.wast:617 |
| assert_return(() => call($9, "load8_u", [48_774]), 0); |
| |
| // memory_copy.wast:618 |
| assert_return(() => call($9, "load8_u", [48_973]), 0); |
| |
| // memory_copy.wast:619 |
| assert_return(() => call($9, "load8_u", [49_172]), 0); |
| |
| // memory_copy.wast:620 |
| assert_return(() => call($9, "load8_u", [49_371]), 0); |
| |
| // memory_copy.wast:621 |
| assert_return(() => call($9, "load8_u", [49_570]), 0); |
| |
| // memory_copy.wast:622 |
| assert_return(() => call($9, "load8_u", [49_769]), 0); |
| |
| // memory_copy.wast:623 |
| assert_return(() => call($9, "load8_u", [49_968]), 0); |
| |
| // memory_copy.wast:624 |
| assert_return(() => call($9, "load8_u", [50_167]), 0); |
| |
| // memory_copy.wast:625 |
| assert_return(() => call($9, "load8_u", [50_366]), 0); |
| |
| // memory_copy.wast:626 |
| assert_return(() => call($9, "load8_u", [50_565]), 0); |
| |
| // memory_copy.wast:627 |
| assert_return(() => call($9, "load8_u", [50_764]), 0); |
| |
| // memory_copy.wast:628 |
| assert_return(() => call($9, "load8_u", [50_963]), 0); |
| |
| // memory_copy.wast:629 |
| assert_return(() => call($9, "load8_u", [51_162]), 0); |
| |
| // memory_copy.wast:630 |
| assert_return(() => call($9, "load8_u", [51_361]), 0); |
| |
| // memory_copy.wast:631 |
| assert_return(() => call($9, "load8_u", [51_560]), 0); |
| |
| // memory_copy.wast:632 |
| assert_return(() => call($9, "load8_u", [51_759]), 0); |
| |
| // memory_copy.wast:633 |
| assert_return(() => call($9, "load8_u", [51_958]), 0); |
| |
| // memory_copy.wast:634 |
| assert_return(() => call($9, "load8_u", [52_157]), 0); |
| |
| // memory_copy.wast:635 |
| assert_return(() => call($9, "load8_u", [52_356]), 0); |
| |
| // memory_copy.wast:636 |
| assert_return(() => call($9, "load8_u", [52_555]), 0); |
| |
| // memory_copy.wast:637 |
| assert_return(() => call($9, "load8_u", [52_754]), 0); |
| |
| // memory_copy.wast:638 |
| assert_return(() => call($9, "load8_u", [52_953]), 0); |
| |
| // memory_copy.wast:639 |
| assert_return(() => call($9, "load8_u", [53_152]), 0); |
| |
| // memory_copy.wast:640 |
| assert_return(() => call($9, "load8_u", [53_351]), 0); |
| |
| // memory_copy.wast:641 |
| assert_return(() => call($9, "load8_u", [53_550]), 0); |
| |
| // memory_copy.wast:642 |
| assert_return(() => call($9, "load8_u", [53_749]), 0); |
| |
| // memory_copy.wast:643 |
| assert_return(() => call($9, "load8_u", [53_948]), 0); |
| |
| // memory_copy.wast:644 |
| assert_return(() => call($9, "load8_u", [54_147]), 0); |
| |
| // memory_copy.wast:645 |
| assert_return(() => call($9, "load8_u", [54_346]), 0); |
| |
| // memory_copy.wast:646 |
| assert_return(() => call($9, "load8_u", [54_545]), 0); |
| |
| // memory_copy.wast:647 |
| assert_return(() => call($9, "load8_u", [54_744]), 0); |
| |
| // memory_copy.wast:648 |
| assert_return(() => call($9, "load8_u", [54_943]), 0); |
| |
| // memory_copy.wast:649 |
| assert_return(() => call($9, "load8_u", [55_142]), 0); |
| |
| // memory_copy.wast:650 |
| assert_return(() => call($9, "load8_u", [55_341]), 0); |
| |
| // memory_copy.wast:651 |
| assert_return(() => call($9, "load8_u", [55_540]), 0); |
| |
| // memory_copy.wast:652 |
| assert_return(() => call($9, "load8_u", [55_739]), 0); |
| |
| // memory_copy.wast:653 |
| assert_return(() => call($9, "load8_u", [55_938]), 0); |
| |
| // memory_copy.wast:654 |
| assert_return(() => call($9, "load8_u", [56_137]), 0); |
| |
| // memory_copy.wast:655 |
| assert_return(() => call($9, "load8_u", [56_336]), 0); |
| |
| // memory_copy.wast:656 |
| assert_return(() => call($9, "load8_u", [56_535]), 0); |
| |
| // memory_copy.wast:657 |
| assert_return(() => call($9, "load8_u", [56_734]), 0); |
| |
| // memory_copy.wast:658 |
| assert_return(() => call($9, "load8_u", [56_933]), 0); |
| |
| // memory_copy.wast:659 |
| assert_return(() => call($9, "load8_u", [57_132]), 0); |
| |
| // memory_copy.wast:660 |
| assert_return(() => call($9, "load8_u", [57_331]), 0); |
| |
| // memory_copy.wast:661 |
| assert_return(() => call($9, "load8_u", [57_530]), 0); |
| |
| // memory_copy.wast:662 |
| assert_return(() => call($9, "load8_u", [57_729]), 0); |
| |
| // memory_copy.wast:663 |
| assert_return(() => call($9, "load8_u", [57_928]), 0); |
| |
| // memory_copy.wast:664 |
| assert_return(() => call($9, "load8_u", [58_127]), 0); |
| |
| // memory_copy.wast:665 |
| assert_return(() => call($9, "load8_u", [58_326]), 0); |
| |
| // memory_copy.wast:666 |
| assert_return(() => call($9, "load8_u", [58_525]), 0); |
| |
| // memory_copy.wast:667 |
| assert_return(() => call($9, "load8_u", [58_724]), 0); |
| |
| // memory_copy.wast:668 |
| assert_return(() => call($9, "load8_u", [58_923]), 0); |
| |
| // memory_copy.wast:669 |
| assert_return(() => call($9, "load8_u", [59_122]), 0); |
| |
| // memory_copy.wast:670 |
| assert_return(() => call($9, "load8_u", [59_321]), 0); |
| |
| // memory_copy.wast:671 |
| assert_return(() => call($9, "load8_u", [59_520]), 0); |
| |
| // memory_copy.wast:672 |
| assert_return(() => call($9, "load8_u", [59_719]), 0); |
| |
| // memory_copy.wast:673 |
| assert_return(() => call($9, "load8_u", [59_918]), 0); |
| |
| // memory_copy.wast:674 |
| assert_return(() => call($9, "load8_u", [60_117]), 0); |
| |
| // memory_copy.wast:675 |
| assert_return(() => call($9, "load8_u", [60_316]), 0); |
| |
| // memory_copy.wast:676 |
| assert_return(() => call($9, "load8_u", [60_515]), 0); |
| |
| // memory_copy.wast:677 |
| assert_return(() => call($9, "load8_u", [60_714]), 0); |
| |
| // memory_copy.wast:678 |
| assert_return(() => call($9, "load8_u", [60_913]), 0); |
| |
| // memory_copy.wast:679 |
| assert_return(() => call($9, "load8_u", [61_112]), 0); |
| |
| // memory_copy.wast:680 |
| assert_return(() => call($9, "load8_u", [61_311]), 0); |
| |
| // memory_copy.wast:681 |
| assert_return(() => call($9, "load8_u", [61_510]), 0); |
| |
| // memory_copy.wast:682 |
| assert_return(() => call($9, "load8_u", [61_709]), 0); |
| |
| // memory_copy.wast:683 |
| assert_return(() => call($9, "load8_u", [61_908]), 0); |
| |
| // memory_copy.wast:684 |
| assert_return(() => call($9, "load8_u", [62_107]), 0); |
| |
| // memory_copy.wast:685 |
| assert_return(() => call($9, "load8_u", [62_306]), 0); |
| |
| // memory_copy.wast:686 |
| assert_return(() => call($9, "load8_u", [62_505]), 0); |
| |
| // memory_copy.wast:687 |
| assert_return(() => call($9, "load8_u", [62_704]), 0); |
| |
| // memory_copy.wast:688 |
| assert_return(() => call($9, "load8_u", [62_903]), 0); |
| |
| // memory_copy.wast:689 |
| assert_return(() => call($9, "load8_u", [63_102]), 0); |
| |
| // memory_copy.wast:690 |
| assert_return(() => call($9, "load8_u", [63_301]), 0); |
| |
| // memory_copy.wast:691 |
| assert_return(() => call($9, "load8_u", [63_500]), 0); |
| |
| // memory_copy.wast:692 |
| assert_return(() => call($9, "load8_u", [63_699]), 0); |
| |
| // memory_copy.wast:693 |
| assert_return(() => call($9, "load8_u", [63_898]), 0); |
| |
| // memory_copy.wast:694 |
| assert_return(() => call($9, "load8_u", [64_097]), 0); |
| |
| // memory_copy.wast:695 |
| assert_return(() => call($9, "load8_u", [64_296]), 0); |
| |
| // memory_copy.wast:696 |
| assert_return(() => call($9, "load8_u", [64_495]), 0); |
| |
| // memory_copy.wast:697 |
| assert_return(() => call($9, "load8_u", [64_694]), 0); |
| |
| // memory_copy.wast:698 |
| assert_return(() => call($9, "load8_u", [64_893]), 0); |
| |
| // memory_copy.wast:699 |
| assert_return(() => call($9, "load8_u", [65_092]), 0); |
| |
| // memory_copy.wast:700 |
| assert_return(() => call($9, "load8_u", [65_291]), 0); |
| |
| // memory_copy.wast:701 |
| assert_return(() => call($9, "load8_u", [65_490]), 0); |
| |
| // memory_copy.wast:703 |
| let $10 = 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\x9b\x80\x80\x80\x00\x01\x00\x41\x00\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:711 |
| assert_trap(() => call($10, "run", [65_515, 0, 39])); |
| |
| // memory_copy.wast:714 |
| assert_return(() => call($10, "load8_u", [0]), 0); |
| |
| // memory_copy.wast:715 |
| assert_return(() => call($10, "load8_u", [1]), 1); |
| |
| // memory_copy.wast:716 |
| assert_return(() => call($10, "load8_u", [2]), 2); |
| |
| // memory_copy.wast:717 |
| assert_return(() => call($10, "load8_u", [3]), 3); |
| |
| // memory_copy.wast:718 |
| assert_return(() => call($10, "load8_u", [4]), 4); |
| |
| // memory_copy.wast:719 |
| assert_return(() => call($10, "load8_u", [5]), 5); |
| |
| // memory_copy.wast:720 |
| assert_return(() => call($10, "load8_u", [6]), 6); |
| |
| // memory_copy.wast:721 |
| assert_return(() => call($10, "load8_u", [7]), 7); |
| |
| // memory_copy.wast:722 |
| assert_return(() => call($10, "load8_u", [8]), 8); |
| |
| // memory_copy.wast:723 |
| assert_return(() => call($10, "load8_u", [9]), 9); |
| |
| // memory_copy.wast:724 |
| assert_return(() => call($10, "load8_u", [10]), 10); |
| |
| // memory_copy.wast:725 |
| assert_return(() => call($10, "load8_u", [11]), 11); |
| |
| // memory_copy.wast:726 |
| assert_return(() => call($10, "load8_u", [12]), 12); |
| |
| // memory_copy.wast:727 |
| assert_return(() => call($10, "load8_u", [13]), 13); |
| |
| // memory_copy.wast:728 |
| assert_return(() => call($10, "load8_u", [14]), 14); |
| |
| // memory_copy.wast:729 |
| assert_return(() => call($10, "load8_u", [15]), 15); |
| |
| // memory_copy.wast:730 |
| assert_return(() => call($10, "load8_u", [16]), 16); |
| |
| // memory_copy.wast:731 |
| assert_return(() => call($10, "load8_u", [17]), 17); |
| |
| // memory_copy.wast:732 |
| assert_return(() => call($10, "load8_u", [18]), 18); |
| |
| // memory_copy.wast:733 |
| assert_return(() => call($10, "load8_u", [19]), 19); |
| |
| // memory_copy.wast:734 |
| assert_return(() => call($10, "load8_u", [20]), 20); |
| |
| // memory_copy.wast:735 |
| assert_return(() => call($10, "load8_u", [219]), 0); |
| |
| // memory_copy.wast:736 |
| assert_return(() => call($10, "load8_u", [418]), 0); |
| |
| // memory_copy.wast:737 |
| assert_return(() => call($10, "load8_u", [617]), 0); |
| |
| // memory_copy.wast:738 |
| assert_return(() => call($10, "load8_u", [816]), 0); |
| |
| // memory_copy.wast:739 |
| assert_return(() => call($10, "load8_u", [1_015]), 0); |
| |
| // memory_copy.wast:740 |
| assert_return(() => call($10, "load8_u", [1_214]), 0); |
| |
| // memory_copy.wast:741 |
| assert_return(() => call($10, "load8_u", [1_413]), 0); |
| |
| // memory_copy.wast:742 |
| assert_return(() => call($10, "load8_u", [1_612]), 0); |
| |
| // memory_copy.wast:743 |
| assert_return(() => call($10, "load8_u", [1_811]), 0); |
| |
| // memory_copy.wast:744 |
| assert_return(() => call($10, "load8_u", [2_010]), 0); |
| |
| // memory_copy.wast:745 |
| assert_return(() => call($10, "load8_u", [2_209]), 0); |
| |
| // memory_copy.wast:746 |
| assert_return(() => call($10, "load8_u", [2_408]), 0); |
| |
| // memory_copy.wast:747 |
| assert_return(() => call($10, "load8_u", [2_607]), 0); |
| |
| // memory_copy.wast:748 |
| assert_return(() => call($10, "load8_u", [2_806]), 0); |
| |
| // memory_copy.wast:749 |
| assert_return(() => call($10, "load8_u", [3_005]), 0); |
| |
| // memory_copy.wast:750 |
| assert_return(() => call($10, "load8_u", [3_204]), 0); |
| |
| // memory_copy.wast:751 |
| assert_return(() => call($10, "load8_u", [3_403]), 0); |
| |
| // memory_copy.wast:752 |
| assert_return(() => call($10, "load8_u", [3_602]), 0); |
| |
| // memory_copy.wast:753 |
| assert_return(() => call($10, "load8_u", [3_801]), 0); |
| |
| // memory_copy.wast:754 |
| assert_return(() => call($10, "load8_u", [4_000]), 0); |
| |
| // memory_copy.wast:755 |
| assert_return(() => call($10, "load8_u", [4_199]), 0); |
| |
| // memory_copy.wast:756 |
| assert_return(() => call($10, "load8_u", [4_398]), 0); |
| |
| // memory_copy.wast:757 |
| assert_return(() => call($10, "load8_u", [4_597]), 0); |
| |
| // memory_copy.wast:758 |
| assert_return(() => call($10, "load8_u", [4_796]), 0); |
| |
| // memory_copy.wast:759 |
| assert_return(() => call($10, "load8_u", [4_995]), 0); |
| |
| // memory_copy.wast:760 |
| assert_return(() => call($10, "load8_u", [5_194]), 0); |
| |
| // memory_copy.wast:761 |
| assert_return(() => call($10, "load8_u", [5_393]), 0); |
| |
| // memory_copy.wast:762 |
| assert_return(() => call($10, "load8_u", [5_592]), 0); |
| |
| // memory_copy.wast:763 |
| assert_return(() => call($10, "load8_u", [5_791]), 0); |
| |
| // memory_copy.wast:764 |
| assert_return(() => call($10, "load8_u", [5_990]), 0); |
| |
| // memory_copy.wast:765 |
| assert_return(() => call($10, "load8_u", [6_189]), 0); |
| |
| // memory_copy.wast:766 |
| assert_return(() => call($10, "load8_u", [6_388]), 0); |
| |
| // memory_copy.wast:767 |
| assert_return(() => call($10, "load8_u", [6_587]), 0); |
| |
| // memory_copy.wast:768 |
| assert_return(() => call($10, "load8_u", [6_786]), 0); |
| |
| // memory_copy.wast:769 |
| assert_return(() => call($10, "load8_u", [6_985]), 0); |
| |
| // memory_copy.wast:770 |
| assert_return(() => call($10, "load8_u", [7_184]), 0); |
| |
| // memory_copy.wast:771 |
| assert_return(() => call($10, "load8_u", [7_383]), 0); |
| |
| // memory_copy.wast:772 |
| assert_return(() => call($10, "load8_u", [7_582]), 0); |
| |
| // memory_copy.wast:773 |
| assert_return(() => call($10, "load8_u", [7_781]), 0); |
| |
| // memory_copy.wast:774 |
| assert_return(() => call($10, "load8_u", [7_980]), 0); |
| |
| // memory_copy.wast:775 |
| assert_return(() => call($10, "load8_u", [8_179]), 0); |
| |
| // memory_copy.wast:776 |
| assert_return(() => call($10, "load8_u", [8_378]), 0); |
| |
| // memory_copy.wast:777 |
| assert_return(() => call($10, "load8_u", [8_577]), 0); |
| |
| // memory_copy.wast:778 |
| assert_return(() => call($10, "load8_u", [8_776]), 0); |
| |
| // memory_copy.wast:779 |
| assert_return(() => call($10, "load8_u", [8_975]), 0); |
| |
| // memory_copy.wast:780 |
| assert_return(() => call($10, "load8_u", [9_174]), 0); |
| |
| // memory_copy.wast:781 |
| assert_return(() => call($10, "load8_u", [9_373]), 0); |
| |
| // memory_copy.wast:782 |
| assert_return(() => call($10, "load8_u", [9_572]), 0); |
| |
| // memory_copy.wast:783 |
| assert_return(() => call($10, "load8_u", [9_771]), 0); |
| |
| // memory_copy.wast:784 |
| assert_return(() => call($10, "load8_u", [9_970]), 0); |
| |
| // memory_copy.wast:785 |
| assert_return(() => call($10, "load8_u", [10_169]), 0); |
| |
| // memory_copy.wast:786 |
| assert_return(() => call($10, "load8_u", [10_368]), 0); |
| |
| // memory_copy.wast:787 |
| assert_return(() => call($10, "load8_u", [10_567]), 0); |
| |
| // memory_copy.wast:788 |
| assert_return(() => call($10, "load8_u", [10_766]), 0); |
| |
| // memory_copy.wast:789 |
| assert_return(() => call($10, "load8_u", [10_965]), 0); |
| |
| // memory_copy.wast:790 |
| assert_return(() => call($10, "load8_u", [11_164]), 0); |
| |
| // memory_copy.wast:791 |
| assert_return(() => call($10, "load8_u", [11_363]), 0); |
| |
| // memory_copy.wast:792 |
| assert_return(() => call($10, "load8_u", [11_562]), 0); |
| |
| // memory_copy.wast:793 |
| assert_return(() => call($10, "load8_u", [11_761]), 0); |
| |
| // memory_copy.wast:794 |
| assert_return(() => call($10, "load8_u", [11_960]), 0); |
| |
| // memory_copy.wast:795 |
| assert_return(() => call($10, "load8_u", [12_159]), 0); |
| |
| // memory_copy.wast:796 |
| assert_return(() => call($10, "load8_u", [12_358]), 0); |
| |
| // memory_copy.wast:797 |
| assert_return(() => call($10, "load8_u", [12_557]), 0); |
| |
| // memory_copy.wast:798 |
| assert_return(() => call($10, "load8_u", [12_756]), 0); |
| |
| // memory_copy.wast:799 |
| assert_return(() => call($10, "load8_u", [12_955]), 0); |
| |
| // memory_copy.wast:800 |
| assert_return(() => call($10, "load8_u", [13_154]), 0); |
| |
| // memory_copy.wast:801 |
| assert_return(() => call($10, "load8_u", [13_353]), 0); |
| |
| // memory_copy.wast:802 |
| assert_return(() => call($10, "load8_u", [13_552]), 0); |
| |
| // memory_copy.wast:803 |
| assert_return(() => call($10, "load8_u", [13_751]), 0); |
| |
| // memory_copy.wast:804 |
| assert_return(() => call($10, "load8_u", [13_950]), 0); |
| |
| // memory_copy.wast:805 |
| assert_return(() => call($10, "load8_u", [14_149]), 0); |
| |
| // memory_copy.wast:806 |
| assert_return(() => call($10, "load8_u", [14_348]), 0); |
| |
| // memory_copy.wast:807 |
| assert_return(() => call($10, "load8_u", [14_547]), 0); |
| |
| // memory_copy.wast:808 |
| assert_return(() => call($10, "load8_u", [14_746]), 0); |
| |
| // memory_copy.wast:809 |
| assert_return(() => call($10, "load8_u", [14_945]), 0); |
| |
| // memory_copy.wast:810 |
| assert_return(() => call($10, "load8_u", [15_144]), 0); |
| |
| // memory_copy.wast:811 |
| assert_return(() => call($10, "load8_u", [15_343]), 0); |
| |
| // memory_copy.wast:812 |
| assert_return(() => call($10, "load8_u", [15_542]), 0); |
| |
| // memory_copy.wast:813 |
| assert_return(() => call($10, "load8_u", [15_741]), 0); |
| |
| // memory_copy.wast:814 |
| assert_return(() => call($10, "load8_u", [15_940]), 0); |
| |
| // memory_copy.wast:815 |
| assert_return(() => call($10, "load8_u", [16_139]), 0); |
| |
| // memory_copy.wast:816 |
| assert_return(() => call($10, "load8_u", [16_338]), 0); |
| |
| // memory_copy.wast:817 |
| assert_return(() => call($10, "load8_u", [16_537]), 0); |
| |
| // memory_copy.wast:818 |
| assert_return(() => call($10, "load8_u", [16_736]), 0); |
| |
| // memory_copy.wast:819 |
| assert_return(() => call($10, "load8_u", [16_935]), 0); |
| |
| // memory_copy.wast:820 |
| assert_return(() => call($10, "load8_u", [17_134]), 0); |
| |
| // memory_copy.wast:821 |
| assert_return(() => call($10, "load8_u", [17_333]), 0); |
| |
| // memory_copy.wast:822 |
| assert_return(() => call($10, "load8_u", [17_532]), 0); |
| |
| // memory_copy.wast:823 |
| assert_return(() => call($10, "load8_u", [17_731]), 0); |
| |
| // memory_copy.wast:824 |
| assert_return(() => call($10, "load8_u", [17_930]), 0); |
| |
| // memory_copy.wast:825 |
| assert_return(() => call($10, "load8_u", [18_129]), 0); |
| |
| // memory_copy.wast:826 |
| assert_return(() => call($10, "load8_u", [18_328]), 0); |
| |
| // memory_copy.wast:827 |
| assert_return(() => call($10, "load8_u", [18_527]), 0); |
| |
| // memory_copy.wast:828 |
| assert_return(() => call($10, "load8_u", [18_726]), 0); |
| |
| // memory_copy.wast:829 |
| assert_return(() => call($10, "load8_u", [18_925]), 0); |
| |
| // memory_copy.wast:830 |
| assert_return(() => call($10, "load8_u", [19_124]), 0); |
| |
| // memory_copy.wast:831 |
| assert_return(() => call($10, "load8_u", [19_323]), 0); |
| |
| // memory_copy.wast:832 |
| assert_return(() => call($10, "load8_u", [19_522]), 0); |
| |
| // memory_copy.wast:833 |
| assert_return(() => call($10, "load8_u", [19_721]), 0); |
| |
| // memory_copy.wast:834 |
| assert_return(() => call($10, "load8_u", [19_920]), 0); |
| |
| // memory_copy.wast:835 |
| assert_return(() => call($10, "load8_u", [20_119]), 0); |
| |
| // memory_copy.wast:836 |
| assert_return(() => call($10, "load8_u", [20_318]), 0); |
| |
| // memory_copy.wast:837 |
| assert_return(() => call($10, "load8_u", [20_517]), 0); |
| |
| // memory_copy.wast:838 |
| assert_return(() => call($10, "load8_u", [20_716]), 0); |
| |
| // memory_copy.wast:839 |
| assert_return(() => call($10, "load8_u", [20_915]), 0); |
| |
| // memory_copy.wast:840 |
| assert_return(() => call($10, "load8_u", [21_114]), 0); |
| |
| // memory_copy.wast:841 |
| assert_return(() => call($10, "load8_u", [21_313]), 0); |
| |
| // memory_copy.wast:842 |
| assert_return(() => call($10, "load8_u", [21_512]), 0); |
| |
| // memory_copy.wast:843 |
| assert_return(() => call($10, "load8_u", [21_711]), 0); |
| |
| // memory_copy.wast:844 |
| assert_return(() => call($10, "load8_u", [21_910]), 0); |
| |
| // memory_copy.wast:845 |
| assert_return(() => call($10, "load8_u", [22_109]), 0); |
| |
| // memory_copy.wast:846 |
| assert_return(() => call($10, "load8_u", [22_308]), 0); |
| |
| // memory_copy.wast:847 |
| assert_return(() => call($10, "load8_u", [22_507]), 0); |
| |
| // memory_copy.wast:848 |
| assert_return(() => call($10, "load8_u", [22_706]), 0); |
| |
| // memory_copy.wast:849 |
| assert_return(() => call($10, "load8_u", [22_905]), 0); |
| |
| // memory_copy.wast:850 |
| assert_return(() => call($10, "load8_u", [23_104]), 0); |
| |
| // memory_copy.wast:851 |
| assert_return(() => call($10, "load8_u", [23_303]), 0); |
| |
| // memory_copy.wast:852 |
| assert_return(() => call($10, "load8_u", [23_502]), 0); |
| |
| // memory_copy.wast:853 |
| assert_return(() => call($10, "load8_u", [23_701]), 0); |
| |
| // memory_copy.wast:854 |
| assert_return(() => call($10, "load8_u", [23_900]), 0); |
| |
| // memory_copy.wast:855 |
| assert_return(() => call($10, "load8_u", [24_099]), 0); |
| |
| // memory_copy.wast:856 |
| assert_return(() => call($10, "load8_u", [24_298]), 0); |
| |
| // memory_copy.wast:857 |
| assert_return(() => call($10, "load8_u", [24_497]), 0); |
| |
| // memory_copy.wast:858 |
| assert_return(() => call($10, "load8_u", [24_696]), 0); |
| |
| // memory_copy.wast:859 |
| assert_return(() => call($10, "load8_u", [24_895]), 0); |
| |
| // memory_copy.wast:860 |
| assert_return(() => call($10, "load8_u", [25_094]), 0); |
| |
| // memory_copy.wast:861 |
| assert_return(() => call($10, "load8_u", [25_293]), 0); |
| |
| // memory_copy.wast:862 |
| assert_return(() => call($10, "load8_u", [25_492]), 0); |
| |
| // memory_copy.wast:863 |
| assert_return(() => call($10, "load8_u", [25_691]), 0); |
| |
| // memory_copy.wast:864 |
| assert_return(() => call($10, "load8_u", [25_890]), 0); |
| |
| // memory_copy.wast:865 |
| assert_return(() => call($10, "load8_u", [26_089]), 0); |
| |
| // memory_copy.wast:866 |
| assert_return(() => call($10, "load8_u", [26_288]), 0); |
| |
| // memory_copy.wast:867 |
| assert_return(() => call($10, "load8_u", [26_487]), 0); |
| |
| // memory_copy.wast:868 |
| assert_return(() => call($10, "load8_u", [26_686]), 0); |
| |
| // memory_copy.wast:869 |
| assert_return(() => call($10, "load8_u", [26_885]), 0); |
| |
| // memory_copy.wast:870 |
| assert_return(() => call($10, "load8_u", [27_084]), 0); |
| |
| // memory_copy.wast:871 |
| assert_return(() => call($10, "load8_u", [27_283]), 0); |
| |
| // memory_copy.wast:872 |
| assert_return(() => call($10, "load8_u", [27_482]), 0); |
| |
| // memory_copy.wast:873 |
| assert_return(() => call($10, "load8_u", [27_681]), 0); |
| |
| // memory_copy.wast:874 |
| assert_return(() => call($10, "load8_u", [27_880]), 0); |
| |
| // memory_copy.wast:875 |
| assert_return(() => call($10, "load8_u", [28_079]), 0); |
| |
| // memory_copy.wast:876 |
| assert_return(() => call($10, "load8_u", [28_278]), 0); |
| |
| // memory_copy.wast:877 |
| assert_return(() => call($10, "load8_u", [28_477]), 0); |
| |
| // memory_copy.wast:878 |
| assert_return(() => call($10, "load8_u", [28_676]), 0); |
| |
| // memory_copy.wast:879 |
| assert_return(() => call($10, "load8_u", [28_875]), 0); |
| |
| // memory_copy.wast:880 |
| assert_return(() => call($10, "load8_u", [29_074]), 0); |
| |
| // memory_copy.wast:881 |
| assert_return(() => call($10, "load8_u", [29_273]), 0); |
| |
| // memory_copy.wast:882 |
| assert_return(() => call($10, "load8_u", [29_472]), 0); |
| |
| // memory_copy.wast:883 |
| assert_return(() => call($10, "load8_u", [29_671]), 0); |
| |
| // memory_copy.wast:884 |
| assert_return(() => call($10, "load8_u", [29_870]), 0); |
| |
| // memory_copy.wast:885 |
| assert_return(() => call($10, "load8_u", [30_069]), 0); |
| |
| // memory_copy.wast:886 |
| assert_return(() => call($10, "load8_u", [30_268]), 0); |
| |
| // memory_copy.wast:887 |
| assert_return(() => call($10, "load8_u", [30_467]), 0); |
| |
| // memory_copy.wast:888 |
| assert_return(() => call($10, "load8_u", [30_666]), 0); |
| |
| // memory_copy.wast:889 |
| assert_return(() => call($10, "load8_u", [30_865]), 0); |
| |
| // memory_copy.wast:890 |
| assert_return(() => call($10, "load8_u", [31_064]), 0); |
| |
| // memory_copy.wast:891 |
| assert_return(() => call($10, "load8_u", [31_263]), 0); |
| |
| // memory_copy.wast:892 |
| assert_return(() => call($10, "load8_u", [31_462]), 0); |
| |
| // memory_copy.wast:893 |
| assert_return(() => call($10, "load8_u", [31_661]), 0); |
| |
| // memory_copy.wast:894 |
| assert_return(() => call($10, "load8_u", [31_860]), 0); |
| |
| // memory_copy.wast:895 |
| assert_return(() => call($10, "load8_u", [32_059]), 0); |
| |
| // memory_copy.wast:896 |
| assert_return(() => call($10, "load8_u", [32_258]), 0); |
| |
| // memory_copy.wast:897 |
| assert_return(() => call($10, "load8_u", [32_457]), 0); |
| |
| // memory_copy.wast:898 |
| assert_return(() => call($10, "load8_u", [32_656]), 0); |
| |
| // memory_copy.wast:899 |
| assert_return(() => call($10, "load8_u", [32_855]), 0); |
| |
| // memory_copy.wast:900 |
| assert_return(() => call($10, "load8_u", [33_054]), 0); |
| |
| // memory_copy.wast:901 |
| assert_return(() => call($10, "load8_u", [33_253]), 0); |
| |
| // memory_copy.wast:902 |
| assert_return(() => call($10, "load8_u", [33_452]), 0); |
| |
| // memory_copy.wast:903 |
| assert_return(() => call($10, "load8_u", [33_651]), 0); |
| |
| // memory_copy.wast:904 |
| assert_return(() => call($10, "load8_u", [33_850]), 0); |
| |
| // memory_copy.wast:905 |
| assert_return(() => call($10, "load8_u", [34_049]), 0); |
| |
| // memory_copy.wast:906 |
| assert_return(() => call($10, "load8_u", [34_248]), 0); |
| |
| // memory_copy.wast:907 |
| assert_return(() => call($10, "load8_u", [34_447]), 0); |
| |
| // memory_copy.wast:908 |
| assert_return(() => call($10, "load8_u", [34_646]), 0); |
| |
| // memory_copy.wast:909 |
| assert_return(() => call($10, "load8_u", [34_845]), 0); |
| |
| // memory_copy.wast:910 |
| assert_return(() => call($10, "load8_u", [35_044]), 0); |
| |
| // memory_copy.wast:911 |
| assert_return(() => call($10, "load8_u", [35_243]), 0); |
| |
| // memory_copy.wast:912 |
| assert_return(() => call($10, "load8_u", [35_442]), 0); |
| |
| // memory_copy.wast:913 |
| assert_return(() => call($10, "load8_u", [35_641]), 0); |
| |
| // memory_copy.wast:914 |
| assert_return(() => call($10, "load8_u", [35_840]), 0); |
| |
| // memory_copy.wast:915 |
| assert_return(() => call($10, "load8_u", [36_039]), 0); |
| |
| // memory_copy.wast:916 |
| assert_return(() => call($10, "load8_u", [36_238]), 0); |
| |
| // memory_copy.wast:917 |
| assert_return(() => call($10, "load8_u", [36_437]), 0); |
| |
| // memory_copy.wast:918 |
| assert_return(() => call($10, "load8_u", [36_636]), 0); |
| |
| // memory_copy.wast:919 |
| assert_return(() => call($10, "load8_u", [36_835]), 0); |
| |
| // memory_copy.wast:920 |
| assert_return(() => call($10, "load8_u", [37_034]), 0); |
| |
| // memory_copy.wast:921 |
| assert_return(() => call($10, "load8_u", [37_233]), 0); |
| |
| // memory_copy.wast:922 |
| assert_return(() => call($10, "load8_u", [37_432]), 0); |
| |
| // memory_copy.wast:923 |
| assert_return(() => call($10, "load8_u", [37_631]), 0); |
| |
| // memory_copy.wast:924 |
| assert_return(() => call($10, "load8_u", [37_830]), 0); |
| |
| // memory_copy.wast:925 |
| assert_return(() => call($10, "load8_u", [38_029]), 0); |
| |
| // memory_copy.wast:926 |
| assert_return(() => call($10, "load8_u", [38_228]), 0); |
| |
| // memory_copy.wast:927 |
| assert_return(() => call($10, "load8_u", [38_427]), 0); |
| |
| // memory_copy.wast:928 |
| assert_return(() => call($10, "load8_u", [38_626]), 0); |
| |
| // memory_copy.wast:929 |
| assert_return(() => call($10, "load8_u", [38_825]), 0); |
| |
| // memory_copy.wast:930 |
| assert_return(() => call($10, "load8_u", [39_024]), 0); |
| |
| // memory_copy.wast:931 |
| assert_return(() => call($10, "load8_u", [39_223]), 0); |
| |
| // memory_copy.wast:932 |
| assert_return(() => call($10, "load8_u", [39_422]), 0); |
| |
| // memory_copy.wast:933 |
| assert_return(() => call($10, "load8_u", [39_621]), 0); |
| |
| // memory_copy.wast:934 |
| assert_return(() => call($10, "load8_u", [39_820]), 0); |
| |
| // memory_copy.wast:935 |
| assert_return(() => call($10, "load8_u", [40_019]), 0); |
| |
| // memory_copy.wast:936 |
| assert_return(() => call($10, "load8_u", [40_218]), 0); |
| |
| // memory_copy.wast:937 |
| assert_return(() => call($10, "load8_u", [40_417]), 0); |
| |
| // memory_copy.wast:938 |
| assert_return(() => call($10, "load8_u", [40_616]), 0); |
| |
| // memory_copy.wast:939 |
| assert_return(() => call($10, "load8_u", [40_815]), 0); |
| |
| // memory_copy.wast:940 |
| assert_return(() => call($10, "load8_u", [41_014]), 0); |
| |
| // memory_copy.wast:941 |
| assert_return(() => call($10, "load8_u", [41_213]), 0); |
| |
| // memory_copy.wast:942 |
| assert_return(() => call($10, "load8_u", [41_412]), 0); |
| |
| // memory_copy.wast:943 |
| assert_return(() => call($10, "load8_u", [41_611]), 0); |
| |
| // memory_copy.wast:944 |
| assert_return(() => call($10, "load8_u", [41_810]), 0); |
| |
| // memory_copy.wast:945 |
| assert_return(() => call($10, "load8_u", [42_009]), 0); |
| |
| // memory_copy.wast:946 |
| assert_return(() => call($10, "load8_u", [42_208]), 0); |
| |
| // memory_copy.wast:947 |
| assert_return(() => call($10, "load8_u", [42_407]), 0); |
| |
| // memory_copy.wast:948 |
| assert_return(() => call($10, "load8_u", [42_606]), 0); |
| |
| // memory_copy.wast:949 |
| assert_return(() => call($10, "load8_u", [42_805]), 0); |
| |
| // memory_copy.wast:950 |
| assert_return(() => call($10, "load8_u", [43_004]), 0); |
| |
| // memory_copy.wast:951 |
| assert_return(() => call($10, "load8_u", [43_203]), 0); |
| |
| // memory_copy.wast:952 |
| assert_return(() => call($10, "load8_u", [43_402]), 0); |
| |
| // memory_copy.wast:953 |
| assert_return(() => call($10, "load8_u", [43_601]), 0); |
| |
| // memory_copy.wast:954 |
| assert_return(() => call($10, "load8_u", [43_800]), 0); |
| |
| // memory_copy.wast:955 |
| assert_return(() => call($10, "load8_u", [43_999]), 0); |
| |
| // memory_copy.wast:956 |
| assert_return(() => call($10, "load8_u", [44_198]), 0); |
| |
| // memory_copy.wast:957 |
| assert_return(() => call($10, "load8_u", [44_397]), 0); |
| |
| // memory_copy.wast:958 |
| assert_return(() => call($10, "load8_u", [44_596]), 0); |
| |
| // memory_copy.wast:959 |
| assert_return(() => call($10, "load8_u", [44_795]), 0); |
| |
| // memory_copy.wast:960 |
| assert_return(() => call($10, "load8_u", [44_994]), 0); |
| |
| // memory_copy.wast:961 |
| assert_return(() => call($10, "load8_u", [45_193]), 0); |
| |
| // memory_copy.wast:962 |
| assert_return(() => call($10, "load8_u", [45_392]), 0); |
| |
| // memory_copy.wast:963 |
| assert_return(() => call($10, "load8_u", [45_591]), 0); |
| |
| // memory_copy.wast:964 |
| assert_return(() => call($10, "load8_u", [45_790]), 0); |
| |
| // memory_copy.wast:965 |
| assert_return(() => call($10, "load8_u", [45_989]), 0); |
| |
| // memory_copy.wast:966 |
| assert_return(() => call($10, "load8_u", [46_188]), 0); |
| |
| // memory_copy.wast:967 |
| assert_return(() => call($10, "load8_u", [46_387]), 0); |
| |
| // memory_copy.wast:968 |
| assert_return(() => call($10, "load8_u", [46_586]), 0); |
| |
| // memory_copy.wast:969 |
| assert_return(() => call($10, "load8_u", [46_785]), 0); |
| |
| // memory_copy.wast:970 |
| assert_return(() => call($10, "load8_u", [46_984]), 0); |
| |
| // memory_copy.wast:971 |
| assert_return(() => call($10, "load8_u", [47_183]), 0); |
| |
| // memory_copy.wast:972 |
| assert_return(() => call($10, "load8_u", [47_382]), 0); |
| |
| // memory_copy.wast:973 |
| assert_return(() => call($10, "load8_u", [47_581]), 0); |
| |
| // memory_copy.wast:974 |
| assert_return(() => call($10, "load8_u", [47_780]), 0); |
| |
| // memory_copy.wast:975 |
| assert_return(() => call($10, "load8_u", [47_979]), 0); |
| |
| // memory_copy.wast:976 |
| assert_return(() => call($10, "load8_u", [48_178]), 0); |
| |
| // memory_copy.wast:977 |
| assert_return(() => call($10, "load8_u", [48_377]), 0); |
| |
| // memory_copy.wast:978 |
| assert_return(() => call($10, "load8_u", [48_576]), 0); |
| |
| // memory_copy.wast:979 |
| assert_return(() => call($10, "load8_u", [48_775]), 0); |
| |
| // memory_copy.wast:980 |
| assert_return(() => call($10, "load8_u", [48_974]), 0); |
| |
| // memory_copy.wast:981 |
| assert_return(() => call($10, "load8_u", [49_173]), 0); |
| |
| // memory_copy.wast:982 |
| assert_return(() => call($10, "load8_u", [49_372]), 0); |
| |
| // memory_copy.wast:983 |
| assert_return(() => call($10, "load8_u", [49_571]), 0); |
| |
| // memory_copy.wast:984 |
| assert_return(() => call($10, "load8_u", [49_770]), 0); |
| |
| // memory_copy.wast:985 |
| assert_return(() => call($10, "load8_u", [49_969]), 0); |
| |
| // memory_copy.wast:986 |
| assert_return(() => call($10, "load8_u", [50_168]), 0); |
| |
| // memory_copy.wast:987 |
| assert_return(() => call($10, "load8_u", [50_367]), 0); |
| |
| // memory_copy.wast:988 |
| assert_return(() => call($10, "load8_u", [50_566]), 0); |
| |
| // memory_copy.wast:989 |
| assert_return(() => call($10, "load8_u", [50_765]), 0); |
| |
| // memory_copy.wast:990 |
| assert_return(() => call($10, "load8_u", [50_964]), 0); |
| |
| // memory_copy.wast:991 |
| assert_return(() => call($10, "load8_u", [51_163]), 0); |
| |
| // memory_copy.wast:992 |
| assert_return(() => call($10, "load8_u", [51_362]), 0); |
| |
| // memory_copy.wast:993 |
| assert_return(() => call($10, "load8_u", [51_561]), 0); |
| |
| // memory_copy.wast:994 |
| assert_return(() => call($10, "load8_u", [51_760]), 0); |
| |
| // memory_copy.wast:995 |
| assert_return(() => call($10, "load8_u", [51_959]), 0); |
| |
| // memory_copy.wast:996 |
| assert_return(() => call($10, "load8_u", [52_158]), 0); |
| |
| // memory_copy.wast:997 |
| assert_return(() => call($10, "load8_u", [52_357]), 0); |
| |
| // memory_copy.wast:998 |
| assert_return(() => call($10, "load8_u", [52_556]), 0); |
| |
| // memory_copy.wast:999 |
| assert_return(() => call($10, "load8_u", [52_755]), 0); |
| |
| // memory_copy.wast:1000 |
| assert_return(() => call($10, "load8_u", [52_954]), 0); |
| |
| // memory_copy.wast:1001 |
| assert_return(() => call($10, "load8_u", [53_153]), 0); |
| |
| // memory_copy.wast:1002 |
| assert_return(() => call($10, "load8_u", [53_352]), 0); |
| |
| // memory_copy.wast:1003 |
| assert_return(() => call($10, "load8_u", [53_551]), 0); |
| |
| // memory_copy.wast:1004 |
| assert_return(() => call($10, "load8_u", [53_750]), 0); |
| |
| // memory_copy.wast:1005 |
| assert_return(() => call($10, "load8_u", [53_949]), 0); |
| |
| // memory_copy.wast:1006 |
| assert_return(() => call($10, "load8_u", [54_148]), 0); |
| |
| // memory_copy.wast:1007 |
| assert_return(() => call($10, "load8_u", [54_347]), 0); |
| |
| // memory_copy.wast:1008 |
| assert_return(() => call($10, "load8_u", [54_546]), 0); |
| |
| // memory_copy.wast:1009 |
| assert_return(() => call($10, "load8_u", [54_745]), 0); |
| |
| // memory_copy.wast:1010 |
| assert_return(() => call($10, "load8_u", [54_944]), 0); |
| |
| // memory_copy.wast:1011 |
| assert_return(() => call($10, "load8_u", [55_143]), 0); |
| |
| // memory_copy.wast:1012 |
| assert_return(() => call($10, "load8_u", [55_342]), 0); |
| |
| // memory_copy.wast:1013 |
| assert_return(() => call($10, "load8_u", [55_541]), 0); |
| |
| // memory_copy.wast:1014 |
| assert_return(() => call($10, "load8_u", [55_740]), 0); |
| |
| // memory_copy.wast:1015 |
| assert_return(() => call($10, "load8_u", [55_939]), 0); |
| |
| // memory_copy.wast:1016 |
| assert_return(() => call($10, "load8_u", [56_138]), 0); |
| |
| // memory_copy.wast:1017 |
| assert_return(() => call($10, "load8_u", [56_337]), 0); |
| |
| // memory_copy.wast:1018 |
| assert_return(() => call($10, "load8_u", [56_536]), 0); |
| |
| // memory_copy.wast:1019 |
| assert_return(() => call($10, "load8_u", [56_735]), 0); |
| |
| // memory_copy.wast:1020 |
| assert_return(() => call($10, "load8_u", [56_934]), 0); |
| |
| // memory_copy.wast:1021 |
| assert_return(() => call($10, "load8_u", [57_133]), 0); |
| |
| // memory_copy.wast:1022 |
| assert_return(() => call($10, "load8_u", [57_332]), 0); |
| |
| // memory_copy.wast:1023 |
| assert_return(() => call($10, "load8_u", [57_531]), 0); |
| |
| // memory_copy.wast:1024 |
| assert_return(() => call($10, "load8_u", [57_730]), 0); |
| |
| // memory_copy.wast:1025 |
| assert_return(() => call($10, "load8_u", [57_929]), 0); |
| |
| // memory_copy.wast:1026 |
| assert_return(() => call($10, "load8_u", [58_128]), 0); |
| |
| // memory_copy.wast:1027 |
| assert_return(() => call($10, "load8_u", [58_327]), 0); |
| |
| // memory_copy.wast:1028 |
| assert_return(() => call($10, "load8_u", [58_526]), 0); |
| |
| // memory_copy.wast:1029 |
| assert_return(() => call($10, "load8_u", [58_725]), 0); |
| |
| // memory_copy.wast:1030 |
| assert_return(() => call($10, "load8_u", [58_924]), 0); |
| |
| // memory_copy.wast:1031 |
| assert_return(() => call($10, "load8_u", [59_123]), 0); |
| |
| // memory_copy.wast:1032 |
| assert_return(() => call($10, "load8_u", [59_322]), 0); |
| |
| // memory_copy.wast:1033 |
| assert_return(() => call($10, "load8_u", [59_521]), 0); |
| |
| // memory_copy.wast:1034 |
| assert_return(() => call($10, "load8_u", [59_720]), 0); |
| |
| // memory_copy.wast:1035 |
| assert_return(() => call($10, "load8_u", [59_919]), 0); |
| |
| // memory_copy.wast:1036 |
| assert_return(() => call($10, "load8_u", [60_118]), 0); |
| |
| // memory_copy.wast:1037 |
| assert_return(() => call($10, "load8_u", [60_317]), 0); |
| |
| // memory_copy.wast:1038 |
| assert_return(() => call($10, "load8_u", [60_516]), 0); |
| |
| // memory_copy.wast:1039 |
| assert_return(() => call($10, "load8_u", [60_715]), 0); |
| |
| // memory_copy.wast:1040 |
| assert_return(() => call($10, "load8_u", [60_914]), 0); |
| |
| // memory_copy.wast:1041 |
| assert_return(() => call($10, "load8_u", [61_113]), 0); |
| |
| // memory_copy.wast:1042 |
| assert_return(() => call($10, "load8_u", [61_312]), 0); |
| |
| // memory_copy.wast:1043 |
| assert_return(() => call($10, "load8_u", [61_511]), 0); |
| |
| // memory_copy.wast:1044 |
| assert_return(() => call($10, "load8_u", [61_710]), 0); |
| |
| // memory_copy.wast:1045 |
| assert_return(() => call($10, "load8_u", [61_909]), 0); |
| |
| // memory_copy.wast:1046 |
| assert_return(() => call($10, "load8_u", [62_108]), 0); |
| |
| // memory_copy.wast:1047 |
| assert_return(() => call($10, "load8_u", [62_307]), 0); |
| |
| // memory_copy.wast:1048 |
| assert_return(() => call($10, "load8_u", [62_506]), 0); |
| |
| // memory_copy.wast:1049 |
| assert_return(() => call($10, "load8_u", [62_705]), 0); |
| |
| // memory_copy.wast:1050 |
| assert_return(() => call($10, "load8_u", [62_904]), 0); |
| |
| // memory_copy.wast:1051 |
| assert_return(() => call($10, "load8_u", [63_103]), 0); |
| |
| // memory_copy.wast:1052 |
| assert_return(() => call($10, "load8_u", [63_302]), 0); |
| |
| // memory_copy.wast:1053 |
| assert_return(() => call($10, "load8_u", [63_501]), 0); |
| |
| // memory_copy.wast:1054 |
| assert_return(() => call($10, "load8_u", [63_700]), 0); |
| |
| // memory_copy.wast:1055 |
| assert_return(() => call($10, "load8_u", [63_899]), 0); |
| |
| // memory_copy.wast:1056 |
| assert_return(() => call($10, "load8_u", [64_098]), 0); |
| |
| // memory_copy.wast:1057 |
| assert_return(() => call($10, "load8_u", [64_297]), 0); |
| |
| // memory_copy.wast:1058 |
| assert_return(() => call($10, "load8_u", [64_496]), 0); |
| |
| // memory_copy.wast:1059 |
| assert_return(() => call($10, "load8_u", [64_695]), 0); |
| |
| // memory_copy.wast:1060 |
| assert_return(() => call($10, "load8_u", [64_894]), 0); |
| |
| // memory_copy.wast:1061 |
| assert_return(() => call($10, "load8_u", [65_093]), 0); |
| |
| // memory_copy.wast:1062 |
| assert_return(() => call($10, "load8_u", [65_292]), 0); |
| |
| // memory_copy.wast:1063 |
| assert_return(() => call($10, "load8_u", [65_491]), 0); |
| |
| // memory_copy.wast:1065 |
| 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:1073 |
| assert_trap(() => call($11, "run", [0, 65_516, 40])); |
| |
| // memory_copy.wast:1076 |
| assert_return(() => call($11, "load8_u", [198]), 0); |
| |
| // memory_copy.wast:1077 |
| assert_return(() => call($11, "load8_u", [397]), 0); |
| |
| // memory_copy.wast:1078 |
| assert_return(() => call($11, "load8_u", [596]), 0); |
| |
| // memory_copy.wast:1079 |
| assert_return(() => call($11, "load8_u", [795]), 0); |
| |
| // memory_copy.wast:1080 |
| assert_return(() => call($11, "load8_u", [994]), 0); |
| |
| // memory_copy.wast:1081 |
| assert_return(() => call($11, "load8_u", [1_193]), 0); |
| |
| // memory_copy.wast:1082 |
| assert_return(() => call($11, "load8_u", [1_392]), 0); |
| |
| // memory_copy.wast:1083 |
| assert_return(() => call($11, "load8_u", [1_591]), 0); |
| |
| // memory_copy.wast:1084 |
| assert_return(() => call($11, "load8_u", [1_790]), 0); |
| |
| // memory_copy.wast:1085 |
| assert_return(() => call($11, "load8_u", [1_989]), 0); |
| |
| // memory_copy.wast:1086 |
| assert_return(() => call($11, "load8_u", [2_188]), 0); |
| |
| // memory_copy.wast:1087 |
| assert_return(() => call($11, "load8_u", [2_387]), 0); |
| |
| // memory_copy.wast:1088 |
| assert_return(() => call($11, "load8_u", [2_586]), 0); |
| |
| // memory_copy.wast:1089 |
| assert_return(() => call($11, "load8_u", [2_785]), 0); |
| |
| // memory_copy.wast:1090 |
| assert_return(() => call($11, "load8_u", [2_984]), 0); |
| |
| // memory_copy.wast:1091 |
| assert_return(() => call($11, "load8_u", [3_183]), 0); |
| |
| // memory_copy.wast:1092 |
| assert_return(() => call($11, "load8_u", [3_382]), 0); |
| |
| // memory_copy.wast:1093 |
| assert_return(() => call($11, "load8_u", [3_581]), 0); |
| |
| // memory_copy.wast:1094 |
| assert_return(() => call($11, "load8_u", [3_780]), 0); |
| |
| // memory_copy.wast:1095 |
| assert_return(() => call($11, "load8_u", [3_979]), 0); |
| |
| // memory_copy.wast:1096 |
| assert_return(() => call($11, "load8_u", [4_178]), 0); |
| |
| // memory_copy.wast:1097 |
| assert_return(() => call($11, "load8_u", [4_377]), 0); |
| |
| // memory_copy.wast:1098 |
| assert_return(() => call($11, "load8_u", [4_576]), 0); |
| |
| // memory_copy.wast:1099 |
| assert_return(() => call($11, "load8_u", [4_775]), 0); |
| |
| // memory_copy.wast:1100 |
| assert_return(() => call($11, "load8_u", [4_974]), 0); |
| |
| // memory_copy.wast:1101 |
| assert_return(() => call($11, "load8_u", [5_173]), 0); |
| |
| // memory_copy.wast:1102 |
| assert_return(() => call($11, "load8_u", [5_372]), 0); |
| |
| // memory_copy.wast:1103 |
| assert_return(() => call($11, "load8_u", [5_571]), 0); |
| |
| // memory_copy.wast:1104 |
| assert_return(() => call($11, "load8_u", [5_770]), 0); |
| |
| // memory_copy.wast:1105 |
| assert_return(() => call($11, "load8_u", [5_969]), 0); |
| |
| // memory_copy.wast:1106 |
| assert_return(() => call($11, "load8_u", [6_168]), 0); |
| |
| // memory_copy.wast:1107 |
| assert_return(() => call($11, "load8_u", [6_367]), 0); |
| |
| // memory_copy.wast:1108 |
| assert_return(() => call($11, "load8_u", [6_566]), 0); |
| |
| // memory_copy.wast:1109 |
| assert_return(() => call($11, "load8_u", [6_765]), 0); |
| |
| // memory_copy.wast:1110 |
| assert_return(() => call($11, "load8_u", [6_964]), 0); |
| |
| // memory_copy.wast:1111 |
| assert_return(() => call($11, "load8_u", [7_163]), 0); |
| |
| // memory_copy.wast:1112 |
| assert_return(() => call($11, "load8_u", [7_362]), 0); |
| |
| // memory_copy.wast:1113 |
| assert_return(() => call($11, "load8_u", [7_561]), 0); |
| |
| // memory_copy.wast:1114 |
| assert_return(() => call($11, "load8_u", [7_760]), 0); |
| |
| // memory_copy.wast:1115 |
| assert_return(() => call($11, "load8_u", [7_959]), 0); |
| |
| // memory_copy.wast:1116 |
| assert_return(() => call($11, "load8_u", [8_158]), 0); |
| |
| // memory_copy.wast:1117 |
| assert_return(() => call($11, "load8_u", [8_357]), 0); |
| |
| // memory_copy.wast:1118 |
| assert_return(() => call($11, "load8_u", [8_556]), 0); |
| |
| // memory_copy.wast:1119 |
| assert_return(() => call($11, "load8_u", [8_755]), 0); |
| |
| // memory_copy.wast:1120 |
| assert_return(() => call($11, "load8_u", [8_954]), 0); |
| |
| // memory_copy.wast:1121 |
| assert_return(() => call($11, "load8_u", [9_153]), 0); |
| |
| // memory_copy.wast:1122 |
| assert_return(() => call($11, "load8_u", [9_352]), 0); |
| |
| // memory_copy.wast:1123 |
| assert_return(() => call($11, "load8_u", [9_551]), 0); |
| |
| // memory_copy.wast:1124 |
| assert_return(() => call($11, "load8_u", [9_750]), 0); |
| |
| // memory_copy.wast:1125 |
| assert_return(() => call($11, "load8_u", [9_949]), 0); |
| |
| // memory_copy.wast:1126 |
| assert_return(() => call($11, "load8_u", [10_148]), 0); |
| |
| // memory_copy.wast:1127 |
| assert_return(() => call($11, "load8_u", [10_347]), 0); |
| |
| // memory_copy.wast:1128 |
| assert_return(() => call($11, "load8_u", [10_546]), 0); |
| |
| // memory_copy.wast:1129 |
| assert_return(() => call($11, "load8_u", [10_745]), 0); |
| |
| // memory_copy.wast:1130 |
| assert_return(() => call($11, "load8_u", [10_944]), 0); |
| |
| // memory_copy.wast:1131 |
| assert_return(() => call($11, "load8_u", [11_143]), 0); |
| |
| // memory_copy.wast:1132 |
| assert_return(() => call($11, "load8_u", [11_342]), 0); |
| |
| // memory_copy.wast:1133 |
| assert_return(() => call($11, "load8_u", [11_541]), 0); |
| |
| // memory_copy.wast:1134 |
| assert_return(() => call($11, "load8_u", [11_740]), 0); |
| |
| // memory_copy.wast:1135 |
| assert_return(() => call($11, "load8_u", [11_939]), 0); |
| |
| // memory_copy.wast:1136 |
| assert_return(() => call($11, "load8_u", [12_138]), 0); |
| |
| // memory_copy.wast:1137 |
| assert_return(() => call($11, "load8_u", [12_337]), 0); |
| |
| // memory_copy.wast:1138 |
| assert_return(() => call($11, "load8_u", [12_536]), 0); |
| |
| // memory_copy.wast:1139 |
| assert_return(() => call($11, "load8_u", [12_735]), 0); |
| |
| // memory_copy.wast:1140 |
| assert_return(() => call($11, "load8_u", [12_934]), 0); |
| |
| // memory_copy.wast:1141 |
| assert_return(() => call($11, "load8_u", [13_133]), 0); |
| |
| // memory_copy.wast:1142 |
| assert_return(() => call($11, "load8_u", [13_332]), 0); |
| |
| // memory_copy.wast:1143 |
| assert_return(() => call($11, "load8_u", [13_531]), 0); |
| |
| // memory_copy.wast:1144 |
| assert_return(() => call($11, "load8_u", [13_730]), 0); |
| |
| // memory_copy.wast:1145 |
| assert_return(() => call($11, "load8_u", [13_929]), 0); |
| |
| // memory_copy.wast:1146 |
| assert_return(() => call($11, "load8_u", [14_128]), 0); |
| |
| // memory_copy.wast:1147 |
| assert_return(() => call($11, "load8_u", [14_327]), 0); |
| |
| // memory_copy.wast:1148 |
| assert_return(() => call($11, "load8_u", [14_526]), 0); |
| |
| // memory_copy.wast:1149 |
| assert_return(() => call($11, "load8_u", [14_725]), 0); |
| |
| // memory_copy.wast:1150 |
| assert_return(() => call($11, "load8_u", [14_924]), 0); |
| |
| // memory_copy.wast:1151 |
| assert_return(() => call($11, "load8_u", [15_123]), 0); |
| |
| // memory_copy.wast:1152 |
| assert_return(() => call($11, "load8_u", [15_322]), 0); |
| |
| // memory_copy.wast:1153 |
| assert_return(() => call($11, "load8_u", [15_521]), 0); |
| |
| // memory_copy.wast:1154 |
| assert_return(() => call($11, "load8_u", [15_720]), 0); |
| |
| // memory_copy.wast:1155 |
| assert_return(() => call($11, "load8_u", [15_919]), 0); |
| |
| // memory_copy.wast:1156 |
| assert_return(() => call($11, "load8_u", [16_118]), 0); |
| |
| // memory_copy.wast:1157 |
| assert_return(() => call($11, "load8_u", [16_317]), 0); |
| |
| // memory_copy.wast:1158 |
| assert_return(() => call($11, "load8_u", [16_516]), 0); |
| |
| // memory_copy.wast:1159 |
| assert_return(() => call($11, "load8_u", [16_715]), 0); |
| |
| // memory_copy.wast:1160 |
| assert_return(() => call($11, "load8_u", [16_914]), 0); |
| |
| // memory_copy.wast:1161 |
| assert_return(() => call($11, "load8_u", [17_113]), 0); |
| |
| // memory_copy.wast:1162 |
| assert_return(() => call($11, "load8_u", [17_312]), 0); |
| |
| // memory_copy.wast:1163 |
| assert_return(() => call($11, "load8_u", [17_511]), 0); |
| |
| // memory_copy.wast:1164 |
| assert_return(() => call($11, "load8_u", [17_710]), 0); |
| |
| // memory_copy.wast:1165 |
| assert_return(() => call($11, "load8_u", [17_909]), 0); |
| |
| // memory_copy.wast:1166 |
| assert_return(() => call($11, "load8_u", [18_108]), 0); |
| |
| // memory_copy.wast:1167 |
| assert_return(() => call($11, "load8_u", [18_307]), 0); |
| |
| // memory_copy.wast:1168 |
| assert_return(() => call($11, "load8_u", [18_506]), 0); |
| |
| // memory_copy.wast:1169 |
| assert_return(() => call($11, "load8_u", [18_705]), 0); |
| |
| // memory_copy.wast:1170 |
| assert_return(() => call($11, "load8_u", [18_904]), 0); |
| |
| // memory_copy.wast:1171 |
| assert_return(() => call($11, "load8_u", [19_103]), 0); |
| |
| // memory_copy.wast:1172 |
| assert_return(() => call($11, "load8_u", [19_302]), 0); |
| |
| // memory_copy.wast:1173 |
| assert_return(() => call($11, "load8_u", [19_501]), 0); |
| |
| // memory_copy.wast:1174 |
| assert_return(() => call($11, "load8_u", [19_700]), 0); |
| |
| // memory_copy.wast:1175 |
| assert_return(() => call($11, "load8_u", [19_899]), 0); |
| |
| // memory_copy.wast:1176 |
| assert_return(() => call($11, "load8_u", [20_098]), 0); |
| |
| // memory_copy.wast:1177 |
| assert_return(() => call($11, "load8_u", [20_297]), 0); |
| |
| // memory_copy.wast:1178 |
| assert_return(() => call($11, "load8_u", [20_496]), 0); |
| |
| // memory_copy.wast:1179 |
| assert_return(() => call($11, "load8_u", [20_695]), 0); |
| |
| // memory_copy.wast:1180 |
| assert_return(() => call($11, "load8_u", [20_894]), 0); |
| |
| // memory_copy.wast:1181 |
| assert_return(() => call($11, "load8_u", [21_093]), 0); |
| |
| // memory_copy.wast:1182 |
| assert_return(() => call($11, "load8_u", [21_292]), 0); |
| |
| // memory_copy.wast:1183 |
| assert_return(() => call($11, "load8_u", [21_491]), 0); |
| |
| // memory_copy.wast:1184 |
| assert_return(() => call($11, "load8_u", [21_690]), 0); |
| |
| // memory_copy.wast:1185 |
| assert_return(() => call($11, "load8_u", [21_889]), 0); |
| |
| // memory_copy.wast:1186 |
| assert_return(() => call($11, "load8_u", [22_088]), 0); |
| |
| // memory_copy.wast:1187 |
| assert_return(() => call($11, "load8_u", [22_287]), 0); |
| |
| // memory_copy.wast:1188 |
| assert_return(() => call($11, "load8_u", [22_486]), 0); |
| |
| // memory_copy.wast:1189 |
| assert_return(() => call($11, "load8_u", [22_685]), 0); |
| |
| // memory_copy.wast:1190 |
| assert_return(() => call($11, "load8_u", [22_884]), 0); |
| |
| // memory_copy.wast:1191 |
| assert_return(() => call($11, "load8_u", [23_083]), 0); |
| |
| // memory_copy.wast:1192 |
| assert_return(() => call($11, "load8_u", [23_282]), 0); |
| |
| // memory_copy.wast:1193 |
| assert_return(() => call($11, "load8_u", [23_481]), 0); |
| |
| // memory_copy.wast:1194 |
| assert_return(() => call($11, "load8_u", [23_680]), 0); |
| |
| // memory_copy.wast:1195 |
| assert_return(() => call($11, "load8_u", [23_879]), 0); |
| |
| // memory_copy.wast:1196 |
| assert_return(() => call($11, "load8_u", [24_078]), 0); |
| |
| // memory_copy.wast:1197 |
| assert_return(() => call($11, "load8_u", [24_277]), 0); |
| |
| // memory_copy.wast:1198 |
| assert_return(() => call($11, "load8_u", [24_476]), 0); |
| |
| // memory_copy.wast:1199 |
| assert_return(() => call($11, "load8_u", [24_675]), 0); |
| |
| // memory_copy.wast:1200 |
| assert_return(() => call($11, "load8_u", [24_874]), 0); |
| |
| // memory_copy.wast:1201 |
| assert_return(() => call($11, "load8_u", [25_073]), 0); |
| |
| // memory_copy.wast:1202 |
| assert_return(() => call($11, "load8_u", [25_272]), 0); |
| |
| // memory_copy.wast:1203 |
| assert_return(() => call($11, "load8_u", [25_471]), 0); |
| |
| // memory_copy.wast:1204 |
| assert_return(() => call($11, "load8_u", [25_670]), 0); |
| |
| // memory_copy.wast:1205 |
| assert_return(() => call($11, "load8_u", [25_869]), 0); |
| |
| // memory_copy.wast:1206 |
| assert_return(() => call($11, "load8_u", [26_068]), 0); |
| |
| // memory_copy.wast:1207 |
| assert_return(() => call($11, "load8_u", [26_267]), 0); |
| |
| // memory_copy.wast:1208 |
| assert_return(() => call($11, "load8_u", [26_466]), 0); |
| |
| // memory_copy.wast:1209 |
| assert_return(() => call($11, "load8_u", [26_665]), 0); |
| |
| // memory_copy.wast:1210 |
| assert_return(() => call($11, "load8_u", [26_864]), 0); |
| |
| // memory_copy.wast:1211 |
| assert_return(() => call($11, "load8_u", [27_063]), 0); |
| |
| // memory_copy.wast:1212 |
| assert_return(() => call($11, "load8_u", [27_262]), 0); |
| |
| // memory_copy.wast:1213 |
| assert_return(() => call($11, "load8_u", [27_461]), 0); |
| |
| // memory_copy.wast:1214 |
| assert_return(() => call($11, "load8_u", [27_660]), 0); |
| |
| // memory_copy.wast:1215 |
| assert_return(() => call($11, "load8_u", [27_859]), 0); |
| |
| // memory_copy.wast:1216 |
| assert_return(() => call($11, "load8_u", [28_058]), 0); |
| |
| // memory_copy.wast:1217 |
| assert_return(() => call($11, "load8_u", [28_257]), 0); |
| |
| // memory_copy.wast:1218 |
| assert_return(() => call($11, "load8_u", [28_456]), 0); |
| |
| // memory_copy.wast:1219 |
| assert_return(() => call($11, "load8_u", [28_655]), 0); |
| |
| // memory_copy.wast:1220 |
| assert_return(() => call($11, "load8_u", [28_854]), 0); |
| |
| // memory_copy.wast:1221 |
| assert_return(() => call($11, "load8_u", [29_053]), 0); |
| |
| // memory_copy.wast:1222 |
| assert_return(() => call($11, "load8_u", [29_252]), 0); |
| |
| // memory_copy.wast:1223 |
| assert_return(() => call($11, "load8_u", [29_451]), 0); |
| |
| // memory_copy.wast:1224 |
| assert_return(() => call($11, "load8_u", [29_650]), 0); |
| |
| // memory_copy.wast:1225 |
| assert_return(() => call($11, "load8_u", [29_849]), 0); |
| |
| // memory_copy.wast:1226 |
| assert_return(() => call($11, "load8_u", [30_048]), 0); |
| |
| // memory_copy.wast:1227 |
| assert_return(() => call($11, "load8_u", [30_247]), 0); |
| |
| // memory_copy.wast:1228 |
| assert_return(() => call($11, "load8_u", [30_446]), 0); |
| |
| // memory_copy.wast:1229 |
| assert_return(() => call($11, "load8_u", [30_645]), 0); |
| |
| // memory_copy.wast:1230 |
| assert_return(() => call($11, "load8_u", [30_844]), 0); |
| |
| // memory_copy.wast:1231 |
| assert_return(() => call($11, "load8_u", [31_043]), 0); |
| |
| // memory_copy.wast:1232 |
| assert_return(() => call($11, "load8_u", [31_242]), 0); |
| |
| // memory_copy.wast:1233 |
| assert_return(() => call($11, "load8_u", [31_441]), 0); |
| |
| // memory_copy.wast:1234 |
| assert_return(() => call($11, "load8_u", [31_640]), 0); |
| |
| // memory_copy.wast:1235 |
| assert_return(() => call($11, "load8_u", [31_839]), 0); |
| |
| // memory_copy.wast:1236 |
| assert_return(() => call($11, "load8_u", [32_038]), 0); |
| |
| // memory_copy.wast:1237 |
| assert_return(() => call($11, "load8_u", [32_237]), 0); |
| |
| // memory_copy.wast:1238 |
| assert_return(() => call($11, "load8_u", [32_436]), 0); |
| |
| // memory_copy.wast:1239 |
| assert_return(() => call($11, "load8_u", [32_635]), 0); |
| |
| // memory_copy.wast:1240 |
| assert_return(() => call($11, "load8_u", [32_834]), 0); |
| |
| // memory_copy.wast:1241 |
| assert_return(() => call($11, "load8_u", [33_033]), 0); |
| |
| // memory_copy.wast:1242 |
| assert_return(() => call($11, "load8_u", [33_232]), 0); |
| |
| // memory_copy.wast:1243 |
| assert_return(() => call($11, "load8_u", [33_431]), 0); |
| |
| // memory_copy.wast:1244 |
| assert_return(() => call($11, "load8_u", [33_630]), 0); |
| |
| // memory_copy.wast:1245 |
| assert_return(() => call($11, "load8_u", [33_829]), 0); |
| |
| // memory_copy.wast:1246 |
| assert_return(() => call($11, "load8_u", [34_028]), 0); |
| |
| // memory_copy.wast:1247 |
| assert_return(() => call($11, "load8_u", [34_227]), 0); |
| |
| // memory_copy.wast:1248 |
| assert_return(() => call($11, "load8_u", [34_426]), 0); |
| |
| // memory_copy.wast:1249 |
| assert_return(() => call($11, "load8_u", [34_625]), 0); |
| |
| // memory_copy.wast:1250 |
| assert_return(() => call($11, "load8_u", [34_824]), 0); |
| |
| // memory_copy.wast:1251 |
| assert_return(() => call($11, "load8_u", [35_023]), 0); |
| |
| // memory_copy.wast:1252 |
| assert_return(() => call($11, "load8_u", [35_222]), 0); |
| |
| // memory_copy.wast:1253 |
| assert_return(() => call($11, "load8_u", [35_421]), 0); |
| |
| // memory_copy.wast:1254 |
| assert_return(() => call($11, "load8_u", [35_620]), 0); |
| |
| // memory_copy.wast:1255 |
| assert_return(() => call($11, "load8_u", [35_819]), 0); |
| |
| // memory_copy.wast:1256 |
| assert_return(() => call($11, "load8_u", [36_018]), 0); |
| |
| // memory_copy.wast:1257 |
| assert_return(() => call($11, "load8_u", [36_217]), 0); |
| |
| // memory_copy.wast:1258 |
| assert_return(() => call($11, "load8_u", [36_416]), 0); |
| |
| // memory_copy.wast:1259 |
| assert_return(() => call($11, "load8_u", [36_615]), 0); |
| |
| // memory_copy.wast:1260 |
| assert_return(() => call($11, "load8_u", [36_814]), 0); |
| |
| // memory_copy.wast:1261 |
| assert_return(() => call($11, "load8_u", [37_013]), 0); |
| |
| // memory_copy.wast:1262 |
| assert_return(() => call($11, "load8_u", [37_212]), 0); |
| |
| // memory_copy.wast:1263 |
| assert_return(() => call($11, "load8_u", [37_411]), 0); |
| |
| // memory_copy.wast:1264 |
| assert_return(() => call($11, "load8_u", [37_610]), 0); |
| |
| // memory_copy.wast:1265 |
| assert_return(() => call($11, "load8_u", [37_809]), 0); |
| |
| // memory_copy.wast:1266 |
| assert_return(() => call($11, "load8_u", [38_008]), 0); |
| |
| // memory_copy.wast:1267 |
| assert_return(() => call($11, "load8_u", [38_207]), 0); |
| |
| // memory_copy.wast:1268 |
| assert_return(() => call($11, "load8_u", [38_406]), 0); |
| |
| // memory_copy.wast:1269 |
| assert_return(() => call($11, "load8_u", [38_605]), 0); |
| |
| // memory_copy.wast:1270 |
| assert_return(() => call($11, "load8_u", [38_804]), 0); |
| |
| // memory_copy.wast:1271 |
| assert_return(() => call($11, "load8_u", [39_003]), 0); |
| |
| // memory_copy.wast:1272 |
| assert_return(() => call($11, "load8_u", [39_202]), 0); |
| |
| // memory_copy.wast:1273 |
| assert_return(() => call($11, "load8_u", [39_401]), 0); |
| |
| // memory_copy.wast:1274 |
| assert_return(() => call($11, "load8_u", [39_600]), 0); |
| |
| // memory_copy.wast:1275 |
| assert_return(() => call($11, "load8_u", [39_799]), 0); |
| |
| // memory_copy.wast:1276 |
| assert_return(() => call($11, "load8_u", [39_998]), 0); |
| |
| // memory_copy.wast:1277 |
| assert_return(() => call($11, "load8_u", [40_197]), 0); |
| |
| // memory_copy.wast:1278 |
| assert_return(() => call($11, "load8_u", [40_396]), 0); |
| |
| // memory_copy.wast:1279 |
| assert_return(() => call($11, "load8_u", [40_595]), 0); |
| |
| // memory_copy.wast:1280 |
| assert_return(() => call($11, "load8_u", [40_794]), 0); |
| |
| // memory_copy.wast:1281 |
| assert_return(() => call($11, "load8_u", [40_993]), 0); |
| |
| // memory_copy.wast:1282 |
| assert_return(() => call($11, "load8_u", [41_192]), 0); |
| |
| // memory_copy.wast:1283 |
| assert_return(() => call($11, "load8_u", [41_391]), 0); |
| |
| // memory_copy.wast:1284 |
| assert_return(() => call($11, "load8_u", [41_590]), 0); |
| |
| // memory_copy.wast:1285 |
| assert_return(() => call($11, "load8_u", [41_789]), 0); |
| |
| // memory_copy.wast:1286 |
| assert_return(() => call($11, "load8_u", [41_988]), 0); |
| |
| // memory_copy.wast:1287 |
| assert_return(() => call($11, "load8_u", [42_187]), 0); |
| |
| // memory_copy.wast:1288 |
| assert_return(() => call($11, "load8_u", [42_386]), 0); |
| |
| // memory_copy.wast:1289 |
| assert_return(() => call($11, "load8_u", [42_585]), 0); |
| |
| // memory_copy.wast:1290 |
| assert_return(() => call($11, "load8_u", [42_784]), 0); |
| |
| // memory_copy.wast:1291 |
| assert_return(() => call($11, "load8_u", [42_983]), 0); |
| |
| // memory_copy.wast:1292 |
| assert_return(() => call($11, "load8_u", [43_182]), 0); |
| |
| // memory_copy.wast:1293 |
| assert_return(() => call($11, "load8_u", [43_381]), 0); |
| |
| // memory_copy.wast:1294 |
| assert_return(() => call($11, "load8_u", [43_580]), 0); |
| |
| // memory_copy.wast:1295 |
| assert_return(() => call($11, "load8_u", [43_779]), 0); |
| |
| // memory_copy.wast:1296 |
| assert_return(() => call($11, "load8_u", [43_978]), 0); |
| |
| // memory_copy.wast:1297 |
| assert_return(() => call($11, "load8_u", [44_177]), 0); |
| |
| // memory_copy.wast:1298 |
| assert_return(() => call($11, "load8_u", [44_376]), 0); |
| |
| // memory_copy.wast:1299 |
| assert_return(() => call($11, "load8_u", [44_575]), 0); |
| |
| // memory_copy.wast:1300 |
| assert_return(() => call($11, "load8_u", [44_774]), 0); |
| |
| // memory_copy.wast:1301 |
| assert_return(() => call($11, "load8_u", [44_973]), 0); |
| |
| // memory_copy.wast:1302 |
| assert_return(() => call($11, "load8_u", [45_172]), 0); |
| |
| // memory_copy.wast:1303 |
| assert_return(() => call($11, "load8_u", [45_371]), 0); |
| |
| // memory_copy.wast:1304 |
| assert_return(() => call($11, "load8_u", [45_570]), 0); |
| |
| // memory_copy.wast:1305 |
| assert_return(() => call($11, "load8_u", [45_769]), 0); |
| |
| // memory_copy.wast:1306 |
| assert_return(() => call($11, "load8_u", [45_968]), 0); |
| |
| // memory_copy.wast:1307 |
| assert_return(() => call($11, "load8_u", [46_167]), 0); |
| |
| // memory_copy.wast:1308 |
| assert_return(() => call($11, "load8_u", [46_366]), 0); |
| |
| // memory_copy.wast:1309 |
| assert_return(() => call($11, "load8_u", [46_565]), 0); |
| |
| // memory_copy.wast:1310 |
| assert_return(() => call($11, "load8_u", [46_764]), 0); |
| |
| // memory_copy.wast:1311 |
| assert_return(() => call($11, "load8_u", [46_963]), 0); |
| |
| // memory_copy.wast:1312 |
| assert_return(() => call($11, "load8_u", [47_162]), 0); |
| |
| // memory_copy.wast:1313 |
| assert_return(() => call($11, "load8_u", [47_361]), 0); |
| |
| // memory_copy.wast:1314 |
| assert_return(() => call($11, "load8_u", [47_560]), 0); |
| |
| // memory_copy.wast:1315 |
| assert_return(() => call($11, "load8_u", [47_759]), 0); |
| |
| // memory_copy.wast:1316 |
| assert_return(() => call($11, "load8_u", [47_958]), 0); |
| |
| // memory_copy.wast:1317 |
| assert_return(() => call($11, "load8_u", [48_157]), 0); |
| |
| // memory_copy.wast:1318 |
| assert_return(() => call($11, "load8_u", [48_356]), 0); |
| |
| // memory_copy.wast:1319 |
| assert_return(() => call($11, "load8_u", [48_555]), 0); |
| |
| // memory_copy.wast:1320 |
| assert_return(() => call($11, "load8_u", [48_754]), 0); |
| |
| // memory_copy.wast:1321 |
| assert_return(() => call($11, "load8_u", [48_953]), 0); |
| |
| // memory_copy.wast:1322 |
| assert_return(() => call($11, "load8_u", [49_152]), 0); |
| |
| // memory_copy.wast:1323 |
| assert_return(() => call($11, "load8_u", [49_351]), 0); |
| |
| // memory_copy.wast:1324 |
| assert_return(() => call($11, "load8_u", [49_550]), 0); |
| |
| // memory_copy.wast:1325 |
| assert_return(() => call($11, "load8_u", [49_749]), 0); |
| |
| // memory_copy.wast:1326 |
| assert_return(() => call($11, "load8_u", [49_948]), 0); |
| |
| // memory_copy.wast:1327 |
| assert_return(() => call($11, "load8_u", [50_147]), 0); |
| |
| // memory_copy.wast:1328 |
| assert_return(() => call($11, "load8_u", [50_346]), 0); |
| |
| // memory_copy.wast:1329 |
| assert_return(() => call($11, "load8_u", [50_545]), 0); |
| |
| // memory_copy.wast:1330 |
| assert_return(() => call($11, "load8_u", [50_744]), 0); |
| |
| // memory_copy.wast:1331 |
| assert_return(() => call($11, "load8_u", [50_943]), 0); |
| |
| // memory_copy.wast:1332 |
| assert_return(() => call($11, "load8_u", [51_142]), 0); |
| |
| // memory_copy.wast:1333 |
| assert_return(() => call($11, "load8_u", [51_341]), 0); |
| |
| // memory_copy.wast:1334 |
| assert_return(() => call($11, "load8_u", [51_540]), 0); |
| |
| // memory_copy.wast:1335 |
| assert_return(() => call($11, "load8_u", [51_739]), 0); |
| |
| // memory_copy.wast:1336 |
| assert_return(() => call($11, "load8_u", [51_938]), 0); |
| |
| // memory_copy.wast:1337 |
| assert_return(() => call($11, "load8_u", [52_137]), 0); |
| |
| // memory_copy.wast:1338 |
| assert_return(() => call($11, "load8_u", [52_336]), 0); |
| |
| // memory_copy.wast:1339 |
| assert_return(() => call($11, "load8_u", [52_535]), 0); |
| |
| // memory_copy.wast:1340 |
| assert_return(() => call($11, "load8_u", [52_734]), 0); |
| |
| // memory_copy.wast:1341 |
| assert_return(() => call($11, "load8_u", [52_933]), 0); |
| |
| // memory_copy.wast:1342 |
| assert_return(() => call($11, "load8_u", [53_132]), 0); |
| |
| // memory_copy.wast:1343 |
| assert_return(() => call($11, "load8_u", [53_331]), 0); |
| |
| // memory_copy.wast:1344 |
| assert_return(() => call($11, "load8_u", [53_530]), 0); |
| |
| // memory_copy.wast:1345 |
| assert_return(() => call($11, "load8_u", [53_729]), 0); |
| |
| // memory_copy.wast:1346 |
| assert_return(() => call($11, "load8_u", [53_928]), 0); |
| |
| // memory_copy.wast:1347 |
| assert_return(() => call($11, "load8_u", [54_127]), 0); |
| |
| // memory_copy.wast:1348 |
| assert_return(() => call($11, "load8_u", [54_326]), 0); |
| |
| // memory_copy.wast:1349 |
| assert_return(() => call($11, "load8_u", [54_525]), 0); |
| |
| // memory_copy.wast:1350 |
| assert_return(() => call($11, "load8_u", [54_724]), 0); |
| |
| // memory_copy.wast:1351 |
| assert_return(() => call($11, "load8_u", [54_923]), 0); |
| |
| // memory_copy.wast:1352 |
| assert_return(() => call($11, "load8_u", [55_122]), 0); |
| |
| // memory_copy.wast:1353 |
| assert_return(() => call($11, "load8_u", [55_321]), 0); |
| |
| // memory_copy.wast:1354 |
| assert_return(() => call($11, "load8_u", [55_520]), 0); |
| |
| // memory_copy.wast:1355 |
| assert_return(() => call($11, "load8_u", [55_719]), 0); |
| |
| // memory_copy.wast:1356 |
| assert_return(() => call($11, "load8_u", [55_918]), 0); |
| |
| // memory_copy.wast:1357 |
| assert_return(() => call($11, "load8_u", [56_117]), 0); |
| |
| // memory_copy.wast:1358 |
| assert_return(() => call($11, "load8_u", [56_316]), 0); |
| |
| // memory_copy.wast:1359 |
| assert_return(() => call($11, "load8_u", [56_515]), 0); |
| |
| // memory_copy.wast:1360 |
| assert_return(() => call($11, "load8_u", [56_714]), 0); |
| |
| // memory_copy.wast:1361 |
| assert_return(() => call($11, "load8_u", [56_913]), 0); |
| |
| // memory_copy.wast:1362 |
| assert_return(() => call($11, "load8_u", [57_112]), 0); |
| |
| // memory_copy.wast:1363 |
| assert_return(() => call($11, "load8_u", [57_311]), 0); |
| |
| // memory_copy.wast:1364 |
| assert_return(() => call($11, "load8_u", [57_510]), 0); |
| |
| // memory_copy.wast:1365 |
| assert_return(() => call($11, "load8_u", [57_709]), 0); |
| |
| // memory_copy.wast:1366 |
| assert_return(() => call($11, "load8_u", [57_908]), 0); |
| |
| // memory_copy.wast:1367 |
| assert_return(() => call($11, "load8_u", [58_107]), 0); |
| |
| // memory_copy.wast:1368 |
| assert_return(() => call($11, "load8_u", [58_306]), 0); |
| |
| // memory_copy.wast:1369 |
| assert_return(() => call($11, "load8_u", [58_505]), 0); |
| |
| // memory_copy.wast:1370 |
| assert_return(() => call($11, "load8_u", [58_704]), 0); |
| |
| // memory_copy.wast:1371 |
| assert_return(() => call($11, "load8_u", [58_903]), 0); |
| |
| // memory_copy.wast:1372 |
| assert_return(() => call($11, "load8_u", [59_102]), 0); |
| |
| // memory_copy.wast:1373 |
| assert_return(() => call($11, "load8_u", [59_301]), 0); |
| |
| // memory_copy.wast:1374 |
| assert_return(() => call($11, "load8_u", [59_500]), 0); |
| |
| // memory_copy.wast:1375 |
| assert_return(() => call($11, "load8_u", [59_699]), 0); |
| |
| // memory_copy.wast:1376 |
| assert_return(() => call($11, "load8_u", [59_898]), 0); |
| |
| // memory_copy.wast:1377 |
| assert_return(() => call($11, "load8_u", [60_097]), 0); |
| |
| // memory_copy.wast:1378 |
| assert_return(() => call($11, "load8_u", [60_296]), 0); |
| |
| // memory_copy.wast:1379 |
| assert_return(() => call($11, "load8_u", [60_495]), 0); |
| |
| // memory_copy.wast:1380 |
| assert_return(() => call($11, "load8_u", [60_694]), 0); |
| |
| // memory_copy.wast:1381 |
| assert_return(() => call($11, "load8_u", [60_893]), 0); |
| |
| // memory_copy.wast:1382 |
| assert_return(() => call($11, "load8_u", [61_092]), 0); |
| |
| // memory_copy.wast:1383 |
| assert_return(() => call($11, "load8_u", [61_291]), 0); |
| |
| // memory_copy.wast:1384 |
| assert_return(() => call($11, "load8_u", [61_490]), 0); |
| |
| // memory_copy.wast:1385 |
| assert_return(() => call($11, "load8_u", [61_689]), 0); |
| |
| // memory_copy.wast:1386 |
| assert_return(() => call($11, "load8_u", [61_888]), 0); |
| |
| // memory_copy.wast:1387 |
| assert_return(() => call($11, "load8_u", [62_087]), 0); |
| |
| // memory_copy.wast:1388 |
| assert_return(() => call($11, "load8_u", [62_286]), 0); |
| |
| // memory_copy.wast:1389 |
| assert_return(() => call($11, "load8_u", [62_485]), 0); |
| |
| // memory_copy.wast:1390 |
| assert_return(() => call($11, "load8_u", [62_684]), 0); |
| |
| // memory_copy.wast:1391 |
| assert_return(() => call($11, "load8_u", [62_883]), 0); |
| |
| // memory_copy.wast:1392 |
| assert_return(() => call($11, "load8_u", [63_082]), 0); |
| |
| // memory_copy.wast:1393 |
| assert_return(() => call($11, "load8_u", [63_281]), 0); |
| |
| // memory_copy.wast:1394 |
| assert_return(() => call($11, "load8_u", [63_480]), 0); |
| |
| // memory_copy.wast:1395 |
| assert_return(() => call($11, "load8_u", [63_679]), 0); |
| |
| // memory_copy.wast:1396 |
| assert_return(() => call($11, "load8_u", [63_878]), 0); |
| |
| // memory_copy.wast:1397 |
| assert_return(() => call($11, "load8_u", [64_077]), 0); |
| |
| // memory_copy.wast:1398 |
| assert_return(() => call($11, "load8_u", [64_276]), 0); |
| |
| // memory_copy.wast:1399 |
| assert_return(() => call($11, "load8_u", [64_475]), 0); |
| |
| // memory_copy.wast:1400 |
| assert_return(() => call($11, "load8_u", [64_674]), 0); |
| |
| // memory_copy.wast:1401 |
| assert_return(() => call($11, "load8_u", [64_873]), 0); |
| |
| // memory_copy.wast:1402 |
| assert_return(() => call($11, "load8_u", [65_072]), 0); |
| |
| // memory_copy.wast:1403 |
| assert_return(() => call($11, "load8_u", [65_271]), 0); |
| |
| // memory_copy.wast:1404 |
| assert_return(() => call($11, "load8_u", [65_470]), 0); |
| |
| // memory_copy.wast:1405 |
| assert_return(() => call($11, "load8_u", [65_516]), 0); |
| |
| // memory_copy.wast:1406 |
| assert_return(() => call($11, "load8_u", [65_517]), 1); |
| |
| // memory_copy.wast:1407 |
| assert_return(() => call($11, "load8_u", [65_518]), 2); |
| |
| // memory_copy.wast:1408 |
| assert_return(() => call($11, "load8_u", [65_519]), 3); |
| |
| // memory_copy.wast:1409 |
| assert_return(() => call($11, "load8_u", [65_520]), 4); |
| |
| // memory_copy.wast:1410 |
| assert_return(() => call($11, "load8_u", [65_521]), 5); |
| |
| // memory_copy.wast:1411 |
| assert_return(() => call($11, "load8_u", [65_522]), 6); |
| |
| // memory_copy.wast:1412 |
| assert_return(() => call($11, "load8_u", [65_523]), 7); |
| |
| // memory_copy.wast:1413 |
| assert_return(() => call($11, "load8_u", [65_524]), 8); |
| |
| // memory_copy.wast:1414 |
| assert_return(() => call($11, "load8_u", [65_525]), 9); |
| |
| // memory_copy.wast:1415 |
| assert_return(() => call($11, "load8_u", [65_526]), 10); |
| |
| // memory_copy.wast:1416 |
| assert_return(() => call($11, "load8_u", [65_527]), 11); |
| |
| // memory_copy.wast:1417 |
| assert_return(() => call($11, "load8_u", [65_528]), 12); |
| |
| // memory_copy.wast:1418 |
| assert_return(() => call($11, "load8_u", [65_529]), 13); |
| |
| // memory_copy.wast:1419 |
| assert_return(() => call($11, "load8_u", [65_530]), 14); |
| |
| // memory_copy.wast:1420 |
| assert_return(() => call($11, "load8_u", [65_531]), 15); |
| |
| // memory_copy.wast:1421 |
| assert_return(() => call($11, "load8_u", [65_532]), 16); |
| |
| // memory_copy.wast:1422 |
| assert_return(() => call($11, "load8_u", [65_533]), 17); |
| |
| // memory_copy.wast:1423 |
| assert_return(() => call($11, "load8_u", [65_534]), 18); |
| |
| // memory_copy.wast:1424 |
| assert_return(() => call($11, "load8_u", [65_535]), 19); |
| |
| // memory_copy.wast:1426 |
| 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:1434 |
| assert_trap(() => call($12, "run", [0, 65_515, 39])); |
| |
| // memory_copy.wast:1437 |
| assert_return(() => call($12, "load8_u", [198]), 0); |
| |
| // memory_copy.wast:1438 |
| assert_return(() => call($12, "load8_u", [397]), 0); |
| |
| // memory_copy.wast:1439 |
| assert_return(() => call($12, "load8_u", [596]), 0); |
| |
| // memory_copy.wast:1440 |
| assert_return(() => call($12, "load8_u", [795]), 0); |
| |
| // memory_copy.wast:1441 |
| assert_return(() => call($12, "load8_u", [994]), 0); |
| |
| // memory_copy.wast:1442 |
| assert_return(() => call($12, "load8_u", [1_193]), 0); |
| |
| // memory_copy.wast:1443 |
| assert_return(() => call($12, "load8_u", [1_392]), 0); |
| |
| // memory_copy.wast:1444 |
| assert_return(() => call($12, "load8_u", [1_591]), 0); |
| |
| // memory_copy.wast:1445 |
| assert_return(() => call($12, "load8_u", [1_790]), 0); |
| |
| // memory_copy.wast:1446 |
| assert_return(() => call($12, "load8_u", [1_989]), 0); |
| |
| // memory_copy.wast:1447 |
| assert_return(() => call($12, "load8_u", [2_188]), 0); |
| |
| // memory_copy.wast:1448 |
| assert_return(() => call($12, "load8_u", [2_387]), 0); |
| |
| // memory_copy.wast:1449 |
| assert_return(() => call($12, "load8_u", [2_586]), 0); |
| |
| // memory_copy.wast:1450 |
| assert_return(() => call($12, "load8_u", [2_785]), 0); |
| |
| // memory_copy.wast:1451 |
| assert_return(() => call($12, "load8_u", [2_984]), 0); |
| |
| // memory_copy.wast:1452 |
| assert_return(() => call($12, "load8_u", [3_183]), 0); |
| |
| // memory_copy.wast:1453 |
| assert_return(() => call($12, "load8_u", [3_382]), 0); |
| |
| // memory_copy.wast:1454 |
| assert_return(() => call($12, "load8_u", [3_581]), 0); |
| |
| // memory_copy.wast:1455 |
| assert_return(() => call($12, "load8_u", [3_780]), 0); |
| |
| // memory_copy.wast:1456 |
| assert_return(() => call($12, "load8_u", [3_979]), 0); |
| |
| // memory_copy.wast:1457 |
| assert_return(() => call($12, "load8_u", [4_178]), 0); |
| |
| // memory_copy.wast:1458 |
| assert_return(() => call($12, "load8_u", [4_377]), 0); |
| |
| // memory_copy.wast:1459 |
| assert_return(() => call($12, "load8_u", [4_576]), 0); |
| |
| // memory_copy.wast:1460 |
| assert_return(() => call($12, "load8_u", [4_775]), 0); |
| |
| // memory_copy.wast:1461 |
| assert_return(() => call($12, "load8_u", [4_974]), 0); |
| |
| // memory_copy.wast:1462 |
| assert_return(() => call($12, "load8_u", [5_173]), 0); |
| |
| // memory_copy.wast:1463 |
| assert_return(() => call($12, "load8_u", [5_372]), 0); |
| |
| // memory_copy.wast:1464 |
| assert_return(() => call($12, "load8_u", [5_571]), 0); |
| |
| // memory_copy.wast:1465 |
| assert_return(() => call($12, "load8_u", [5_770]), 0); |
| |
| // memory_copy.wast:1466 |
| assert_return(() => call($12, "load8_u", [5_969]), 0); |
| |
| // memory_copy.wast:1467 |
| assert_return(() => call($12, "load8_u", [6_168]), 0); |
| |
| // memory_copy.wast:1468 |
| assert_return(() => call($12, "load8_u", [6_367]), 0); |
| |
| // memory_copy.wast:1469 |
| assert_return(() => call($12, "load8_u", [6_566]), 0); |
| |
| // memory_copy.wast:1470 |
| assert_return(() => call($12, "load8_u", [6_765]), 0); |
| |
| // memory_copy.wast:1471 |
| assert_return(() => call($12, "load8_u", [6_964]), 0); |
| |
| // memory_copy.wast:1472 |
| assert_return(() => call($12, "load8_u", [7_163]), 0); |
| |
| // memory_copy.wast:1473 |
| assert_return(() => call($12, "load8_u", [7_362]), 0); |
| |
| // memory_copy.wast:1474 |
| assert_return(() => call($12, "load8_u", [7_561]), 0); |
| |
| // memory_copy.wast:1475 |
| assert_return(() => call($12, "load8_u", [7_760]), 0); |
| |
| // memory_copy.wast:1476 |
| assert_return(() => call($12, "load8_u", [7_959]), 0); |
| |
| // memory_copy.wast:1477 |
| assert_return(() => call($12, "load8_u", [8_158]), 0); |
| |
| // memory_copy.wast:1478 |
| assert_return(() => call($12, "load8_u", [8_357]), 0); |
| |
| // memory_copy.wast:1479 |
| assert_return(() => call($12, "load8_u", [8_556]), 0); |
| |
| // memory_copy.wast:1480 |
| assert_return(() => call($12, "load8_u", [8_755]), 0); |
| |
| // memory_copy.wast:1481 |
| assert_return(() => call($12, "load8_u", [8_954]), 0); |
| |
| // memory_copy.wast:1482 |
| assert_return(() => call($12, "load8_u", [9_153]), 0); |
| |
| // memory_copy.wast:1483 |
| assert_return(() => call($12, "load8_u", [9_352]), 0); |
| |
| // memory_copy.wast:1484 |
| assert_return(() => call($12, "load8_u", [9_551]), 0); |
| |
| // memory_copy.wast:1485 |
| assert_return(() => call($12, "load8_u", [9_750]), 0); |
| |
| // memory_copy.wast:1486 |
| assert_return(() => call($12, "load8_u", [9_949]), 0); |
| |
| // memory_copy.wast:1487 |
| assert_return(() => call($12, "load8_u", [10_148]), 0); |
| |
| // memory_copy.wast:1488 |
| assert_return(() => call($12, "load8_u", [10_347]), 0); |
| |
| // memory_copy.wast:1489 |
| assert_return(() => call($12, "load8_u", [10_546]), 0); |
| |
| // memory_copy.wast:1490 |
| assert_return(() => call($12, "load8_u", [10_745]), 0); |
| |
| // memory_copy.wast:1491 |
| assert_return(() => call($12, "load8_u", [10_944]), 0); |
| |
| // memory_copy.wast:1492 |
| assert_return(() => call($12, "load8_u", [11_143]), 0); |
| |
| // memory_copy.wast:1493 |
| assert_return(() => call($12, "load8_u", [11_342]), 0); |
| |
| // memory_copy.wast:1494 |
| assert_return(() => call($12, "load8_u", [11_541]), 0); |
| |
| // memory_copy.wast:1495 |
| assert_return(() => call($12, "load8_u", [11_740]), 0); |
| |
| // memory_copy.wast:1496 |
| assert_return(() => call($12, "load8_u", [11_939]), 0); |
| |
| // memory_copy.wast:1497 |
| assert_return(() => call($12, "load8_u", [12_138]), 0); |
| |
| // memory_copy.wast:1498 |
| assert_return(() => call($12, "load8_u", [12_337]), 0); |
| |
| // memory_copy.wast:1499 |
| assert_return(() => call($12, "load8_u", [12_536]), 0); |
| |
| // memory_copy.wast:1500 |
| assert_return(() => call($12, "load8_u", [12_735]), 0); |
| |
| // memory_copy.wast:1501 |
| assert_return(() => call($12, "load8_u", [12_934]), 0); |
| |
| // memory_copy.wast:1502 |
| assert_return(() => call($12, "load8_u", [13_133]), 0); |
| |
| // memory_copy.wast:1503 |
| assert_return(() => call($12, "load8_u", [13_332]), 0); |
| |
| // memory_copy.wast:1504 |
| assert_return(() => call($12, "load8_u", [13_531]), 0); |
| |
| // memory_copy.wast:1505 |
| assert_return(() => call($12, "load8_u", [13_730]), 0); |
| |
| // memory_copy.wast:1506 |
| assert_return(() => call($12, "load8_u", [13_929]), 0); |
| |
| // memory_copy.wast:1507 |
| assert_return(() => call($12, "load8_u", [14_128]), 0); |
| |
| // memory_copy.wast:1508 |
| assert_return(() => call($12, "load8_u", [14_327]), 0); |
| |
| // memory_copy.wast:1509 |
| assert_return(() => call($12, "load8_u", [14_526]), 0); |
| |
| // memory_copy.wast:1510 |
| assert_return(() => call($12, "load8_u", [14_725]), 0); |
| |
| // memory_copy.wast:1511 |
| assert_return(() => call($12, "load8_u", [14_924]), 0); |
| |
| // memory_copy.wast:1512 |
| assert_return(() => call($12, "load8_u", [15_123]), 0); |
| |
| // memory_copy.wast:1513 |
| assert_return(() => call($12, "load8_u", [15_322]), 0); |
| |
| // memory_copy.wast:1514 |
| assert_return(() => call($12, "load8_u", [15_521]), 0); |
| |
| // memory_copy.wast:1515 |
| assert_return(() => call($12, "load8_u", [15_720]), 0); |
| |
| // memory_copy.wast:1516 |
| assert_return(() => call($12, "load8_u", [15_919]), 0); |
| |
| // memory_copy.wast:1517 |
| assert_return(() => call($12, "load8_u", [16_118]), 0); |
| |
| // memory_copy.wast:1518 |
| assert_return(() => call($12, "load8_u", [16_317]), 0); |
| |
| // memory_copy.wast:1519 |
| assert_return(() => call($12, "load8_u", [16_516]), 0); |
| |
| // memory_copy.wast:1520 |
| assert_return(() => call($12, "load8_u", [16_715]), 0); |
| |
| // memory_copy.wast:1521 |
| assert_return(() => call($12, "load8_u", [16_914]), 0); |
| |
| // memory_copy.wast:1522 |
| assert_return(() => call($12, "load8_u", [17_113]), 0); |
| |
| // memory_copy.wast:1523 |
| assert_return(() => call($12, "load8_u", [17_312]), 0); |
| |
| // memory_copy.wast:1524 |
| assert_return(() => call($12, "load8_u", [17_511]), 0); |
| |
| // memory_copy.wast:1525 |
| assert_return(() => call($12, "load8_u", [17_710]), 0); |
| |
| // memory_copy.wast:1526 |
| assert_return(() => call($12, "load8_u", [17_909]), 0); |
| |
| // memory_copy.wast:1527 |
| assert_return(() => call($12, "load8_u", [18_108]), 0); |
| |
| // memory_copy.wast:1528 |
| assert_return(() => call($12, "load8_u", [18_307]), 0); |
| |
| // memory_copy.wast:1529 |
| assert_return(() => call($12, "load8_u", [18_506]), 0); |
| |
| // memory_copy.wast:1530 |
| assert_return(() => call($12, "load8_u", [18_705]), 0); |
| |
| // memory_copy.wast:1531 |
| assert_return(() => call($12, "load8_u", [18_904]), 0); |
| |
| // memory_copy.wast:1532 |
| assert_return(() => call($12, "load8_u", [19_103]), 0); |
| |
| // memory_copy.wast:1533 |
| assert_return(() => call($12, "load8_u", [19_302]), 0); |
| |
| // memory_copy.wast:1534 |
| assert_return(() => call($12, "load8_u", [19_501]), 0); |
| |
| // memory_copy.wast:1535 |
| assert_return(() => call($12, "load8_u", [19_700]), 0); |
| |
| // memory_copy.wast:1536 |
| assert_return(() => call($12, "load8_u", [19_899]), 0); |
| |
| // memory_copy.wast:1537 |
| assert_return(() => call($12, "load8_u", [20_098]), 0); |
| |
| // memory_copy.wast:1538 |
| assert_return(() => call($12, "load8_u", [20_297]), 0); |
| |
| // memory_copy.wast:1539 |
| assert_return(() => call($12, "load8_u", [20_496]), 0); |
| |
| // memory_copy.wast:1540 |
| assert_return(() => call($12, "load8_u", [20_695]), 0); |
| |
| // memory_copy.wast:1541 |
| assert_return(() => call($12, "load8_u", [20_894]), 0); |
| |
| // memory_copy.wast:1542 |
| assert_return(() => call($12, "load8_u", [21_093]), 0); |
| |
| // memory_copy.wast:1543 |
| assert_return(() => call($12, "load8_u", [21_292]), 0); |
| |
| // memory_copy.wast:1544 |
| assert_return(() => call($12, "load8_u", [21_491]), 0); |
| |
| // memory_copy.wast:1545 |
| assert_return(() => call($12, "load8_u", [21_690]), 0); |
| |
| // memory_copy.wast:1546 |
| assert_return(() => call($12, "load8_u", [21_889]), 0); |
| |
| // memory_copy.wast:1547 |
| assert_return(() => call($12, "load8_u", [22_088]), 0); |
| |
| // memory_copy.wast:1548 |
| assert_return(() => call($12, "load8_u", [22_287]), 0); |
| |
| // memory_copy.wast:1549 |
| assert_return(() => call($12, "load8_u", [22_486]), 0); |
| |
| // memory_copy.wast:1550 |
| assert_return(() => call($12, "load8_u", [22_685]), 0); |
| |
| // memory_copy.wast:1551 |
| assert_return(() => call($12, "load8_u", [22_884]), 0); |
| |
| // memory_copy.wast:1552 |
| assert_return(() => call($12, "load8_u", [23_083]), 0); |
| |
| // memory_copy.wast:1553 |
| assert_return(() => call($12, "load8_u", [23_282]), 0); |
| |
| // memory_copy.wast:1554 |
| assert_return(() => call($12, "load8_u", [23_481]), 0); |
| |
| // memory_copy.wast:1555 |
| assert_return(() => call($12, "load8_u", [23_680]), 0); |
| |
| // memory_copy.wast:1556 |
| assert_return(() => call($12, "load8_u", [23_879]), 0); |
| |
| // memory_copy.wast:1557 |
| assert_return(() => call($12, "load8_u", [24_078]), 0); |
| |
| // memory_copy.wast:1558 |
| assert_return(() => call($12, "load8_u", [24_277]), 0); |
| |
| // memory_copy.wast:1559 |
| assert_return(() => call($12, "load8_u", [24_476]), 0); |
| |
| // memory_copy.wast:1560 |
| assert_return(() => call($12, "load8_u", [24_675]), 0); |
| |
| // memory_copy.wast:1561 |
| assert_return(() => call($12, "load8_u", [24_874]), 0); |
| |
| // memory_copy.wast:1562 |
| assert_return(() => call($12, "load8_u", [25_073]), 0); |
| |
| // memory_copy.wast:1563 |
| assert_return(() => call($12, "load8_u", [25_272]), 0); |
| |
| // memory_copy.wast:1564 |
| assert_return(() => call($12, "load8_u", [25_471]), 0); |
| |
| // memory_copy.wast:1565 |
| assert_return(() => call($12, "load8_u", [25_670]), 0); |
| |
| // memory_copy.wast:1566 |
| assert_return(() => call($12, "load8_u", [25_869]), 0); |
| |
| // memory_copy.wast:1567 |
| assert_return(() => call($12, "load8_u", [26_068]), 0); |
| |
| // memory_copy.wast:1568 |
| assert_return(() => call($12, "load8_u", [26_267]), 0); |
| |
| // memory_copy.wast:1569 |
| assert_return(() => call($12, "load8_u", [26_466]), 0); |
| |
| // memory_copy.wast:1570 |
| assert_return(() => call($12, "load8_u", [26_665]), 0); |
| |
| // memory_copy.wast:1571 |
| assert_return(() => call($12, "load8_u", [26_864]), 0); |
| |
| // memory_copy.wast:1572 |
| assert_return(() => call($12, "load8_u", [27_063]), 0); |
| |
| // memory_copy.wast:1573 |
| assert_return(() => call($12, "load8_u", [27_262]), 0); |
| |
| // memory_copy.wast:1574 |
| assert_return(() => call($12, "load8_u", [27_461]), 0); |
| |
| // memory_copy.wast:1575 |
| assert_return(() => call($12, "load8_u", [27_660]), 0); |
| |
| // memory_copy.wast:1576 |
| assert_return(() => call($12, "load8_u", [27_859]), 0); |
| |
| // memory_copy.wast:1577 |
| assert_return(() => call($12, "load8_u", [28_058]), 0); |
| |
| // memory_copy.wast:1578 |
| assert_return(() => call($12, "load8_u", [28_257]), 0); |
| |
| // memory_copy.wast:1579 |
| assert_return(() => call($12, "load8_u", [28_456]), 0); |
| |
| // memory_copy.wast:1580 |
| assert_return(() => call($12, "load8_u", [28_655]), 0); |
| |
| // memory_copy.wast:1581 |
| assert_return(() => call($12, "load8_u", [28_854]), 0); |
| |
| // memory_copy.wast:1582 |
| assert_return(() => call($12, "load8_u", [29_053]), 0); |
| |
| // memory_copy.wast:1583 |
| assert_return(() => call($12, "load8_u", [29_252]), 0); |
| |
| // memory_copy.wast:1584 |
| assert_return(() => call($12, "load8_u", [29_451]), 0); |
| |
| // memory_copy.wast:1585 |
| assert_return(() => call($12, "load8_u", [29_650]), 0); |
| |
| // memory_copy.wast:1586 |
| assert_return(() => call($12, "load8_u", [29_849]), 0); |
| |
| // memory_copy.wast:1587 |
| assert_return(() => call($12, "load8_u", [30_048]), 0); |
| |
| // memory_copy.wast:1588 |
| assert_return(() => call($12, "load8_u", [30_247]), 0); |
| |
| // memory_copy.wast:1589 |
| assert_return(() => call($12, "load8_u", [30_446]), 0); |
| |
| // memory_copy.wast:1590 |
| assert_return(() => call($12, "load8_u", [30_645]), 0); |
| |
| // memory_copy.wast:1591 |
| assert_return(() => call($12, "load8_u", [30_844]), 0); |
| |
| // memory_copy.wast:1592 |
| assert_return(() => call($12, "load8_u", [31_043]), 0); |
| |
| // memory_copy.wast:1593 |
| assert_return(() => call($12, "load8_u", [31_242]), 0); |
| |
| // memory_copy.wast:1594 |
| assert_return(() => call($12, "load8_u", [31_441]), 0); |
| |
| // memory_copy.wast:1595 |
| assert_return(() => call($12, "load8_u", [31_640]), 0); |
| |
| // memory_copy.wast:1596 |
| assert_return(() => call($12, "load8_u", [31_839]), 0); |
| |
| // memory_copy.wast:1597 |
| assert_return(() => call($12, "load8_u", [32_038]), 0); |
| |
| // memory_copy.wast:1598 |
| assert_return(() => call($12, "load8_u", [32_237]), 0); |
| |
| // memory_copy.wast:1599 |
| assert_return(() => call($12, "load8_u", [32_436]), 0); |
| |
| // memory_copy.wast:1600 |
| assert_return(() => call($12, "load8_u", [32_635]), 0); |
| |
| // memory_copy.wast:1601 |
| assert_return(() => call($12, "load8_u", [32_834]), 0); |
| |
| // memory_copy.wast:1602 |
| assert_return(() => call($12, "load8_u", [33_033]), 0); |
| |
| // memory_copy.wast:1603 |
| assert_return(() => call($12, "load8_u", [33_232]), 0); |
| |
| // memory_copy.wast:1604 |
| assert_return(() => call($12, "load8_u", [33_431]), 0); |
| |
| // memory_copy.wast:1605 |
| assert_return(() => call($12, "load8_u", [33_630]), 0); |
| |
| // memory_copy.wast:1606 |
| assert_return(() => call($12, "load8_u", [33_829]), 0); |
| |
| // memory_copy.wast:1607 |
| assert_return(() => call($12, "load8_u", [34_028]), 0); |
| |
| // memory_copy.wast:1608 |
| assert_return(() => call($12, "load8_u", [34_227]), 0); |
| |
| // memory_copy.wast:1609 |
| assert_return(() => call($12, "load8_u", [34_426]), 0); |
| |
| // memory_copy.wast:1610 |
| assert_return(() => call($12, "load8_u", [34_625]), 0); |
| |
| // memory_copy.wast:1611 |
| assert_return(() => call($12, "load8_u", [34_824]), 0); |
| |
| // memory_copy.wast:1612 |
| assert_return(() => call($12, "load8_u", [35_023]), 0); |
| |
| // memory_copy.wast:1613 |
| assert_return(() => call($12, "load8_u", [35_222]), 0); |
| |
| // memory_copy.wast:1614 |
| assert_return(() => call($12, "load8_u", [35_421]), 0); |
| |
| // memory_copy.wast:1615 |
| assert_return(() => call($12, "load8_u", [35_620]), 0); |
| |
| // memory_copy.wast:1616 |
| assert_return(() => call($12, "load8_u", [35_819]), 0); |
| |
| // memory_copy.wast:1617 |
| assert_return(() => call($12, "load8_u", [36_018]), 0); |
| |
| // memory_copy.wast:1618 |
| assert_return(() => call($12, "load8_u", [36_217]), 0); |
| |
| // memory_copy.wast:1619 |
| assert_return(() => call($12, "load8_u", [36_416]), 0); |
| |
| // memory_copy.wast:1620 |
| assert_return(() => call($12, "load8_u", [36_615]), 0); |
| |
| // memory_copy.wast:1621 |
| assert_return(() => call($12, "load8_u", [36_814]), 0); |
| |
| // memory_copy.wast:1622 |
| assert_return(() => call($12, "load8_u", [37_013]), 0); |
| |
| // memory_copy.wast:1623 |
| assert_return(() => call($12, "load8_u", [37_212]), 0); |
| |
| // memory_copy.wast:1624 |
| assert_return(() => call($12, "load8_u", [37_411]), 0); |
| |
| // memory_copy.wast:1625 |
| assert_return(() => call($12, "load8_u", [37_610]), 0); |
| |
| // memory_copy.wast:1626 |
| assert_return(() => call($12, "load8_u", [37_809]), 0); |
| |
| // memory_copy.wast:1627 |
| assert_return(() => call($12, "load8_u", [38_008]), 0); |
| |
| // memory_copy.wast:1628 |
| assert_return(() => call($12, "load8_u", [38_207]), 0); |
| |
| // memory_copy.wast:1629 |
| assert_return(() => call($12, "load8_u", [38_406]), 0); |
| |
| // memory_copy.wast:1630 |
| assert_return(() => call($12, "load8_u", [38_605]), 0); |
| |
| // memory_copy.wast:1631 |
| assert_return(() => call($12, "load8_u", [38_804]), 0); |
| |
| // memory_copy.wast:1632 |
| assert_return(() => call($12, "load8_u", [39_003]), 0); |
| |
| // memory_copy.wast:1633 |
| assert_return(() => call($12, "load8_u", [39_202]), 0); |
| |
| // memory_copy.wast:1634 |
| assert_return(() => call($12, "load8_u", [39_401]), 0); |
| |
| // memory_copy.wast:1635 |
| assert_return(() => call($12, "load8_u", [39_600]), 0); |
| |
| // memory_copy.wast:1636 |
| assert_return(() => call($12, "load8_u", [39_799]), 0); |
| |
| // memory_copy.wast:1637 |
| assert_return(() => call($12, "load8_u", [39_998]), 0); |
| |
| // memory_copy.wast:1638 |
| assert_return(() => call($12, "load8_u", [40_197]), 0); |
| |
| // memory_copy.wast:1639 |
| assert_return(() => call($12, "load8_u", [40_396]), 0); |
| |
| // memory_copy.wast:1640 |
| assert_return(() => call($12, "load8_u", [40_595]), 0); |
| |
| // memory_copy.wast:1641 |
| assert_return(() => call($12, "load8_u", [40_794]), 0); |
| |
| // memory_copy.wast:1642 |
| assert_return(() => call($12, "load8_u", [40_993]), 0); |
| |
| // memory_copy.wast:1643 |
| assert_return(() => call($12, "load8_u", [41_192]), 0); |
| |
| // memory_copy.wast:1644 |
| assert_return(() => call($12, "load8_u", [41_391]), 0); |
| |
| // memory_copy.wast:1645 |
| assert_return(() => call($12, "load8_u", [41_590]), 0); |
| |
| // memory_copy.wast:1646 |
| assert_return(() => call($12, "load8_u", [41_789]), 0); |
| |
| // memory_copy.wast:1647 |
| assert_return(() => call($12, "load8_u", [41_988]), 0); |
| |
| // memory_copy.wast:1648 |
| assert_return(() => call($12, "load8_u", [42_187]), 0); |
| |
| // memory_copy.wast:1649 |
| assert_return(() => call($12, "load8_u", [42_386]), 0); |
| |
| // memory_copy.wast:1650 |
| assert_return(() => call($12, "load8_u", [42_585]), 0); |
| |
| // memory_copy.wast:1651 |
| assert_return(() => call($12, "load8_u", [42_784]), 0); |
| |
| // memory_copy.wast:1652 |
| assert_return(() => call($12, "load8_u", [42_983]), 0); |
| |
| // memory_copy.wast:1653 |
| assert_return(() => call($12, "load8_u", [43_182]), 0); |
| |
| // memory_copy.wast:1654 |
| assert_return(() => call($12, "load8_u", [43_381]), 0); |
| |
| // memory_copy.wast:1655 |
| assert_return(() => call($12, "load8_u", [43_580]), 0); |
| |
| // memory_copy.wast:1656 |
| assert_return(() => call($12, "load8_u", [43_779]), 0); |
| |
| // memory_copy.wast:1657 |
| assert_return(() => call($12, "load8_u", [43_978]), 0); |
| |
| // memory_copy.wast:1658 |
| assert_return(() => call($12, "load8_u", [44_177]), 0); |
| |
| // memory_copy.wast:1659 |
| assert_return(() => call($12, "load8_u", [44_376]), 0); |
| |
| // memory_copy.wast:1660 |
| assert_return(() => call($12, "load8_u", [44_575]), 0); |
| |
| // memory_copy.wast:1661 |
| assert_return(() => call($12, "load8_u", [44_774]), 0); |
| |
| // memory_copy.wast:1662 |
| assert_return(() => call($12, "load8_u", [44_973]), 0); |
| |
| // memory_copy.wast:1663 |
| assert_return(() => call($12, "load8_u", [45_172]), 0); |
| |
| // memory_copy.wast:1664 |
| assert_return(() => call($12, "load8_u", [45_371]), 0); |
| |
| // memory_copy.wast:1665 |
| assert_return(() => call($12, "load8_u", [45_570]), 0); |
| |
| // memory_copy.wast:1666 |
| assert_return(() => call($12, "load8_u", [45_769]), 0); |
| |
| // memory_copy.wast:1667 |
| assert_return(() => call($12, "load8_u", [45_968]), 0); |
| |
| // memory_copy.wast:1668 |
| assert_return(() => call($12, "load8_u", [46_167]), 0); |
| |
| // memory_copy.wast:1669 |
| assert_return(() => call($12, "load8_u", [46_366]), 0); |
| |
| // memory_copy.wast:1670 |
| assert_return(() => call($12, "load8_u", [46_565]), 0); |
| |
| // memory_copy.wast:1671 |
| assert_return(() => call($12, "load8_u", [46_764]), 0); |
| |
| // memory_copy.wast:1672 |
| assert_return(() => call($12, "load8_u", [46_963]), 0); |
| |
| // memory_copy.wast:1673 |
| assert_return(() => call($12, "load8_u", [47_162]), 0); |
| |
| // memory_copy.wast:1674 |
| assert_return(() => call($12, "load8_u", [47_361]), 0); |
| |
| // memory_copy.wast:1675 |
| assert_return(() => call($12, "load8_u", [47_560]), 0); |
| |
| // memory_copy.wast:1676 |
| assert_return(() => call($12, "load8_u", [47_759]), 0); |
| |
| // memory_copy.wast:1677 |
| assert_return(() => call($12, "load8_u", [47_958]), 0); |
| |
| // memory_copy.wast:1678 |
| assert_return(() => call($12, "load8_u", [48_157]), 0); |
| |
| // memory_copy.wast:1679 |
| assert_return(() => call($12, "load8_u", [48_356]), 0); |
| |
| // memory_copy.wast:1680 |
| assert_return(() => call($12, "load8_u", [48_555]), 0); |
| |
| // memory_copy.wast:1681 |
| assert_return(() => call($12, "load8_u", [48_754]), 0); |
| |
| // memory_copy.wast:1682 |
| assert_return(() => call($12, "load8_u", [48_953]), 0); |
| |
| // memory_copy.wast:1683 |
| assert_return(() => call($12, "load8_u", [49_152]), 0); |
| |
| // memory_copy.wast:1684 |
| assert_return(() => call($12, "load8_u", [49_351]), 0); |
| |
| // memory_copy.wast:1685 |
| assert_return(() => call($12, "load8_u", [49_550]), 0); |
| |
| // memory_copy.wast:1686 |
| assert_return(() => call($12, "load8_u", [49_749]), 0); |
| |
| // memory_copy.wast:1687 |
| assert_return(() => call($12, "load8_u", [49_948]), 0); |
| |
| // memory_copy.wast:1688 |
| assert_return(() => call($12, "load8_u", [50_147]), 0); |
| |
| // memory_copy.wast:1689 |
| assert_return(() => call($12, "load8_u", [50_346]), 0); |
| |
| // memory_copy.wast:1690 |
| assert_return(() => call($12, "load8_u", [50_545]), 0); |
| |
| // memory_copy.wast:1691 |
| assert_return(() => call($12, "load8_u", [50_744]), 0); |
| |
| // memory_copy.wast:1692 |
| assert_return(() => call($12, "load8_u", [50_943]), 0); |
| |
| // memory_copy.wast:1693 |
| assert_return(() => call($12, "load8_u", [51_142]), 0); |
| |
| // memory_copy.wast:1694 |
| assert_return(() => call($12, "load8_u", [51_341]), 0); |
| |
| // memory_copy.wast:1695 |
| assert_return(() => call($12, "load8_u", [51_540]), 0); |
| |
| // memory_copy.wast:1696 |
| assert_return(() => call($12, "load8_u", [51_739]), 0); |
| |
| // memory_copy.wast:1697 |
| assert_return(() => call($12, "load8_u", [51_938]), 0); |
| |
| // memory_copy.wast:1698 |
| assert_return(() => call($12, "load8_u", [52_137]), 0); |
| |
| // memory_copy.wast:1699 |
| assert_return(() => call($12, "load8_u", [52_336]), 0); |
| |
| // memory_copy.wast:1700 |
| assert_return(() => call($12, "load8_u", [52_535]), 0); |
| |
| // memory_copy.wast:1701 |
| assert_return(() => call($12, "load8_u", [52_734]), 0); |
| |
| // memory_copy.wast:1702 |
| assert_return(() => call($12, "load8_u", [52_933]), 0); |
| |
| // memory_copy.wast:1703 |
| assert_return(() => call($12, "load8_u", [53_132]), 0); |
| |
| // memory_copy.wast:1704 |
| assert_return(() => call($12, "load8_u", [53_331]), 0); |
| |
| // memory_copy.wast:1705 |
| assert_return(() => call($12, "load8_u", [53_530]), 0); |
| |
| // memory_copy.wast:1706 |
| assert_return(() => call($12, "load8_u", [53_729]), 0); |
| |
| // memory_copy.wast:1707 |
| assert_return(() => call($12, "load8_u", [53_928]), 0); |
| |
| // memory_copy.wast:1708 |
| assert_return(() => call($12, "load8_u", [54_127]), 0); |
| |
| // memory_copy.wast:1709 |
| assert_return(() => call($12, "load8_u", [54_326]), 0); |
| |
| // memory_copy.wast:1710 |
| assert_return(() => call($12, "load8_u", [54_525]), 0); |
| |
| // memory_copy.wast:1711 |
| assert_return(() => call($12, "load8_u", [54_724]), 0); |
| |
| // memory_copy.wast:1712 |
| assert_return(() => call($12, "load8_u", [54_923]), 0); |
| |
| // memory_copy.wast:1713 |
| assert_return(() => call($12, "load8_u", [55_122]), 0); |
| |
| // memory_copy.wast:1714 |
| assert_return(() => call($12, "load8_u", [55_321]), 0); |
| |
| // memory_copy.wast:1715 |
| assert_return(() => call($12, "load8_u", [55_520]), 0); |
| |
| // memory_copy.wast:1716 |
| assert_return(() => call($12, "load8_u", [55_719]), 0); |
| |
| // memory_copy.wast:1717 |
| assert_return(() => call($12, "load8_u", [55_918]), 0); |
| |
| // memory_copy.wast:1718 |
| assert_return(() => call($12, "load8_u", [56_117]), 0); |
| |
| // memory_copy.wast:1719 |
| assert_return(() => call($12, "load8_u", [56_316]), 0); |
| |
| // memory_copy.wast:1720 |
| assert_return(() => call($12, "load8_u", [56_515]), 0); |
| |
| // memory_copy.wast:1721 |
| assert_return(() => call($12, "load8_u", [56_714]), 0); |
| |
| // memory_copy.wast:1722 |
| assert_return(() => call($12, "load8_u", [56_913]), 0); |
| |
| // memory_copy.wast:1723 |
| assert_return(() => call($12, "load8_u", [57_112]), 0); |
| |
| // memory_copy.wast:1724 |
| assert_return(() => call($12, "load8_u", [57_311]), 0); |
| |
| // memory_copy.wast:1725 |
| assert_return(() => call($12, "load8_u", [57_510]), 0); |
| |
| // memory_copy.wast:1726 |
| assert_return(() => call($12, "load8_u", [57_709]), 0); |
| |
| // memory_copy.wast:1727 |
| assert_return(() => call($12, "load8_u", [57_908]), 0); |
| |
| // memory_copy.wast:1728 |
| assert_return(() => call($12, "load8_u", [58_107]), 0); |
| |
| // memory_copy.wast:1729 |
| assert_return(() => call($12, "load8_u", [58_306]), 0); |
| |
| // memory_copy.wast:1730 |
| assert_return(() => call($12, "load8_u", [58_505]), 0); |
| |
| // memory_copy.wast:1731 |
| assert_return(() => call($12, "load8_u", [58_704]), 0); |
| |
| // memory_copy.wast:1732 |
| assert_return(() => call($12, "load8_u", [58_903]), 0); |
| |
| // memory_copy.wast:1733 |
| assert_return(() => call($12, "load8_u", [59_102]), 0); |
| |
| // memory_copy.wast:1734 |
| assert_return(() => call($12, "load8_u", [59_301]), 0); |
| |
| // memory_copy.wast:1735 |
| assert_return(() => call($12, "load8_u", [59_500]), 0); |
| |
| // memory_copy.wast:1736 |
| assert_return(() => call($12, "load8_u", [59_699]), 0); |
| |
| // memory_copy.wast:1737 |
| assert_return(() => call($12, "load8_u", [59_898]), 0); |
| |
| // memory_copy.wast:1738 |
| assert_return(() => call($12, "load8_u", [60_097]), 0); |
| |
| // memory_copy.wast:1739 |
| assert_return(() => call($12, "load8_u", [60_296]), 0); |
| |
| // memory_copy.wast:1740 |
| assert_return(() => call($12, "load8_u", [60_495]), 0); |
| |
| // memory_copy.wast:1741 |
| assert_return(() => call($12, "load8_u", [60_694]), 0); |
| |
| // memory_copy.wast:1742 |
| assert_return(() => call($12, "load8_u", [60_893]), 0); |
| |
| // memory_copy.wast:1743 |
| assert_return(() => call($12, "load8_u", [61_092]), 0); |
| |
| // memory_copy.wast:1744 |
| assert_return(() => call($12, "load8_u", [61_291]), 0); |
| |
| // memory_copy.wast:1745 |
| assert_return(() => call($12, "load8_u", [61_490]), 0); |
| |
| // memory_copy.wast:1746 |
| assert_return(() => call($12, "load8_u", [61_689]), 0); |
| |
| // memory_copy.wast:1747 |
| assert_return(() => call($12, "load8_u", [61_888]), 0); |
| |
| // memory_copy.wast:1748 |
| assert_return(() => call($12, "load8_u", [62_087]), 0); |
| |
| // memory_copy.wast:1749 |
| assert_return(() => call($12, "load8_u", [62_286]), 0); |
| |
| // memory_copy.wast:1750 |
| assert_return(() => call($12, "load8_u", [62_485]), 0); |
| |
| // memory_copy.wast:1751 |
| assert_return(() => call($12, "load8_u", [62_684]), 0); |
| |
| // memory_copy.wast:1752 |
| assert_return(() => call($12, "load8_u", [62_883]), 0); |
| |
| // memory_copy.wast:1753 |
| assert_return(() => call($12, "load8_u", [63_082]), 0); |
| |
| // memory_copy.wast:1754 |
| assert_return(() => call($12, "load8_u", [63_281]), 0); |
| |
| // memory_copy.wast:1755 |
| assert_return(() => call($12, "load8_u", [63_480]), 0); |
| |
| // memory_copy.wast:1756 |
| assert_return(() => call($12, "load8_u", [63_679]), 0); |
| |
| // memory_copy.wast:1757 |
| assert_return(() => call($12, "load8_u", [63_878]), 0); |
| |
| // memory_copy.wast:1758 |
| assert_return(() => call($12, "load8_u", [64_077]), 0); |
| |
| // memory_copy.wast:1759 |
| assert_return(() => call($12, "load8_u", [64_276]), 0); |
| |
| // memory_copy.wast:1760 |
| assert_return(() => call($12, "load8_u", [64_475]), 0); |
| |
| // memory_copy.wast:1761 |
| assert_return(() => call($12, "load8_u", [64_674]), 0); |
| |
| // memory_copy.wast:1762 |
| assert_return(() => call($12, "load8_u", [64_873]), 0); |
| |
| // memory_copy.wast:1763 |
| assert_return(() => call($12, "load8_u", [65_072]), 0); |
| |
| // memory_copy.wast:1764 |
| assert_return(() => call($12, "load8_u", [65_271]), 0); |
| |
| // memory_copy.wast:1765 |
| assert_return(() => call($12, "load8_u", [65_470]), 0); |
| |
| // memory_copy.wast:1766 |
| assert_return(() => call($12, "load8_u", [65_515]), 0); |
| |
| // memory_copy.wast:1767 |
| assert_return(() => call($12, "load8_u", [65_516]), 1); |
| |
| // memory_copy.wast:1768 |
| assert_return(() => call($12, "load8_u", [65_517]), 2); |
| |
| // memory_copy.wast:1769 |
| assert_return(() => call($12, "load8_u", [65_518]), 3); |
| |
| // memory_copy.wast:1770 |
| assert_return(() => call($12, "load8_u", [65_519]), 4); |
| |
| // memory_copy.wast:1771 |
| assert_return(() => call($12, "load8_u", [65_520]), 5); |
| |
| // memory_copy.wast:1772 |
| assert_return(() => call($12, "load8_u", [65_521]), 6); |
| |
| // memory_copy.wast:1773 |
| assert_return(() => call($12, "load8_u", [65_522]), 7); |
| |
| // memory_copy.wast:1774 |
| assert_return(() => call($12, "load8_u", [65_523]), 8); |
| |
| // memory_copy.wast:1775 |
| assert_return(() => call($12, "load8_u", [65_524]), 9); |
| |
| // memory_copy.wast:1776 |
| assert_return(() => call($12, "load8_u", [65_525]), 10); |
| |
| // memory_copy.wast:1777 |
| assert_return(() => call($12, "load8_u", [65_526]), 11); |
| |
| // memory_copy.wast:1778 |
| assert_return(() => call($12, "load8_u", [65_527]), 12); |
| |
| // memory_copy.wast:1779 |
| assert_return(() => call($12, "load8_u", [65_528]), 13); |
| |
| // memory_copy.wast:1780 |
| assert_return(() => call($12, "load8_u", [65_529]), 14); |
| |
| // memory_copy.wast:1781 |
| assert_return(() => call($12, "load8_u", [65_530]), 15); |
| |
| // memory_copy.wast:1782 |
| assert_return(() => call($12, "load8_u", [65_531]), 16); |
| |
| // memory_copy.wast:1783 |
| assert_return(() => call($12, "load8_u", [65_532]), 17); |
| |
| // memory_copy.wast:1784 |
| assert_return(() => call($12, "load8_u", [65_533]), 18); |
| |
| // memory_copy.wast:1785 |
| assert_return(() => call($12, "load8_u", [65_534]), 19); |
| |
| // memory_copy.wast:1786 |
| assert_return(() => call($12, "load8_u", [65_535]), 20); |
| |
| // memory_copy.wast:1788 |
| 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:1796 |
| assert_trap(() => call($13, "run", [65_516, 65_486, 40])); |
| |
| // memory_copy.wast:1799 |
| assert_return(() => call($13, "load8_u", [198]), 0); |
| |
| // memory_copy.wast:1800 |
| assert_return(() => call($13, "load8_u", [397]), 0); |
| |
| // memory_copy.wast:1801 |
| assert_return(() => call($13, "load8_u", [596]), 0); |
| |
| // memory_copy.wast:1802 |
| assert_return(() => call($13, "load8_u", [795]), 0); |
| |
| // memory_copy.wast:1803 |
| assert_return(() => call($13, "load8_u", [994]), 0); |
| |
| // memory_copy.wast:1804 |
| assert_return(() => call($13, "load8_u", [1_193]), 0); |
| |
| // memory_copy.wast:1805 |
| assert_return(() => call($13, "load8_u", [1_392]), 0); |
| |
| // memory_copy.wast:1806 |
| assert_return(() => call($13, "load8_u", [1_591]), 0); |
| |
| // memory_copy.wast:1807 |
| assert_return(() => call($13, "load8_u", [1_790]), 0); |
| |
| // memory_copy.wast:1808 |
| assert_return(() => call($13, "load8_u", [1_989]), 0); |
| |
| // memory_copy.wast:1809 |
| assert_return(() => call($13, "load8_u", [2_188]), 0); |
| |
| // memory_copy.wast:1810 |
| assert_return(() => call($13, "load8_u", [2_387]), 0); |
| |
| // memory_copy.wast:1811 |
| assert_return(() => call($13, "load8_u", [2_586]), 0); |
| |
| // memory_copy.wast:1812 |
| assert_return(() => call($13, "load8_u", [2_785]), 0); |
| |
| // memory_copy.wast:1813 |
| assert_return(() => call($13, "load8_u", [2_984]), 0); |
| |
| // memory_copy.wast:1814 |
| assert_return(() => call($13, "load8_u", [3_183]), 0); |
| |
| // memory_copy.wast:1815 |
| assert_return(() => call($13, "load8_u", [3_382]), 0); |
| |
| // memory_copy.wast:1816 |
| assert_return(() => call($13, "load8_u", [3_581]), 0); |
| |
| // memory_copy.wast:1817 |
| assert_return(() => call($13, "load8_u", [3_780]), 0); |
| |
| // memory_copy.wast:1818 |
| assert_return(() => call($13, "load8_u", [3_979]), 0); |
| |
| // memory_copy.wast:1819 |
| assert_return(() => call($13, "load8_u", [4_178]), 0); |
| |
| // memory_copy.wast:1820 |
| assert_return(() => call($13, "load8_u", [4_377]), 0); |
| |
| // memory_copy.wast:1821 |
| assert_return(() => call($13, "load8_u", [4_576]), 0); |
| |
| // memory_copy.wast:1822 |
| assert_return(() => call($13, "load8_u", [4_775]), 0); |
| |
| // memory_copy.wast:1823 |
| assert_return(() => call($13, "load8_u", [4_974]), 0); |
| |
| // memory_copy.wast:1824 |
| assert_return(() => call($13, "load8_u", [5_173]), 0); |
| |
| // memory_copy.wast:1825 |
| assert_return(() => call($13, "load8_u", [5_372]), 0); |
| |
| // memory_copy.wast:1826 |
| assert_return(() => call($13, "load8_u", [5_571]), 0); |
| |
| // memory_copy.wast:1827 |
| assert_return(() => call($13, "load8_u", [5_770]), 0); |
| |
| // memory_copy.wast:1828 |
| assert_return(() => call($13, "load8_u", [5_969]), 0); |
| |
| // memory_copy.wast:1829 |
| assert_return(() => call($13, "load8_u", [6_168]), 0); |
| |
| // memory_copy.wast:1830 |
| assert_return(() => call($13, "load8_u", [6_367]), 0); |
| |
| // memory_copy.wast:1831 |
| assert_return(() => call($13, "load8_u", [6_566]), 0); |
| |
| // memory_copy.wast:1832 |
| assert_return(() => call($13, "load8_u", [6_765]), 0); |
| |
| // memory_copy.wast:1833 |
| assert_return(() => call($13, "load8_u", [6_964]), 0); |
| |
| // memory_copy.wast:1834 |
| assert_return(() => call($13, "load8_u", [7_163]), 0); |
| |
| // memory_copy.wast:1835 |
| assert_return(() => call($13, "load8_u", [7_362]), 0); |
| |
| // memory_copy.wast:1836 |
| assert_return(() => call($13, "load8_u", [7_561]), 0); |
| |
| // memory_copy.wast:1837 |
| assert_return(() => call($13, "load8_u", [7_760]), 0); |
| |
| // memory_copy.wast:1838 |
| assert_return(() => call($13, "load8_u", [7_959]), 0); |
| |
| // memory_copy.wast:1839 |
| assert_return(() => call($13, "load8_u", [8_158]), 0); |
| |
| // memory_copy.wast:1840 |
| assert_return(() => call($13, "load8_u", [8_357]), 0); |
| |
| // memory_copy.wast:1841 |
| assert_return(() => call($13, "load8_u", [8_556]), 0); |
| |
| // memory_copy.wast:1842 |
| assert_return(() => call($13, "load8_u", [8_755]), 0); |
| |
| // memory_copy.wast:1843 |
| assert_return(() => call($13, "load8_u", [8_954]), 0); |
| |
| // memory_copy.wast:1844 |
| assert_return(() => call($13, "load8_u", [9_153]), 0); |
| |
| // memory_copy.wast:1845 |
| assert_return(() => call($13, "load8_u", [9_352]), 0); |
| |
| // memory_copy.wast:1846 |
| assert_return(() => call($13, "load8_u", [9_551]), 0); |
| |
| // memory_copy.wast:1847 |
| assert_return(() => call($13, "load8_u", [9_750]), 0); |
| |
| // memory_copy.wast:1848 |
| assert_return(() => call($13, "load8_u", [9_949]), 0); |
| |
| // memory_copy.wast:1849 |
| assert_return(() => call($13, "load8_u", [10_148]), 0); |
| |
| // memory_copy.wast:1850 |
| assert_return(() => call($13, "load8_u", [10_347]), 0); |
| |
| // memory_copy.wast:1851 |
| assert_return(() => call($13, "load8_u", [10_546]), 0); |
| |
| // memory_copy.wast:1852 |
| assert_return(() => call($13, "load8_u", [10_745]), 0); |
| |
| // memory_copy.wast:1853 |
| assert_return(() => call($13, "load8_u", [10_944]), 0); |
| |
| // memory_copy.wast:1854 |
| assert_return(() => call($13, "load8_u", [11_143]), 0); |
| |
| // memory_copy.wast:1855 |
| assert_return(() => call($13, "load8_u", [11_342]), 0); |
| |
| // memory_copy.wast:1856 |
| assert_return(() => call($13, "load8_u", [11_541]), 0); |
| |
| // memory_copy.wast:1857 |
| assert_return(() => call($13, "load8_u", [11_740]), 0); |
| |
| // memory_copy.wast:1858 |
| assert_return(() => call($13, "load8_u", [11_939]), 0); |
| |
| // memory_copy.wast:1859 |
| assert_return(() => call($13, "load8_u", [12_138]), 0); |
| |
| // memory_copy.wast:1860 |
| assert_return(() => call($13, "load8_u", [12_337]), 0); |
| |
| // memory_copy.wast:1861 |
| assert_return(() => call($13, "load8_u", [12_536]), 0); |
| |
| // memory_copy.wast:1862 |
| assert_return(() => call($13, "load8_u", [12_735]), 0); |
| |
| // memory_copy.wast:1863 |
| assert_return(() => call($13, "load8_u", [12_934]), 0); |
| |
| // memory_copy.wast:1864 |
| assert_return(() => call($13, "load8_u", [13_133]), 0); |
| |
| // memory_copy.wast:1865 |
| assert_return(() => call($13, "load8_u", [13_332]), 0); |
| |
| // memory_copy.wast:1866 |
| assert_return(() => call($13, "load8_u", [13_531]), 0); |
| |
| // memory_copy.wast:1867 |
| assert_return(() => call($13, "load8_u", [13_730]), 0); |
| |
| // memory_copy.wast:1868 |
| assert_return(() => call($13, "load8_u", [13_929]), 0); |
| |
| // memory_copy.wast:1869 |
| assert_return(() => call($13, "load8_u", [14_128]), 0); |
| |
| // memory_copy.wast:1870 |
| assert_return(() => call($13, "load8_u", [14_327]), 0); |
| |
| // memory_copy.wast:1871 |
| assert_return(() => call($13, "load8_u", [14_526]), 0); |
| |
| // memory_copy.wast:1872 |
| assert_return(() => call($13, "load8_u", [14_725]), 0); |
| |
| // memory_copy.wast:1873 |
| assert_return(() => call($13, "load8_u", [14_924]), 0); |
| |
| // memory_copy.wast:1874 |
| assert_return(() => call($13, "load8_u", [15_123]), 0); |
| |
| // memory_copy.wast:1875 |
| assert_return(() => call($13, "load8_u", [15_322]), 0); |
| |
| // memory_copy.wast:1876 |
| assert_return(() => call($13, "load8_u", [15_521]), 0); |
| |
| // memory_copy.wast:1877 |
| assert_return(() => call($13, "load8_u", [15_720]), 0); |
| |
| // memory_copy.wast:1878 |
| assert_return(() => call($13, "load8_u", [15_919]), 0); |
| |
| // memory_copy.wast:1879 |
| assert_return(() => call($13, "load8_u", [16_118]), 0); |
| |
| // memory_copy.wast:1880 |
| assert_return(() => call($13, "load8_u", [16_317]), 0); |
| |
| // memory_copy.wast:1881 |
| assert_return(() => call($13, "load8_u", [16_516]), 0); |
| |
| // memory_copy.wast:1882 |
| assert_return(() => call($13, "load8_u", [16_715]), 0); |
| |
| // memory_copy.wast:1883 |
| assert_return(() => call($13, "load8_u", [16_914]), 0); |
| |
| // memory_copy.wast:1884 |
| assert_return(() => call($13, "load8_u", [17_113]), 0); |
| |
| // memory_copy.wast:1885 |
| assert_return(() => call($13, "load8_u", [17_312]), 0); |
| |
| // memory_copy.wast:1886 |
| assert_return(() => call($13, "load8_u", [17_511]), 0); |
| |
| // memory_copy.wast:1887 |
| assert_return(() => call($13, "load8_u", [17_710]), 0); |
| |
| // memory_copy.wast:1888 |
| assert_return(() => call($13, "load8_u", [17_909]), 0); |
| |
| // memory_copy.wast:1889 |
| assert_return(() => call($13, "load8_u", [18_108]), 0); |
| |
| // memory_copy.wast:1890 |
| assert_return(() => call($13, "load8_u", [18_307]), 0); |
| |
| // memory_copy.wast:1891 |
| assert_return(() => call($13, "load8_u", [18_506]), 0); |
| |
| // memory_copy.wast:1892 |
| assert_return(() => call($13, "load8_u", [18_705]), 0); |
| |
| // memory_copy.wast:1893 |
| assert_return(() => call($13, "load8_u", [18_904]), 0); |
| |
| // memory_copy.wast:1894 |
| assert_return(() => call($13, "load8_u", [19_103]), 0); |
| |
| // memory_copy.wast:1895 |
| assert_return(() => call($13, "load8_u", [19_302]), 0); |
| |
| // memory_copy.wast:1896 |
| assert_return(() => call($13, "load8_u", [19_501]), 0); |
| |
| // memory_copy.wast:1897 |
| assert_return(() => call($13, "load8_u", [19_700]), 0); |
| |
| // memory_copy.wast:1898 |
| assert_return(() => call($13, "load8_u", [19_899]), 0); |
| |
| // memory_copy.wast:1899 |
| assert_return(() => call($13, "load8_u", [20_098]), 0); |
| |
| // memory_copy.wast:1900 |
| assert_return(() => call($13, "load8_u", [20_297]), 0); |
| |
| // memory_copy.wast:1901 |
| assert_return(() => call($13, "load8_u", [20_496]), 0); |
| |
| // memory_copy.wast:1902 |
| assert_return(() => call($13, "load8_u", [20_695]), 0); |
| |
| // memory_copy.wast:1903 |
| assert_return(() => call($13, "load8_u", [20_894]), 0); |
| |
| // memory_copy.wast:1904 |
| assert_return(() => call($13, "load8_u", [21_093]), 0); |
| |
| // memory_copy.wast:1905 |
| assert_return(() => call($13, "load8_u", [21_292]), 0); |
| |
| // memory_copy.wast:1906 |
| assert_return(() => call($13, "load8_u", [21_491]), 0); |
| |
| // memory_copy.wast:1907 |
| assert_return(() => call($13, "load8_u", [21_690]), 0); |
| |
| // memory_copy.wast:1908 |
| assert_return(() => call($13, "load8_u", [21_889]), 0); |
| |
| // memory_copy.wast:1909 |
| assert_return(() => call($13, "load8_u", [22_088]), 0); |
| |
| // memory_copy.wast:1910 |
| assert_return(() => call($13, "load8_u", [22_287]), 0); |
| |
| // memory_copy.wast:1911 |
| assert_return(() => call($13, "load8_u", [22_486]), 0); |
| |
| // memory_copy.wast:1912 |
| assert_return(() => call($13, "load8_u", [22_685]), 0); |
| |
| // memory_copy.wast:1913 |
| assert_return(() => call($13, "load8_u", [22_884]), 0); |
| |
| // memory_copy.wast:1914 |
| assert_return(() => call($13, "load8_u", [23_083]), 0); |
| |
| // memory_copy.wast:1915 |
| assert_return(() => call($13, "load8_u", [23_282]), 0); |
| |
| // memory_copy.wast:1916 |
| assert_return(() => call($13, "load8_u", [23_481]), 0); |
| |
| // memory_copy.wast:1917 |
| assert_return(() => call($13, "load8_u", [23_680]), 0); |
| |
| // memory_copy.wast:1918 |
| assert_return(() => call($13, "load8_u", [23_879]), 0); |
| |
| // memory_copy.wast:1919 |
| assert_return(() => call($13, "load8_u", [24_078]), 0); |
| |
| // memory_copy.wast:1920 |
| assert_return(() => call($13, "load8_u", [24_277]), 0); |
| |
| // memory_copy.wast:1921 |
| assert_return(() => call($13, "load8_u", [24_476]), 0); |
| |
| // memory_copy.wast:1922 |
| assert_return(() => call($13, "load8_u", [24_675]), 0); |
| |
| // memory_copy.wast:1923 |
| assert_return(() => call($13, "load8_u", [24_874]), 0); |
| |
| // memory_copy.wast:1924 |
| assert_return(() => call($13, "load8_u", [25_073]), 0); |
| |
| // memory_copy.wast:1925 |
| assert_return(() => call($13, "load8_u", [25_272]), 0); |
| |
| // memory_copy.wast:1926 |
| assert_return(() => call($13, "load8_u", [25_471]), 0); |
| |
| // memory_copy.wast:1927 |
| assert_return(() => call($13, "load8_u", [25_670]), 0); |
| |
| // memory_copy.wast:1928 |
| assert_return(() => call($13, "load8_u", [25_869]), 0); |
| |
| // memory_copy.wast:1929 |
| assert_return(() => call($13, "load8_u", [26_068]), 0); |
| |
| // memory_copy.wast:1930 |
| assert_return(() => call($13, "load8_u", [26_267]), 0); |
| |
| // memory_copy.wast:1931 |
| assert_return(() => call($13, "load8_u", [26_466]), 0); |
| |
| // memory_copy.wast:1932 |
| assert_return(() => call($13, "load8_u", [26_665]), 0); |
| |
| // memory_copy.wast:1933 |
| assert_return(() => call($13, "load8_u", [26_864]), 0); |
| |
| // memory_copy.wast:1934 |
| assert_return(() => call($13, "load8_u", [27_063]), 0); |
| |
| // memory_copy.wast:1935 |
| assert_return(() => call($13, "load8_u", [27_262]), 0); |
| |
| // memory_copy.wast:1936 |
| assert_return(() => call($13, "load8_u", [27_461]), 0); |
| |
| // memory_copy.wast:1937 |
| assert_return(() => call($13, "load8_u", [27_660]), 0); |
| |
| // memory_copy.wast:1938 |
| assert_return(() => call($13, "load8_u", [27_859]), 0); |
| |
| // memory_copy.wast:1939 |
| assert_return(() => call($13, "load8_u", [28_058]), 0); |
| |
| // memory_copy.wast:1940 |
| assert_return(() => call($13, "load8_u", [28_257]), 0); |
| |
| // memory_copy.wast:1941 |
| assert_return(() => call($13, "load8_u", [28_456]), 0); |
| |
| // memory_copy.wast:1942 |
| assert_return(() => call($13, "load8_u", [28_655]), 0); |
| |
| // memory_copy.wast:1943 |
| assert_return(() => call($13, "load8_u", [28_854]), 0); |
| |
| // memory_copy.wast:1944 |
| assert_return(() => call($13, "load8_u", [29_053]), 0); |
| |
| // memory_copy.wast:1945 |
| assert_return(() => call($13, "load8_u", [29_252]), 0); |
| |
| // memory_copy.wast:1946 |
| assert_return(() => call($13, "load8_u", [29_451]), 0); |
| |
| // memory_copy.wast:1947 |
| assert_return(() => call($13, "load8_u", [29_650]), 0); |
| |
| // memory_copy.wast:1948 |
| assert_return(() => call($13, "load8_u", [29_849]), 0); |
| |
| // memory_copy.wast:1949 |
| assert_return(() => call($13, "load8_u", [30_048]), 0); |
| |
| // memory_copy.wast:1950 |
| assert_return(() => call($13, "load8_u", [30_247]), 0); |
| |
| // memory_copy.wast:1951 |
| assert_return(() => call($13, "load8_u", [30_446]), 0); |
| |
| // memory_copy.wast:1952 |
| assert_return(() => call($13, "load8_u", [30_645]), 0); |
| |
| // memory_copy.wast:1953 |
| assert_return(() => call($13, "load8_u", [30_844]), 0); |
| |
| // memory_copy.wast:1954 |
| assert_return(() => call($13, "load8_u", [31_043]), 0); |
| |
| // memory_copy.wast:1955 |
| assert_return(() => call($13, "load8_u", [31_242]), 0); |
| |
| // memory_copy.wast:1956 |
| assert_return(() => call($13, "load8_u", [31_441]), 0); |
| |
| // memory_copy.wast:1957 |
| assert_return(() => call($13, "load8_u", [31_640]), 0); |
| |
| // memory_copy.wast:1958 |
| assert_return(() => call($13, "load8_u", [31_839]), 0); |
| |
| // memory_copy.wast:1959 |
| assert_return(() => call($13, "load8_u", [32_038]), 0); |
| |
| // memory_copy.wast:1960 |
| assert_return(() => call($13, "load8_u", [32_237]), 0); |
| |
| // memory_copy.wast:1961 |
| assert_return(() => call($13, "load8_u", [32_436]), 0); |
| |
| // memory_copy.wast:1962 |
| assert_return(() => call($13, "load8_u", [32_635]), 0); |
| |
| // memory_copy.wast:1963 |
| assert_return(() => call($13, "load8_u", [32_834]), 0); |
| |
| // memory_copy.wast:1964 |
| assert_return(() => call($13, "load8_u", [33_033]), 0); |
| |
| // memory_copy.wast:1965 |
| assert_return(() => call($13, "load8_u", [33_232]), 0); |
| |
| // memory_copy.wast:1966 |
| assert_return(() => call($13, "load8_u", [33_431]), 0); |
| |
| // memory_copy.wast:1967 |
| assert_return(() => call($13, "load8_u", [33_630]), 0); |
| |
| // memory_copy.wast:1968 |
| assert_return(() => call($13, "load8_u", [33_829]), 0); |
| |
| // memory_copy.wast:1969 |
| assert_return(() => call($13, "load8_u", [34_028]), 0); |
| |
| // memory_copy.wast:1970 |
| assert_return(() => call($13, "load8_u", [34_227]), 0); |
| |
| // memory_copy.wast:1971 |
| assert_return(() => call($13, "load8_u", [34_426]), 0); |
| |
| // memory_copy.wast:1972 |
| assert_return(() => call($13, "load8_u", [34_625]), 0); |
| |
| // memory_copy.wast:1973 |
| assert_return(() => call($13, "load8_u", [34_824]), 0); |
| |
| // memory_copy.wast:1974 |
| assert_return(() => call($13, "load8_u", [35_023]), 0); |
| |
| // memory_copy.wast:1975 |
| assert_return(() => call($13, "load8_u", [35_222]), 0); |
| |
| // memory_copy.wast:1976 |
| assert_return(() => call($13, "load8_u", [35_421]), 0); |
| |
| // memory_copy.wast:1977 |
| assert_return(() => call($13, "load8_u", [35_620]), 0); |
| |
| // memory_copy.wast:1978 |
| assert_return(() => call($13, "load8_u", [35_819]), 0); |
| |
| // memory_copy.wast:1979 |
| assert_return(() => call($13, "load8_u", [36_018]), 0); |
| |
| // memory_copy.wast:1980 |
| assert_return(() => call($13, "load8_u", [36_217]), 0); |
| |
| // memory_copy.wast:1981 |
| assert_return(() => call($13, "load8_u", [36_416]), 0); |
| |
| // memory_copy.wast:1982 |
| assert_return(() => call($13, "load8_u", [36_615]), 0); |
| |
| // memory_copy.wast:1983 |
| assert_return(() => call($13, "load8_u", [36_814]), 0); |
| |
| // memory_copy.wast:1984 |
| assert_return(() => call($13, "load8_u", [37_013]), 0); |
| |
| // memory_copy.wast:1985 |
| assert_return(() => call($13, "load8_u", [37_212]), 0); |
| |
| // memory_copy.wast:1986 |
| assert_return(() => call($13, "load8_u", [37_411]), 0); |
| |
| // memory_copy.wast:1987 |
| assert_return(() => call($13, "load8_u", [37_610]), 0); |
| |
| // memory_copy.wast:1988 |
| assert_return(() => call($13, "load8_u", [37_809]), 0); |
| |
| // memory_copy.wast:1989 |
| assert_return(() => call($13, "load8_u", [38_008]), 0); |
| |
| // memory_copy.wast:1990 |
| assert_return(() => call($13, "load8_u", [38_207]), 0); |
| |
| // memory_copy.wast:1991 |
| assert_return(() => call($13, "load8_u", [38_406]), 0); |
| |
| // memory_copy.wast:1992 |
| assert_return(() => call($13, "load8_u", [38_605]), 0); |
| |
| // memory_copy.wast:1993 |
| assert_return(() => call($13, "load8_u", [38_804]), 0); |
| |
| // memory_copy.wast:1994 |
| assert_return(() => call($13, "load8_u", [39_003]), 0); |
| |
| // memory_copy.wast:1995 |
| assert_return(() => call($13, "load8_u", [39_202]), 0); |
| |
| // memory_copy.wast:1996 |
| assert_return(() => call($13, "load8_u", [39_401]), 0); |
| |
| // memory_copy.wast:1997 |
| assert_return(() => call($13, "load8_u", [39_600]), 0); |
| |
| // memory_copy.wast:1998 |
| assert_return(() => call($13, "load8_u", [39_799]), 0); |
| |
| // memory_copy.wast:1999 |
| assert_return(() => call($13, "load8_u", [39_998]), 0); |
| |
| // memory_copy.wast:2000 |
| assert_return(() => call($13, "load8_u", [40_197]), 0); |
| |
| // memory_copy.wast:2001 |
| assert_return(() => call($13, "load8_u", [40_396]), 0); |
| |
| // memory_copy.wast:2002 |
| assert_return(() => call($13, "load8_u", [40_595]), 0); |
| |
| // memory_copy.wast:2003 |
| assert_return(() => call($13, "load8_u", [40_794]), 0); |
| |
| // memory_copy.wast:2004 |
| assert_return(() => call($13, "load8_u", [40_993]), 0); |
| |
| // memory_copy.wast:2005 |
| assert_return(() => call($13, "load8_u", [41_192]), 0); |
| |
| // memory_copy.wast:2006 |
| assert_return(() => call($13, "load8_u", [41_391]), 0); |
| |
| // memory_copy.wast:2007 |
| assert_return(() => call($13, "load8_u", [41_590]), 0); |
| |
| // memory_copy.wast:2008 |
| assert_return(() => call($13, "load8_u", [41_789]), 0); |
| |
| // memory_copy.wast:2009 |
| assert_return(() => call($13, "load8_u", [41_988]), 0); |
| |
| // memory_copy.wast:2010 |
| assert_return(() => call($13, "load8_u", [42_187]), 0); |
| |
| // memory_copy.wast:2011 |
| assert_return(() => call($13, "load8_u", [42_386]), 0); |
| |
| // memory_copy.wast:2012 |
| assert_return(() => call($13, "load8_u", [42_585]), 0); |
| |
| // memory_copy.wast:2013 |
| assert_return(() => call($13, "load8_u", [42_784]), 0); |
| |
| // memory_copy.wast:2014 |
| assert_return(() => call($13, "load8_u", [42_983]), 0); |
| |
| // memory_copy.wast:2015 |
| assert_return(() => call($13, "load8_u", [43_182]), 0); |
| |
| // memory_copy.wast:2016 |
| assert_return(() => call($13, "load8_u", [43_381]), 0); |
| |
| // memory_copy.wast:2017 |
| assert_return(() => call($13, "load8_u", [43_580]), 0); |
| |
| // memory_copy.wast:2018 |
| assert_return(() => call($13, "load8_u", [43_779]), 0); |
| |
| // memory_copy.wast:2019 |
| assert_return(() => call($13, "load8_u", [43_978]), 0); |
| |
| // memory_copy.wast:2020 |
| assert_return(() => call($13, "load8_u", [44_177]), 0); |
| |
| // memory_copy.wast:2021 |
| assert_return(() => call($13, "load8_u", [44_376]), 0); |
| |
| // memory_copy.wast:2022 |
| assert_return(() => call($13, "load8_u", [44_575]), 0); |
| |
| // memory_copy.wast:2023 |
| assert_return(() => call($13, "load8_u", [44_774]), 0); |
| |
| // memory_copy.wast:2024 |
| assert_return(() => call($13, "load8_u", [44_973]), 0); |
| |
| // memory_copy.wast:2025 |
| assert_return(() => call($13, "load8_u", [45_172]), 0); |
| |
| // memory_copy.wast:2026 |
| assert_return(() => call($13, "load8_u", [45_371]), 0); |
| |
| // memory_copy.wast:2027 |
| assert_return(() => call($13, "load8_u", [45_570]), 0); |
| |
| // memory_copy.wast:2028 |
| assert_return(() => call($13, "load8_u", [45_769]), 0); |
| |
| // memory_copy.wast:2029 |
| assert_return(() => call($13, "load8_u", [45_968]), 0); |
| |
| // memory_copy.wast:2030 |
| assert_return(() => call($13, "load8_u", [46_167]), 0); |
| |
| // memory_copy.wast:2031 |
| assert_return(() => call($13, "load8_u", [46_366]), 0); |
| |
| // memory_copy.wast:2032 |
| assert_return(() => call($13, "load8_u", [46_565]), 0); |
| |
| // memory_copy.wast:2033 |
| assert_return(() => call($13, "load8_u", [46_764]), 0); |
| |
| // memory_copy.wast:2034 |
| assert_return(() => call($13, "load8_u", [46_963]), 0); |
| |
| // memory_copy.wast:2035 |
| assert_return(() => call($13, "load8_u", [47_162]), 0); |
| |
| // memory_copy.wast:2036 |
| assert_return(() => call($13, "load8_u", [47_361]), 0); |
| |
| // memory_copy.wast:2037 |
| assert_return(() => call($13, "load8_u", [47_560]), 0); |
| |
| // memory_copy.wast:2038 |
| assert_return(() => call($13, "load8_u", [47_759]), 0); |
| |
| // memory_copy.wast:2039 |
| assert_return(() => call($13, "load8_u", [47_958]), 0); |
| |
| // memory_copy.wast:2040 |
| assert_return(() => call($13, "load8_u", [48_157]), 0); |
| |
| // memory_copy.wast:2041 |
| assert_return(() => call($13, "load8_u", [48_356]), 0); |
| |
| // memory_copy.wast:2042 |
| assert_return(() => call($13, "load8_u", [48_555]), 0); |
| |
| // memory_copy.wast:2043 |
| assert_return(() => call($13, "load8_u", [48_754]), 0); |
| |
| // memory_copy.wast:2044 |
| assert_return(() => call($13, "load8_u", [48_953]), 0); |
| |
| // memory_copy.wast:2045 |
| assert_return(() => call($13, "load8_u", [49_152]), 0); |
| |
| // memory_copy.wast:2046 |
| assert_return(() => call($13, "load8_u", [49_351]), 0); |
| |
| // memory_copy.wast:2047 |
| assert_return(() => call($13, "load8_u", [49_550]), 0); |
| |
| // memory_copy.wast:2048 |
| assert_return(() => call($13, "load8_u", [49_749]), 0); |
| |
| // memory_copy.wast:2049 |
| assert_return(() => call($13, "load8_u", [49_948]), 0); |
| |
| // memory_copy.wast:2050 |
| assert_return(() => call($13, "load8_u", [50_147]), 0); |
| |
| // memory_copy.wast:2051 |
| assert_return(() => call($13, "load8_u", [50_346]), 0); |
| |
| // memory_copy.wast:2052 |
| assert_return(() => call($13, "load8_u", [50_545]), 0); |
| |
| // memory_copy.wast:2053 |
| assert_return(() => call($13, "load8_u", [50_744]), 0); |
| |
| // memory_copy.wast:2054 |
| assert_return(() => call($13, "load8_u", [50_943]), 0); |
| |
| // memory_copy.wast:2055 |
| assert_return(() => call($13, "load8_u", [51_142]), 0); |
| |
| // memory_copy.wast:2056 |
| assert_return(() => call($13, "load8_u", [51_341]), 0); |
| |
| // memory_copy.wast:2057 |
| assert_return(() => call($13, "load8_u", [51_540]), 0); |
| |
| // memory_copy.wast:2058 |
| assert_return(() => call($13, "load8_u", [51_739]), 0); |
| |
| // memory_copy.wast:2059 |
| assert_return(() => call($13, "load8_u", [51_938]), 0); |
| |
| // memory_copy.wast:2060 |
| assert_return(() => call($13, "load8_u", [52_137]), 0); |
| |
| // memory_copy.wast:2061 |
| assert_return(() => call($13, "load8_u", [52_336]), 0); |
| |
| // memory_copy.wast:2062 |
| assert_return(() => call($13, "load8_u", [52_535]), 0); |
| |
| // memory_copy.wast:2063 |
| assert_return(() => call($13, "load8_u", [52_734]), 0); |
| |
| // memory_copy.wast:2064 |
| assert_return(() => call($13, "load8_u", [52_933]), 0); |
| |
| // memory_copy.wast:2065 |
| assert_return(() => call($13, "load8_u", [53_132]), 0); |
| |
| // memory_copy.wast:2066 |
| assert_return(() => call($13, "load8_u", [53_331]), 0); |
| |
| // memory_copy.wast:2067 |
| assert_return(() => call($13, "load8_u", [53_530]), 0); |
| |
| // memory_copy.wast:2068 |
| assert_return(() => call($13, "load8_u", [53_729]), 0); |
| |
| // memory_copy.wast:2069 |
| assert_return(() => call($13, "load8_u", [53_928]), 0); |
| |
| // memory_copy.wast:2070 |
| assert_return(() => call($13, "load8_u", [54_127]), 0); |
| |
| // memory_copy.wast:2071 |
| assert_return(() => call($13, "load8_u", [54_326]), 0); |
| |
| // memory_copy.wast:2072 |
| assert_return(() => call($13, "load8_u", [54_525]), 0); |
| |
| // memory_copy.wast:2073 |
| assert_return(() => call($13, "load8_u", [54_724]), 0); |
| |
| // memory_copy.wast:2074 |
| assert_return(() => call($13, "load8_u", [54_923]), 0); |
| |
| // memory_copy.wast:2075 |
| assert_return(() => call($13, "load8_u", [55_122]), 0); |
| |
| // memory_copy.wast:2076 |
| assert_return(() => call($13, "load8_u", [55_321]), 0); |
| |
| // memory_copy.wast:2077 |
| assert_return(() => call($13, "load8_u", [55_520]), 0); |
| |
| // memory_copy.wast:2078 |
| assert_return(() => call($13, "load8_u", [55_719]), 0); |
| |
| // memory_copy.wast:2079 |
| assert_return(() => call($13, "load8_u", [55_918]), 0); |
| |
| // memory_copy.wast:2080 |
| assert_return(() => call($13, "load8_u", [56_117]), 0); |
| |
| // memory_copy.wast:2081 |
| assert_return(() => call($13, "load8_u", [56_316]), 0); |
| |
| // memory_copy.wast:2082 |
| assert_return(() => call($13, "load8_u", [56_515]), 0); |
| |
| // memory_copy.wast:2083 |
| assert_return(() => call($13, "load8_u", [56_714]), 0); |
| |
| // memory_copy.wast:2084 |
| assert_return(() => call($13, "load8_u", [56_913]), 0); |
| |
| // memory_copy.wast:2085 |
| assert_return(() => call($13, "load8_u", [57_112]), 0); |
| |
| // memory_copy.wast:2086 |
| assert_return(() => call($13, "load8_u", [57_311]), 0); |
| |
| // memory_copy.wast:2087 |
| assert_return(() => call($13, "load8_u", [57_510]), 0); |
| |
| // memory_copy.wast:2088 |
| assert_return(() => call($13, "load8_u", [57_709]), 0); |
| |
| // memory_copy.wast:2089 |
| assert_return(() => call($13, "load8_u", [57_908]), 0); |
| |
| // memory_copy.wast:2090 |
| assert_return(() => call($13, "load8_u", [58_107]), 0); |
| |
| // memory_copy.wast:2091 |
| assert_return(() => call($13, "load8_u", [58_306]), 0); |
| |
| // memory_copy.wast:2092 |
| assert_return(() => call($13, "load8_u", [58_505]), 0); |
| |
| // memory_copy.wast:2093 |
| assert_return(() => call($13, "load8_u", [58_704]), 0); |
| |
| // memory_copy.wast:2094 |
| assert_return(() => call($13, "load8_u", [58_903]), 0); |
| |
| // memory_copy.wast:2095 |
| assert_return(() => call($13, "load8_u", [59_102]), 0); |
| |
| // memory_copy.wast:2096 |
| assert_return(() => call($13, "load8_u", [59_301]), 0); |
| |
| // memory_copy.wast:2097 |
| assert_return(() => call($13, "load8_u", [59_500]), 0); |
| |
| // memory_copy.wast:2098 |
| assert_return(() => call($13, "load8_u", [59_699]), 0); |
| |
| // memory_copy.wast:2099 |
| assert_return(() => call($13, "load8_u", [59_898]), 0); |
| |
| // memory_copy.wast:2100 |
| assert_return(() => call($13, "load8_u", [60_097]), 0); |
| |
| // memory_copy.wast:2101 |
| assert_return(() => call($13, "load8_u", [60_296]), 0); |
| |
| // memory_copy.wast:2102 |
| assert_return(() => call($13, "load8_u", [60_495]), 0); |
| |
| // memory_copy.wast:2103 |
| assert_return(() => call($13, "load8_u", [60_694]), 0); |
| |
| // memory_copy.wast:2104 |
| assert_return(() => call($13, "load8_u", [60_893]), 0); |
| |
| // memory_copy.wast:2105 |
| assert_return(() => call($13, "load8_u", [61_092]), 0); |
| |
| // memory_copy.wast:2106 |
| assert_return(() => call($13, "load8_u", [61_291]), 0); |
| |
| // memory_copy.wast:2107 |
| assert_return(() => call($13, "load8_u", [61_490]), 0); |
| |
| // memory_copy.wast:2108 |
| assert_return(() => call($13, "load8_u", [61_689]), 0); |
| |
| // memory_copy.wast:2109 |
| assert_return(() => call($13, "load8_u", [61_888]), 0); |
| |
| // memory_copy.wast:2110 |
| assert_return(() => call($13, "load8_u", [62_087]), 0); |
| |
| // memory_copy.wast:2111 |
| assert_return(() => call($13, "load8_u", [62_286]), 0); |
| |
| // memory_copy.wast:2112 |
| assert_return(() => call($13, "load8_u", [62_485]), 0); |
| |
| // memory_copy.wast:2113 |
| assert_return(() => call($13, "load8_u", [62_684]), 0); |
| |
| // memory_copy.wast:2114 |
| assert_return(() => call($13, "load8_u", [62_883]), 0); |
| |
| // memory_copy.wast:2115 |
| assert_return(() => call($13, "load8_u", [63_082]), 0); |
| |
| // memory_copy.wast:2116 |
| assert_return(() => call($13, "load8_u", [63_281]), 0); |
| |
| // memory_copy.wast:2117 |
| assert_return(() => call($13, "load8_u", [63_480]), 0); |
| |
| // memory_copy.wast:2118 |
| assert_return(() => call($13, "load8_u", [63_679]), 0); |
| |
| // memory_copy.wast:2119 |
| assert_return(() => call($13, "load8_u", [63_878]), 0); |
| |
| // memory_copy.wast:2120 |
| assert_return(() => call($13, "load8_u", [64_077]), 0); |
| |
| // memory_copy.wast:2121 |
| assert_return(() => call($13, "load8_u", [64_276]), 0); |
| |
| // memory_copy.wast:2122 |
| assert_return(() => call($13, "load8_u", [64_475]), 0); |
| |
| // memory_copy.wast:2123 |
| assert_return(() => call($13, "load8_u", [64_674]), 0); |
| |
| // memory_copy.wast:2124 |
| assert_return(() => call($13, "load8_u", [64_873]), 0); |
| |
| // memory_copy.wast:2125 |
| assert_return(() => call($13, "load8_u", [65_072]), 0); |
| |
| // memory_copy.wast:2126 |
| assert_return(() => call($13, "load8_u", [65_271]), 0); |
| |
| // memory_copy.wast:2127 |
| assert_return(() => call($13, "load8_u", [65_470]), 0); |
| |
| // memory_copy.wast:2128 |
| assert_return(() => call($13, "load8_u", [65_486]), 0); |
| |
| // memory_copy.wast:2129 |
| assert_return(() => call($13, "load8_u", [65_487]), 1); |
| |
| // memory_copy.wast:2130 |
| assert_return(() => call($13, "load8_u", [65_488]), 2); |
| |
| // memory_copy.wast:2131 |
| assert_return(() => call($13, "load8_u", [65_489]), 3); |
| |
| // memory_copy.wast:2132 |
| assert_return(() => call($13, "load8_u", [65_490]), 4); |
| |
| // memory_copy.wast:2133 |
| assert_return(() => call($13, "load8_u", [65_491]), 5); |
| |
| // memory_copy.wast:2134 |
| assert_return(() => call($13, "load8_u", [65_492]), 6); |
| |
| // memory_copy.wast:2135 |
| assert_return(() => call($13, "load8_u", [65_493]), 7); |
| |
| // memory_copy.wast:2136 |
| assert_return(() => call($13, "load8_u", [65_494]), 8); |
| |
| // memory_copy.wast:2137 |
| assert_return(() => call($13, "load8_u", [65_495]), 9); |
| |
| // memory_copy.wast:2138 |
| assert_return(() => call($13, "load8_u", [65_496]), 10); |
| |
| // memory_copy.wast:2139 |
| assert_return(() => call($13, "load8_u", [65_497]), 11); |
| |
| // memory_copy.wast:2140 |
| assert_return(() => call($13, "load8_u", [65_498]), 12); |
| |
| // memory_copy.wast:2141 |
| assert_return(() => call($13, "load8_u", [65_499]), 13); |
| |
| // memory_copy.wast:2142 |
| assert_return(() => call($13, "load8_u", [65_500]), 14); |
| |
| // memory_copy.wast:2143 |
| assert_return(() => call($13, "load8_u", [65_501]), 15); |
| |
| // memory_copy.wast:2144 |
| assert_return(() => call($13, "load8_u", [65_502]), 16); |
| |
| // memory_copy.wast:2145 |
| assert_return(() => call($13, "load8_u", [65_503]), 17); |
| |
| // memory_copy.wast:2146 |
| assert_return(() => call($13, "load8_u", [65_504]), 18); |
| |
| // memory_copy.wast:2147 |
| assert_return(() => call($13, "load8_u", [65_505]), 19); |
| |
| // memory_copy.wast:2149 |
| 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:2157 |
| assert_trap(() => call($14, "run", [65_486, 65_516, 40])); |
| |
| // memory_copy.wast:2160 |
| assert_return(() => call($14, "load8_u", [198]), 0); |
| |
| // memory_copy.wast:2161 |
| assert_return(() => call($14, "load8_u", [397]), 0); |
| |
| // memory_copy.wast:2162 |
| assert_return(() => call($14, "load8_u", [596]), 0); |
| |
| // memory_copy.wast:2163 |
| assert_return(() => call($14, "load8_u", [795]), 0); |
| |
| // memory_copy.wast:2164 |
| assert_return(() => call($14, "load8_u", [994]), 0); |
| |
| // memory_copy.wast:2165 |
| assert_return(() => call($14, "load8_u", [1_193]), 0); |
| |
| // memory_copy.wast:2166 |
| assert_return(() => call($14, "load8_u", [1_392]), 0); |
| |
| // memory_copy.wast:2167 |
| assert_return(() => call($14, "load8_u", [1_591]), 0); |
| |
| // memory_copy.wast:2168 |
| assert_return(() => call($14, "load8_u", [1_790]), 0); |
| |
| // memory_copy.wast:2169 |
| assert_return(() => call($14, "load8_u", [1_989]), 0); |
| |
| // memory_copy.wast:2170 |
| assert_return(() => call($14, "load8_u", [2_188]), 0); |
| |
| // memory_copy.wast:2171 |
| assert_return(() => call($14, "load8_u", [2_387]), 0); |
| |
| // memory_copy.wast:2172 |
| assert_return(() => call($14, "load8_u", [2_586]), 0); |
| |
| // memory_copy.wast:2173 |
| assert_return(() => call($14, "load8_u", [2_785]), 0); |
| |
| // memory_copy.wast:2174 |
| assert_return(() => call($14, "load8_u", [2_984]), 0); |
| |
| // memory_copy.wast:2175 |
| assert_return(() => call($14, "load8_u", [3_183]), 0); |
| |
| // memory_copy.wast:2176 |
| assert_return(() => call($14, "load8_u", [3_382]), 0); |
| |
| // memory_copy.wast:2177 |
| assert_return(() => call($14, "load8_u", [3_581]), 0); |
| |
| // memory_copy.wast:2178 |
| assert_return(() => call($14, "load8_u", [3_780]), 0); |
| |
| // memory_copy.wast:2179 |
| assert_return(() => call($14, "load8_u", [3_979]), 0); |
| |
| // memory_copy.wast:2180 |
| assert_return(() => call($14, "load8_u", [4_178]), 0); |
| |
| // memory_copy.wast:2181 |
| assert_return(() => call($14, "load8_u", [4_377]), 0); |
| |
| // memory_copy.wast:2182 |
| assert_return(() => call($14, "load8_u", [4_576]), 0); |
| |
| // memory_copy.wast:2183 |
| assert_return(() => call($14, "load8_u", [4_775]), 0); |
| |
| // memory_copy.wast:2184 |
| assert_return(() => call($14, "load8_u", [4_974]), 0); |
| |
| // memory_copy.wast:2185 |
| assert_return(() => call($14, "load8_u", [5_173]), 0); |
| |
| // memory_copy.wast:2186 |
| assert_return(() => call($14, "load8_u", [5_372]), 0); |
| |
| // memory_copy.wast:2187 |
| assert_return(() => call($14, "load8_u", [5_571]), 0); |
| |
| // memory_copy.wast:2188 |
| assert_return(() => call($14, "load8_u", [5_770]), 0); |
| |
| // memory_copy.wast:2189 |
| assert_return(() => call($14, "load8_u", [5_969]), 0); |
| |
| // memory_copy.wast:2190 |
| assert_return(() => call($14, "load8_u", [6_168]), 0); |
| |
| // memory_copy.wast:2191 |
| assert_return(() => call($14, "load8_u", [6_367]), 0); |
| |
| // memory_copy.wast:2192 |
| assert_return(() => call($14, "load8_u", [6_566]), 0); |
| |
| // memory_copy.wast:2193 |
| assert_return(() => call($14, "load8_u", [6_765]), 0); |
| |
| // memory_copy.wast:2194 |
| assert_return(() => call($14, "load8_u", [6_964]), 0); |
| |
| // memory_copy.wast:2195 |
| assert_return(() => call($14, "load8_u", [7_163]), 0); |
| |
| // memory_copy.wast:2196 |
| assert_return(() => call($14, "load8_u", [7_362]), 0); |
| |
| // memory_copy.wast:2197 |
| assert_return(() => call($14, "load8_u", [7_561]), 0); |
| |
| // memory_copy.wast:2198 |
| assert_return(() => call($14, "load8_u", [7_760]), 0); |
| |
| // memory_copy.wast:2199 |
| assert_return(() => call($14, "load8_u", [7_959]), 0); |
| |
| // memory_copy.wast:2200 |
| assert_return(() => call($14, "load8_u", [8_158]), 0); |
| |
| // memory_copy.wast:2201 |
| assert_return(() => call($14, "load8_u", [8_357]), 0); |
| |
| // memory_copy.wast:2202 |
| assert_return(() => call($14, "load8_u", [8_556]), 0); |
| |
| // memory_copy.wast:2203 |
| assert_return(() => call($14, "load8_u", [8_755]), 0); |
| |
| // memory_copy.wast:2204 |
| assert_return(() => call($14, "load8_u", [8_954]), 0); |
| |
| // memory_copy.wast:2205 |
| assert_return(() => call($14, "load8_u", [9_153]), 0); |
| |
| // memory_copy.wast:2206 |
| assert_return(() => call($14, "load8_u", [9_352]), 0); |
| |
| // memory_copy.wast:2207 |
| assert_return(() => call($14, "load8_u", [9_551]), 0); |
| |
| // memory_copy.wast:2208 |
| assert_return(() => call($14, "load8_u", [9_750]), 0); |
| |
| // memory_copy.wast:2209 |
| assert_return(() => call($14, "load8_u", [9_949]), 0); |
| |
| // memory_copy.wast:2210 |
| assert_return(() => call($14, "load8_u", [10_148]), 0); |
| |
| // memory_copy.wast:2211 |
| assert_return(() => call($14, "load8_u", [10_347]), 0); |
| |
| // memory_copy.wast:2212 |
| assert_return(() => call($14, "load8_u", [10_546]), 0); |
| |
| // memory_copy.wast:2213 |
| assert_return(() => call($14, "load8_u", [10_745]), 0); |
| |
| // memory_copy.wast:2214 |
| assert_return(() => call($14, "load8_u", [10_944]), 0); |
| |
| // memory_copy.wast:2215 |
| assert_return(() => call($14, "load8_u", [11_143]), 0); |
| |
| // memory_copy.wast:2216 |
| assert_return(() => call($14, "load8_u", [11_342]), 0); |
| |
| // memory_copy.wast:2217 |
| assert_return(() => call($14, "load8_u", [11_541]), 0); |
| |
| // memory_copy.wast:2218 |
| assert_return(() => call($14, "load8_u", [11_740]), 0); |
| |
| // memory_copy.wast:2219 |
| assert_return(() => call($14, "load8_u", [11_939]), 0); |
| |
| // memory_copy.wast:2220 |
| assert_return(() => call($14, "load8_u", [12_138]), 0); |
| |
| // memory_copy.wast:2221 |
| assert_return(() => call($14, "load8_u", [12_337]), 0); |
| |
| // memory_copy.wast:2222 |
| assert_return(() => call($14, "load8_u", [12_536]), 0); |
| |
| // memory_copy.wast:2223 |
| assert_return(() => call($14, "load8_u", [12_735]), 0); |
| |
| // memory_copy.wast:2224 |
| assert_return(() => call($14, "load8_u", [12_934]), 0); |
| |
| // memory_copy.wast:2225 |
| assert_return(() => call($14, "load8_u", [13_133]), 0); |
| |
| // memory_copy.wast:2226 |
| assert_return(() => call($14, "load8_u", [13_332]), 0); |
| |
| // memory_copy.wast:2227 |
| assert_return(() => call($14, "load8_u", [13_531]), 0); |
| |
| // memory_copy.wast:2228 |
| assert_return(() => call($14, "load8_u", [13_730]), 0); |
| |
| // memory_copy.wast:2229 |
| assert_return(() => call($14, "load8_u", [13_929]), 0); |
| |
| // memory_copy.wast:2230 |
| assert_return(() => call($14, "load8_u", [14_128]), 0); |
| |
| // memory_copy.wast:2231 |
| assert_return(() => call($14, "load8_u", [14_327]), 0); |
| |
| // memory_copy.wast:2232 |
| assert_return(() => call($14, "load8_u", [14_526]), 0); |
| |
| // memory_copy.wast:2233 |
| assert_return(() => call($14, "load8_u", [14_725]), 0); |
| |
| // memory_copy.wast:2234 |
| assert_return(() => call($14, "load8_u", [14_924]), 0); |
| |
| // memory_copy.wast:2235 |
| assert_return(() => call($14, "load8_u", [15_123]), 0); |
| |
| // memory_copy.wast:2236 |
| assert_return(() => call($14, "load8_u", [15_322]), 0); |
| |
| // memory_copy.wast:2237 |
| assert_return(() => call($14, "load8_u", [15_521]), 0); |
| |
| // memory_copy.wast:2238 |
| assert_return(() => call($14, "load8_u", [15_720]), 0); |
| |
| // memory_copy.wast:2239 |
| assert_return(() => call($14, "load8_u", [15_919]), 0); |
| |
| // memory_copy.wast:2240 |
| assert_return(() => call($14, "load8_u", [16_118]), 0); |
| |
| // memory_copy.wast:2241 |
| assert_return(() => call($14, "load8_u", [16_317]), 0); |
| |
| // memory_copy.wast:2242 |
| assert_return(() => call($14, "load8_u", [16_516]), 0); |
| |
| // memory_copy.wast:2243 |
| assert_return(() => call($14, "load8_u", [16_715]), 0); |
| |
| // memory_copy.wast:2244 |
| assert_return(() => call($14, "load8_u", [16_914]), 0); |
| |
| // memory_copy.wast:2245 |
| assert_return(() => call($14, "load8_u", [17_113]), 0); |
| |
| // memory_copy.wast:2246 |
| assert_return(() => call($14, "load8_u", [17_312]), 0); |
| |
| // memory_copy.wast:2247 |
| assert_return(() => call($14, "load8_u", [17_511]), 0); |
| |
| // memory_copy.wast:2248 |
| assert_return(() => call($14, "load8_u", [17_710]), 0); |
| |
| // memory_copy.wast:2249 |
| assert_return(() => call($14, "load8_u", [17_909]), 0); |
| |
| // memory_copy.wast:2250 |
| assert_return(() => call($14, "load8_u", [18_108]), 0); |
| |
| // memory_copy.wast:2251 |
| assert_return(() => call($14, "load8_u", [18_307]), 0); |
| |
| // memory_copy.wast:2252 |
| assert_return(() => call($14, "load8_u", [18_506]), 0); |
| |
| // memory_copy.wast:2253 |
| assert_return(() => call($14, "load8_u", [18_705]), 0); |
| |
| // memory_copy.wast:2254 |
| assert_return(() => call($14, "load8_u", [18_904]), 0); |
| |
| // memory_copy.wast:2255 |
| assert_return(() => call($14, "load8_u", [19_103]), 0); |
| |
| // memory_copy.wast:2256 |
| assert_return(() => call($14, "load8_u", [19_302]), 0); |
| |
| // memory_copy.wast:2257 |
| assert_return(() => call($14, "load8_u", [19_501]), 0); |
| |
| // memory_copy.wast:2258 |
| assert_return(() => call($14, "load8_u", [19_700]), 0); |
| |
| // memory_copy.wast:2259 |
| assert_return(() => call($14, "load8_u", [19_899]), 0); |
| |
| // memory_copy.wast:2260 |
| assert_return(() => call($14, "load8_u", [20_098]), 0); |
| |
| // memory_copy.wast:2261 |
| assert_return(() => call($14, "load8_u", [20_297]), 0); |
| |
| // memory_copy.wast:2262 |
| assert_return(() => call($14, "load8_u", [20_496]), 0); |
| |
| // memory_copy.wast:2263 |
| assert_return(() => call($14, "load8_u", [20_695]), 0); |
| |
| // memory_copy.wast:2264 |
| assert_return(() => call($14, "load8_u", [20_894]), 0); |
| |
| // memory_copy.wast:2265 |
| assert_return(() => call($14, "load8_u", [21_093]), 0); |
| |
| // memory_copy.wast:2266 |
| assert_return(() => call($14, "load8_u", [21_292]), 0); |
| |
| // memory_copy.wast:2267 |
| assert_return(() => call($14, "load8_u", [21_491]), 0); |
| |
| // memory_copy.wast:2268 |
| assert_return(() => call($14, "load8_u", [21_690]), 0); |
| |
| // memory_copy.wast:2269 |
| assert_return(() => call($14, "load8_u", [21_889]), 0); |
| |
| // memory_copy.wast:2270 |
| assert_return(() => call($14, "load8_u", [22_088]), 0); |
| |
| // memory_copy.wast:2271 |
| assert_return(() => call($14, "load8_u", [22_287]), 0); |
| |
| // memory_copy.wast:2272 |
| assert_return(() => call($14, "load8_u", [22_486]), 0); |
| |
| // memory_copy.wast:2273 |
| assert_return(() => call($14, "load8_u", [22_685]), 0); |
| |
| // memory_copy.wast:2274 |
| assert_return(() => call($14, "load8_u", [22_884]), 0); |
| |
| // memory_copy.wast:2275 |
| assert_return(() => call($14, "load8_u", [23_083]), 0); |
| |
| // memory_copy.wast:2276 |
| assert_return(() => call($14, "load8_u", [23_282]), 0); |
| |
| // memory_copy.wast:2277 |
| assert_return(() => call($14, "load8_u", [23_481]), 0); |
| |
| // memory_copy.wast:2278 |
| assert_return(() => call($14, "load8_u", [23_680]), 0); |
| |
| // memory_copy.wast:2279 |
| assert_return(() => call($14, "load8_u", [23_879]), 0); |
| |
| // memory_copy.wast:2280 |
| assert_return(() => call($14, "load8_u", [24_078]), 0); |
| |
| // memory_copy.wast:2281 |
| assert_return(() => call($14, "load8_u", [24_277]), 0); |
| |
| // memory_copy.wast:2282 |
| assert_return(() => call($14, "load8_u", [24_476]), 0); |
| |
| // memory_copy.wast:2283 |
| assert_return(() => call($14, "load8_u", [24_675]), 0); |
| |
| // memory_copy.wast:2284 |
| assert_return(() => call($14, "load8_u", [24_874]), 0); |
| |
| // memory_copy.wast:2285 |
| assert_return(() => call($14, "load8_u", [25_073]), 0); |
| |
| // memory_copy.wast:2286 |
| assert_return(() => call($14, "load8_u", [25_272]), 0); |
| |
| // memory_copy.wast:2287 |
| assert_return(() => call($14, "load8_u", [25_471]), 0); |
| |
| // memory_copy.wast:2288 |
| assert_return(() => call($14, "load8_u", [25_670]), 0); |
| |
| // memory_copy.wast:2289 |
| assert_return(() => call($14, "load8_u", [25_869]), 0); |
| |
| // memory_copy.wast:2290 |
| assert_return(() => call($14, "load8_u", [26_068]), 0); |
| |
| // memory_copy.wast:2291 |
| assert_return(() => call($14, "load8_u", [26_267]), 0); |
| |
| // memory_copy.wast:2292 |
| assert_return(() => call($14, "load8_u", [26_466]), 0); |
| |
| // memory_copy.wast:2293 |
| assert_return(() => call($14, "load8_u", [26_665]), 0); |
| |
| // memory_copy.wast:2294 |
| assert_return(() => call($14, "load8_u", [26_864]), 0); |
| |
| // memory_copy.wast:2295 |
| assert_return(() => call($14, "load8_u", [27_063]), 0); |
| |
| // memory_copy.wast:2296 |
| assert_return(() => call($14, "load8_u", [27_262]), 0); |
| |
| // memory_copy.wast:2297 |
| assert_return(() => call($14, "load8_u", [27_461]), 0); |
| |
| // memory_copy.wast:2298 |
| assert_return(() => call($14, "load8_u", [27_660]), 0); |
| |
| // memory_copy.wast:2299 |
| assert_return(() => call($14, "load8_u", [27_859]), 0); |
| |
| // memory_copy.wast:2300 |
| assert_return(() => call($14, "load8_u", [28_058]), 0); |
| |
| // memory_copy.wast:2301 |
| assert_return(() => call($14, "load8_u", [28_257]), 0); |
| |
| // memory_copy.wast:2302 |
| assert_return(() => call($14, "load8_u", [28_456]), 0); |
| |
| // memory_copy.wast:2303 |
| assert_return(() => call($14, "load8_u", [28_655]), 0); |
| |
| // memory_copy.wast:2304 |
| assert_return(() => call($14, "load8_u", [28_854]), 0); |
| |
| // memory_copy.wast:2305 |
| assert_return(() => call($14, "load8_u", [29_053]), 0); |
| |
| // memory_copy.wast:2306 |
| assert_return(() => call($14, "load8_u", [29_252]), 0); |
| |
| // memory_copy.wast:2307 |
| assert_return(() => call($14, "load8_u", [29_451]), 0); |
| |
| // memory_copy.wast:2308 |
| assert_return(() => call($14, "load8_u", [29_650]), 0); |
| |
| // memory_copy.wast:2309 |
| assert_return(() => call($14, "load8_u", [29_849]), 0); |
| |
| // memory_copy.wast:2310 |
| assert_return(() => call($14, "load8_u", [30_048]), 0); |
| |
| // memory_copy.wast:2311 |
| assert_return(() => call($14, "load8_u", [30_247]), 0); |
| |
| // memory_copy.wast:2312 |
| assert_return(() => call($14, "load8_u", [30_446]), 0); |
| |
| // memory_copy.wast:2313 |
| assert_return(() => call($14, "load8_u", [30_645]), 0); |
| |
| // memory_copy.wast:2314 |
| assert_return(() => call($14, "load8_u", [30_844]), 0); |
| |
| // memory_copy.wast:2315 |
| assert_return(() => call($14, "load8_u", [31_043]), 0); |
| |
| // memory_copy.wast:2316 |
| assert_return(() => call($14, "load8_u", [31_242]), 0); |
| |
| // memory_copy.wast:2317 |
| assert_return(() => call($14, "load8_u", [31_441]), 0); |
| |
| // memory_copy.wast:2318 |
| assert_return(() => call($14, "load8_u", [31_640]), 0); |
| |
| // memory_copy.wast:2319 |
| assert_return(() => call($14, "load8_u", [31_839]), 0); |
| |
| // memory_copy.wast:2320 |
| assert_return(() => call($14, "load8_u", [32_038]), 0); |
| |
| // memory_copy.wast:2321 |
| assert_return(() => call($14, "load8_u", [32_237]), 0); |
| |
| // memory_copy.wast:2322 |
| assert_return(() => call($14, "load8_u", [32_436]), 0); |
| |
| // memory_copy.wast:2323 |
| assert_return(() => call($14, "load8_u", [32_635]), 0); |
| |
| // memory_copy.wast:2324 |
| assert_return(() => call($14, "load8_u", [32_834]), 0); |
| |
| // memory_copy.wast:2325 |
| assert_return(() => call($14, "load8_u", [33_033]), 0); |
| |
| // memory_copy.wast:2326 |
| assert_return(() => call($14, "load8_u", [33_232]), 0); |
| |
| // memory_copy.wast:2327 |
| assert_return(() => call($14, "load8_u", [33_431]), 0); |
| |
| // memory_copy.wast:2328 |
| assert_return(() => call($14, "load8_u", [33_630]), 0); |
| |
| // memory_copy.wast:2329 |
| assert_return(() => call($14, "load8_u", [33_829]), 0); |
| |
| // memory_copy.wast:2330 |
| assert_return(() => call($14, "load8_u", [34_028]), 0); |
| |
| // memory_copy.wast:2331 |
| assert_return(() => call($14, "load8_u", [34_227]), 0); |
| |
| // memory_copy.wast:2332 |
| assert_return(() => call($14, "load8_u", [34_426]), 0); |
| |
| // memory_copy.wast:2333 |
| assert_return(() => call($14, "load8_u", [34_625]), 0); |
| |
| // memory_copy.wast:2334 |
| assert_return(() => call($14, "load8_u", [34_824]), 0); |
| |
| // memory_copy.wast:2335 |
| assert_return(() => call($14, "load8_u", [35_023]), 0); |
| |
| // memory_copy.wast:2336 |
| assert_return(() => call($14, "load8_u", [35_222]), 0); |
| |
| // memory_copy.wast:2337 |
| assert_return(() => call($14, "load8_u", [35_421]), 0); |
| |
| // memory_copy.wast:2338 |
| assert_return(() => call($14, "load8_u", [35_620]), 0); |
| |
| // memory_copy.wast:2339 |
| assert_return(() => call($14, "load8_u", [35_819]), 0); |
| |
| // memory_copy.wast:2340 |
| assert_return(() => call($14, "load8_u", [36_018]), 0); |
| |
| // memory_copy.wast:2341 |
| assert_return(() => call($14, "load8_u", [36_217]), 0); |
| |
| // memory_copy.wast:2342 |
| assert_return(() => call($14, "load8_u", [36_416]), 0); |
| |
| // memory_copy.wast:2343 |
| assert_return(() => call($14, "load8_u", [36_615]), 0); |
| |
| // memory_copy.wast:2344 |
| assert_return(() => call($14, "load8_u", [36_814]), 0); |
| |
| // memory_copy.wast:2345 |
| assert_return(() => call($14, "load8_u", [37_013]), 0); |
| |
| // memory_copy.wast:2346 |
| assert_return(() => call($14, "load8_u", [37_212]), 0); |
| |
| // memory_copy.wast:2347 |
| assert_return(() => call($14, "load8_u", [37_411]), 0); |
| |
| // memory_copy.wast:2348 |
| assert_return(() => call($14, "load8_u", [37_610]), 0); |
| |
| // memory_copy.wast:2349 |
| assert_return(() => call($14, "load8_u", [37_809]), 0); |
| |
| // memory_copy.wast:2350 |
| assert_return(() => call($14, "load8_u", [38_008]), 0); |
| |
| // memory_copy.wast:2351 |
| assert_return(() => call($14, "load8_u", [38_207]), 0); |
| |
| // memory_copy.wast:2352 |
| assert_return(() => call($14, "load8_u", [38_406]), 0); |
| |
| // memory_copy.wast:2353 |
| assert_return(() => call($14, "load8_u", [38_605]), 0); |
| |
| // memory_copy.wast:2354 |
| assert_return(() => call($14, "load8_u", [38_804]), 0); |
| |
| // memory_copy.wast:2355 |
| assert_return(() => call($14, "load8_u", [39_003]), 0); |
| |
| // memory_copy.wast:2356 |
| assert_return(() => call($14, "load8_u", [39_202]), 0); |
| |
| // memory_copy.wast:2357 |
| assert_return(() => call($14, "load8_u", [39_401]), 0); |
| |
| // memory_copy.wast:2358 |
| assert_return(() => call($14, "load8_u", [39_600]), 0); |
| |
| // memory_copy.wast:2359 |
| assert_return(() => call($14, "load8_u", [39_799]), 0); |
| |
| // memory_copy.wast:2360 |
| assert_return(() => call($14, "load8_u", [39_998]), 0); |
| |
| // memory_copy.wast:2361 |
| assert_return(() => call($14, "load8_u", [40_197]), 0); |
| |
| // memory_copy.wast:2362 |
| assert_return(() => call($14, "load8_u", [40_396]), 0); |
| |
| // memory_copy.wast:2363 |
| assert_return(() => call($14, "load8_u", [40_595]), 0); |
| |
| // memory_copy.wast:2364 |
| assert_return(() => call($14, "load8_u", [40_794]), 0); |
| |
| // memory_copy.wast:2365 |
| assert_return(() => call($14, "load8_u", [40_993]), 0); |
| |
| // memory_copy.wast:2366 |
| assert_return(() => call($14, "load8_u", [41_192]), 0); |
| |
| // memory_copy.wast:2367 |
| assert_return(() => call($14, "load8_u", [41_391]), 0); |
| |
| // memory_copy.wast:2368 |
| assert_return(() => call($14, "load8_u", [41_590]), 0); |
| |
| // memory_copy.wast:2369 |
| assert_return(() => call($14, "load8_u", [41_789]), 0); |
| |
| // memory_copy.wast:2370 |
| assert_return(() => call($14, "load8_u", [41_988]), 0); |
| |
| // memory_copy.wast:2371 |
| assert_return(() => call($14, "load8_u", [42_187]), 0); |
| |
| // memory_copy.wast:2372 |
| assert_return(() => call($14, "load8_u", [42_386]), 0); |
| |
| // memory_copy.wast:2373 |
| assert_return(() => call($14, "load8_u", [42_585]), 0); |
| |
| // memory_copy.wast:2374 |
| assert_return(() => call($14, "load8_u", [42_784]), 0); |
| |
| // memory_copy.wast:2375 |
| assert_return(() => call($14, "load8_u", [42_983]), 0); |
| |
| // memory_copy.wast:2376 |
| assert_return(() => call($14, "load8_u", [43_182]), 0); |
| |
| // memory_copy.wast:2377 |
| assert_return(() => call($14, "load8_u", [43_381]), 0); |
| |
| // memory_copy.wast:2378 |
| assert_return(() => call($14, "load8_u", [43_580]), 0); |
| |
| // memory_copy.wast:2379 |
| assert_return(() => call($14, "load8_u", [43_779]), 0); |
| |
| // memory_copy.wast:2380 |
| assert_return(() => call($14, "load8_u", [43_978]), 0); |
| |
| // memory_copy.wast:2381 |
| assert_return(() => call($14, "load8_u", [44_177]), 0); |
| |
| // memory_copy.wast:2382 |
| assert_return(() => call($14, "load8_u", [44_376]), 0); |
| |
| // memory_copy.wast:2383 |
| assert_return(() => call($14, "load8_u", [44_575]), 0); |
| |
| // memory_copy.wast:2384 |
| assert_return(() => call($14, "load8_u", [44_774]), 0); |
| |
| // memory_copy.wast:2385 |
| assert_return(() => call($14, "load8_u", [44_973]), 0); |
| |
| // memory_copy.wast:2386 |
| assert_return(() => call($14, "load8_u", [45_172]), 0); |
| |
| // memory_copy.wast:2387 |
| assert_return(() => call($14, "load8_u", [45_371]), 0); |
| |
| // memory_copy.wast:2388 |
| assert_return(() => call($14, "load8_u", [45_570]), 0); |
| |
| // memory_copy.wast:2389 |
| assert_return(() => call($14, "load8_u", [45_769]), 0); |
| |
| // memory_copy.wast:2390 |
| assert_return(() => call($14, "load8_u", [45_968]), 0); |
| |
| // memory_copy.wast:2391 |
| assert_return(() => call($14, "load8_u", [46_167]), 0); |
| |
| // memory_copy.wast:2392 |
| assert_return(() => call($14, "load8_u", [46_366]), 0); |
| |
| // memory_copy.wast:2393 |
| assert_return(() => call($14, "load8_u", [46_565]), 0); |
| |
| // memory_copy.wast:2394 |
| assert_return(() => call($14, "load8_u", [46_764]), 0); |
| |
| // memory_copy.wast:2395 |
| assert_return(() => call($14, "load8_u", [46_963]), 0); |
| |
| // memory_copy.wast:2396 |
| assert_return(() => call($14, "load8_u", [47_162]), 0); |
| |
| // memory_copy.wast:2397 |
| assert_return(() => call($14, "load8_u", [47_361]), 0); |
| |
| // memory_copy.wast:2398 |
| assert_return(() => call($14, "load8_u", [47_560]), 0); |
| |
| // memory_copy.wast:2399 |
| assert_return(() => call($14, "load8_u", [47_759]), 0); |
| |
| // memory_copy.wast:2400 |
| assert_return(() => call($14, "load8_u", [47_958]), 0); |
| |
| // memory_copy.wast:2401 |
| assert_return(() => call($14, "load8_u", [48_157]), 0); |
| |
| // memory_copy.wast:2402 |
| assert_return(() => call($14, "load8_u", [48_356]), 0); |
| |
| // memory_copy.wast:2403 |
| assert_return(() => call($14, "load8_u", [48_555]), 0); |
| |
| // memory_copy.wast:2404 |
| assert_return(() => call($14, "load8_u", [48_754]), 0); |
| |
| // memory_copy.wast:2405 |
| assert_return(() => call($14, "load8_u", [48_953]), 0); |
| |
| // memory_copy.wast:2406 |
| assert_return(() => call($14, "load8_u", [49_152]), 0); |
| |
| // memory_copy.wast:2407 |
| assert_return(() => call($14, "load8_u", [49_351]), 0); |
| |
| // memory_copy.wast:2408 |
| assert_return(() => call($14, "load8_u", [49_550]), 0); |
| |
| // memory_copy.wast:2409 |
| assert_return(() => call($14, "load8_u", [49_749]), 0); |
| |
| // memory_copy.wast:2410 |
| assert_return(() => call($14, "load8_u", [49_948]), 0); |
| |
| // memory_copy.wast:2411 |
| assert_return(() => call($14, "load8_u", [50_147]), 0); |
| |
| // memory_copy.wast:2412 |
| assert_return(() => call($14, "load8_u", [50_346]), 0); |
| |
| // memory_copy.wast:2413 |
| assert_return(() => call($14, "load8_u", [50_545]), 0); |
| |
| // memory_copy.wast:2414 |
| assert_return(() => call($14, "load8_u", [50_744]), 0); |
| |
| // memory_copy.wast:2415 |
| assert_return(() => call($14, "load8_u", [50_943]), 0); |
| |
| // memory_copy.wast:2416 |
| assert_return(() => call($14, "load8_u", [51_142]), 0); |
| |
| // memory_copy.wast:2417 |
| assert_return(() => call($14, "load8_u", [51_341]), 0); |
| |
| // memory_copy.wast:2418 |
| assert_return(() => call($14, "load8_u", [51_540]), 0); |
| |
| // memory_copy.wast:2419 |
| assert_return(() => call($14, "load8_u", [51_739]), 0); |
| |
| // memory_copy.wast:2420 |
| assert_return(() => call($14, "load8_u", [51_938]), 0); |
| |
| // memory_copy.wast:2421 |
| assert_return(() => call($14, "load8_u", [52_137]), 0); |
| |
| // memory_copy.wast:2422 |
| assert_return(() => call($14, "load8_u", [52_336]), 0); |
| |
| // memory_copy.wast:2423 |
| assert_return(() => call($14, "load8_u", [52_535]), 0); |
| |
| // memory_copy.wast:2424 |
| assert_return(() => call($14, "load8_u", [52_734]), 0); |
| |
| // memory_copy.wast:2425 |
| assert_return(() => call($14, "load8_u", [52_933]), 0); |
| |
| // memory_copy.wast:2426 |
| assert_return(() => call($14, "load8_u", [53_132]), 0); |
| |
| // memory_copy.wast:2427 |
| assert_return(() => call($14, "load8_u", [53_331]), 0); |
| |
| // memory_copy.wast:2428 |
| assert_return(() => call($14, "load8_u", [53_530]), 0); |
| |
| // memory_copy.wast:2429 |
| assert_return(() => call($14, "load8_u", [53_729]), 0); |
| |
| // memory_copy.wast:2430 |
| assert_return(() => call($14, "load8_u", [53_928]), 0); |
| |
| // memory_copy.wast:2431 |
| assert_return(() => call($14, "load8_u", [54_127]), 0); |
| |
| // memory_copy.wast:2432 |
| assert_return(() => call($14, "load8_u", [54_326]), 0); |
| |
| // memory_copy.wast:2433 |
| assert_return(() => call($14, "load8_u", [54_525]), 0); |
| |
| // memory_copy.wast:2434 |
| assert_return(() => call($14, "load8_u", [54_724]), 0); |
| |
| // memory_copy.wast:2435 |
| assert_return(() => call($14, "load8_u", [54_923]), 0); |
| |
| // memory_copy.wast:2436 |
| assert_return(() => call($14, "load8_u", [55_122]), 0); |
| |
| // memory_copy.wast:2437 |
| assert_return(() => call($14, "load8_u", [55_321]), 0); |
| |
| // memory_copy.wast:2438 |
| assert_return(() => call($14, "load8_u", [55_520]), 0); |
| |
| // memory_copy.wast:2439 |
| assert_return(() => call($14, "load8_u", [55_719]), 0); |
| |
| // memory_copy.wast:2440 |
| assert_return(() => call($14, "load8_u", [55_918]), 0); |
| |
| // memory_copy.wast:2441 |
| assert_return(() => call($14, "load8_u", [56_117]), 0); |
| |
| // memory_copy.wast:2442 |
| assert_return(() => call($14, "load8_u", [56_316]), 0); |
| |
| // memory_copy.wast:2443 |
| assert_return(() => call($14, "load8_u", [56_515]), 0); |
| |
| // memory_copy.wast:2444 |
| assert_return(() => call($14, "load8_u", [56_714]), 0); |
| |
| // memory_copy.wast:2445 |
| assert_return(() => call($14, "load8_u", [56_913]), 0); |
| |
| // memory_copy.wast:2446 |
| assert_return(() => call($14, "load8_u", [57_112]), 0); |
| |
| // memory_copy.wast:2447 |
| assert_return(() => call($14, "load8_u", [57_311]), 0); |
| |
| // memory_copy.wast:2448 |
| assert_return(() => call($14, "load8_u", [57_510]), 0); |
| |
| // memory_copy.wast:2449 |
| assert_return(() => call($14, "load8_u", [57_709]), 0); |
| |
| // memory_copy.wast:2450 |
| assert_return(() => call($14, "load8_u", [57_908]), 0); |
| |
| // memory_copy.wast:2451 |
| assert_return(() => call($14, "load8_u", [58_107]), 0); |
| |
| // memory_copy.wast:2452 |
| assert_return(() => call($14, "load8_u", [58_306]), 0); |
| |
| // memory_copy.wast:2453 |
| assert_return(() => call($14, "load8_u", [58_505]), 0); |
| |
| // memory_copy.wast:2454 |
| assert_return(() => call($14, "load8_u", [58_704]), 0); |
| |
| // memory_copy.wast:2455 |
| assert_return(() => call($14, "load8_u", [58_903]), 0); |
| |
| // memory_copy.wast:2456 |
| assert_return(() => call($14, "load8_u", [59_102]), 0); |
| |
| // memory_copy.wast:2457 |
| assert_return(() => call($14, "load8_u", [59_301]), 0); |
| |
| // memory_copy.wast:2458 |
| assert_return(() => call($14, "load8_u", [59_500]), 0); |
| |
| // memory_copy.wast:2459 |
| assert_return(() => call($14, "load8_u", [59_699]), 0); |
| |
| // memory_copy.wast:2460 |
| assert_return(() => call($14, "load8_u", [59_898]), 0); |
| |
| // memory_copy.wast:2461 |
| assert_return(() => call($14, "load8_u", [60_097]), 0); |
| |
| // memory_copy.wast:2462 |
| assert_return(() => call($14, "load8_u", [60_296]), 0); |
| |
| // memory_copy.wast:2463 |
| assert_return(() => call($14, "load8_u", [60_495]), 0); |
| |
| // memory_copy.wast:2464 |
| assert_return(() => call($14, "load8_u", [60_694]), 0); |
| |
| // memory_copy.wast:2465 |
| assert_return(() => call($14, "load8_u", [60_893]), 0); |
| |
| // memory_copy.wast:2466 |
| assert_return(() => call($14, "load8_u", [61_092]), 0); |
| |
| // memory_copy.wast:2467 |
| assert_return(() => call($14, "load8_u", [61_291]), 0); |
| |
| // memory_copy.wast:2468 |
| assert_return(() => call($14, "load8_u", [61_490]), 0); |
| |
| // memory_copy.wast:2469 |
| assert_return(() => call($14, "load8_u", [61_689]), 0); |
| |
| // memory_copy.wast:2470 |
| assert_return(() => call($14, "load8_u", [61_888]), 0); |
| |
| // memory_copy.wast:2471 |
| assert_return(() => call($14, "load8_u", [62_087]), 0); |
| |
| // memory_copy.wast:2472 |
| assert_return(() => call($14, "load8_u", [62_286]), 0); |
| |
| // memory_copy.wast:2473 |
| assert_return(() => call($14, "load8_u", [62_485]), 0); |
| |
| // memory_copy.wast:2474 |
| assert_return(() => call($14, "load8_u", [62_684]), 0); |
| |
| // memory_copy.wast:2475 |
| assert_return(() => call($14, "load8_u", [62_883]), 0); |
| |
| // memory_copy.wast:2476 |
| assert_return(() => call($14, "load8_u", [63_082]), 0); |
| |
| // memory_copy.wast:2477 |
| assert_return(() => call($14, "load8_u", [63_281]), 0); |
| |
| // memory_copy.wast:2478 |
| assert_return(() => call($14, "load8_u", [63_480]), 0); |
| |
| // memory_copy.wast:2479 |
| assert_return(() => call($14, "load8_u", [63_679]), 0); |
| |
| // memory_copy.wast:2480 |
| assert_return(() => call($14, "load8_u", [63_878]), 0); |
| |
| // memory_copy.wast:2481 |
| assert_return(() => call($14, "load8_u", [64_077]), 0); |
| |
| // memory_copy.wast:2482 |
| assert_return(() => call($14, "load8_u", [64_276]), 0); |
| |
| // memory_copy.wast:2483 |
| assert_return(() => call($14, "load8_u", [64_475]), 0); |
| |
| // memory_copy.wast:2484 |
| assert_return(() => call($14, "load8_u", [64_674]), 0); |
| |
| // memory_copy.wast:2485 |
| assert_return(() => call($14, "load8_u", [64_873]), 0); |
| |
| // memory_copy.wast:2486 |
| assert_return(() => call($14, "load8_u", [65_072]), 0); |
| |
| // memory_copy.wast:2487 |
| assert_return(() => call($14, "load8_u", [65_271]), 0); |
| |
| // memory_copy.wast:2488 |
| assert_return(() => call($14, "load8_u", [65_470]), 0); |
| |
| // memory_copy.wast:2489 |
| assert_return(() => call($14, "load8_u", [65_516]), 0); |
| |
| // memory_copy.wast:2490 |
| assert_return(() => call($14, "load8_u", [65_517]), 1); |
| |
| // memory_copy.wast:2491 |
| assert_return(() => call($14, "load8_u", [65_518]), 2); |
| |
| // memory_copy.wast:2492 |
| assert_return(() => call($14, "load8_u", [65_519]), 3); |
| |
| // memory_copy.wast:2493 |
| assert_return(() => call($14, "load8_u", [65_520]), 4); |
| |
| // memory_copy.wast:2494 |
| assert_return(() => call($14, "load8_u", [65_521]), 5); |
| |
| // memory_copy.wast:2495 |
| assert_return(() => call($14, "load8_u", [65_522]), 6); |
| |
| // memory_copy.wast:2496 |
| assert_return(() => call($14, "load8_u", [65_523]), 7); |
| |
| // memory_copy.wast:2497 |
| assert_return(() => call($14, "load8_u", [65_524]), 8); |
| |
| // memory_copy.wast:2498 |
| assert_return(() => call($14, "load8_u", [65_525]), 9); |
| |
| // memory_copy.wast:2499 |
| assert_return(() => call($14, "load8_u", [65_526]), 10); |
| |
| // memory_copy.wast:2500 |
| assert_return(() => call($14, "load8_u", [65_527]), 11); |
| |
| // memory_copy.wast:2501 |
| assert_return(() => call($14, "load8_u", [65_528]), 12); |
| |
| // memory_copy.wast:2502 |
| assert_return(() => call($14, "load8_u", [65_529]), 13); |
| |
| // memory_copy.wast:2503 |
| assert_return(() => call($14, "load8_u", [65_530]), 14); |
| |
| // memory_copy.wast:2504 |
| assert_return(() => call($14, "load8_u", [65_531]), 15); |
| |
| // memory_copy.wast:2505 |
| assert_return(() => call($14, "load8_u", [65_532]), 16); |
| |
| // memory_copy.wast:2506 |
| assert_return(() => call($14, "load8_u", [65_533]), 17); |
| |
| // memory_copy.wast:2507 |
| assert_return(() => call($14, "load8_u", [65_534]), 18); |
| |
| // memory_copy.wast:2508 |
| assert_return(() => call($14, "load8_u", [65_535]), 19); |
| |
| // memory_copy.wast:2510 |
| 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:2518 |
| assert_trap(() => call($15, "run", [65_516, 65_506, 40])); |
| |
| // memory_copy.wast:2521 |
| assert_return(() => call($15, "load8_u", [198]), 0); |
| |
| // memory_copy.wast:2522 |
| assert_return(() => call($15, "load8_u", [397]), 0); |
| |
| // memory_copy.wast:2523 |
| assert_return(() => call($15, "load8_u", [596]), 0); |
| |
| // memory_copy.wast:2524 |
| assert_return(() => call($15, "load8_u", [795]), 0); |
| |
| // memory_copy.wast:2525 |
| assert_return(() => call($15, "load8_u", [994]), 0); |
| |
| // memory_copy.wast:2526 |
| assert_return(() => call($15, "load8_u", [1_193]), 0); |
| |
| // memory_copy.wast:2527 |
| assert_return(() => call($15, "load8_u", [1_392]), 0); |
| |
| // memory_copy.wast:2528 |
| assert_return(() => call($15, "load8_u", [1_591]), 0); |
| |
| // memory_copy.wast:2529 |
| assert_return(() => call($15, "load8_u", [1_790]), 0); |
| |
| // memory_copy.wast:2530 |
| assert_return(() => call($15, "load8_u", [1_989]), 0); |
| |
| // memory_copy.wast:2531 |
| assert_return(() => call($15, "load8_u", [2_188]), 0); |
| |
| // memory_copy.wast:2532 |
| assert_return(() => call($15, "load8_u", [2_387]), 0); |
| |
| // memory_copy.wast:2533 |
| assert_return(() => call($15, "load8_u", [2_586]), 0); |
| |
| // memory_copy.wast:2534 |
| assert_return(() => call($15, "load8_u", [2_785]), 0); |
| |
| // memory_copy.wast:2535 |
| assert_return(() => call($15, "load8_u", [2_984]), 0); |
| |
| // memory_copy.wast:2536 |
| assert_return(() => call($15, "load8_u", [3_183]), 0); |
| |
| // memory_copy.wast:2537 |
| assert_return(() => call($15, "load8_u", [3_382]), 0); |
| |
| // memory_copy.wast:2538 |
| assert_return(() => call($15, "load8_u", [3_581]), 0); |
| |
| // memory_copy.wast:2539 |
| assert_return(() => call($15, "load8_u", [3_780]), 0); |
| |
| // memory_copy.wast:2540 |
| assert_return(() => call($15, "load8_u", [3_979]), 0); |
| |
| // memory_copy.wast:2541 |
| assert_return(() => call($15, "load8_u", [4_178]), 0); |
| |
| // memory_copy.wast:2542 |
| assert_return(() => call($15, "load8_u", [4_377]), 0); |
| |
| // memory_copy.wast:2543 |
| assert_return(() => call($15, "load8_u", [4_576]), 0); |
| |
| // memory_copy.wast:2544 |
| assert_return(() => call($15, "load8_u", [4_775]), 0); |
| |
| // memory_copy.wast:2545 |
| assert_return(() => call($15, "load8_u", [4_974]), 0); |
| |
| // memory_copy.wast:2546 |
| assert_return(() => call($15, "load8_u", [5_173]), 0); |
| |
| // memory_copy.wast:2547 |
| assert_return(() => call($15, "load8_u", [5_372]), 0); |
| |
| // memory_copy.wast:2548 |
| assert_return(() => call($15, "load8_u", [5_571]), 0); |
| |
| // memory_copy.wast:2549 |
| assert_return(() => call($15, "load8_u", [5_770]), 0); |
| |
| // memory_copy.wast:2550 |
| assert_return(() => call($15, "load8_u", [5_969]), 0); |
| |
| // memory_copy.wast:2551 |
| assert_return(() => call($15, "load8_u", [6_168]), 0); |
| |
| // memory_copy.wast:2552 |
| assert_return(() => call($15, "load8_u", [6_367]), 0); |
| |
| // memory_copy.wast:2553 |
| assert_return(() => call($15, "load8_u", [6_566]), 0); |
| |
| // memory_copy.wast:2554 |
| assert_return(() => call($15, "load8_u", [6_765]), 0); |
| |
| // memory_copy.wast:2555 |
| assert_return(() => call($15, "load8_u", [6_964]), 0); |
| |
| // memory_copy.wast:2556 |
| assert_return(() => call($15, "load8_u", [7_163]), 0); |
| |
| // memory_copy.wast:2557 |
| assert_return(() => call($15, "load8_u", [7_362]), 0); |
| |
| // memory_copy.wast:2558 |
| assert_return(() => call($15, "load8_u", [7_561]), 0); |
| |
| // memory_copy.wast:2559 |
| assert_return(() => call($15, "load8_u", [7_760]), 0); |
| |
| // memory_copy.wast:2560 |
| assert_return(() => call($15, "load8_u", [7_959]), 0); |
| |
| // memory_copy.wast:2561 |
| assert_return(() => call($15, "load8_u", [8_158]), 0); |
| |
| // memory_copy.wast:2562 |
| assert_return(() => call($15, "load8_u", [8_357]), 0); |
| |
| // memory_copy.wast:2563 |
| assert_return(() => call($15, "load8_u", [8_556]), 0); |
| |
| // memory_copy.wast:2564 |
| assert_return(() => call($15, "load8_u", [8_755]), 0); |
| |
| // memory_copy.wast:2565 |
| assert_return(() => call($15, "load8_u", [8_954]), 0); |
| |
| // memory_copy.wast:2566 |
| assert_return(() => call($15, "load8_u", [9_153]), 0); |
| |
| // memory_copy.wast:2567 |
| assert_return(() => call($15, "load8_u", [9_352]), 0); |
| |
| // memory_copy.wast:2568 |
| assert_return(() => call($15, "load8_u", [9_551]), 0); |
| |
| // memory_copy.wast:2569 |
| assert_return(() => call($15, "load8_u", [9_750]), 0); |
| |
| // memory_copy.wast:2570 |
| assert_return(() => call($15, "load8_u", [9_949]), 0); |
| |
| // memory_copy.wast:2571 |
| assert_return(() => call($15, "load8_u", [10_148]), 0); |
| |
| // memory_copy.wast:2572 |
| assert_return(() => call($15, "load8_u", [10_347]), 0); |
| |
| // memory_copy.wast:2573 |
| assert_return(() => call($15, "load8_u", [10_546]), 0); |
| |
| // memory_copy.wast:2574 |
| assert_return(() => call($15, "load8_u", [10_745]), 0); |
| |
| // memory_copy.wast:2575 |
| assert_return(() => call($15, "load8_u", [10_944]), 0); |
| |
| // memory_copy.wast:2576 |
| assert_return(() => call($15, "load8_u", [11_143]), 0); |
| |
| // memory_copy.wast:2577 |
| assert_return(() => call($15, "load8_u", [11_342]), 0); |
| |
| // memory_copy.wast:2578 |
| assert_return(() => call($15, "load8_u", [11_541]), 0); |
| |
| // memory_copy.wast:2579 |
| assert_return(() => call($15, "load8_u", [11_740]), 0); |
| |
| // memory_copy.wast:2580 |
| assert_return(() => call($15, "load8_u", [11_939]), 0); |
| |
| // memory_copy.wast:2581 |
| assert_return(() => call($15, "load8_u", [12_138]), 0); |
| |
| // memory_copy.wast:2582 |
| assert_return(() => call($15, "load8_u", [12_337]), 0); |
| |
| // memory_copy.wast:2583 |
| assert_return(() => call($15, "load8_u", [12_536]), 0); |
| |
| // memory_copy.wast:2584 |
| assert_return(() => call($15, "load8_u", [12_735]), 0); |
| |
| // memory_copy.wast:2585 |
| assert_return(() => call($15, "load8_u", [12_934]), 0); |
| |
| // memory_copy.wast:2586 |
| assert_return(() => call($15, "load8_u", [13_133]), 0); |
| |
| // memory_copy.wast:2587 |
| assert_return(() => call($15, "load8_u", [13_332]), 0); |
| |
| // memory_copy.wast:2588 |
| assert_return(() => call($15, "load8_u", [13_531]), 0); |
| |
| // memory_copy.wast:2589 |
| assert_return(() => call($15, "load8_u", [13_730]), 0); |
| |
| // memory_copy.wast:2590 |
| assert_return(() => call($15, "load8_u", [13_929]), 0); |
| |
| // memory_copy.wast:2591 |
| assert_return(() => call($15, "load8_u", [14_128]), 0); |
| |
| // memory_copy.wast:2592 |
| assert_return(() => call($15, "load8_u", [14_327]), 0); |
| |
| // memory_copy.wast:2593 |
| assert_return(() => call($15, "load8_u", [14_526]), 0); |
| |
| // memory_copy.wast:2594 |
| assert_return(() => call($15, "load8_u", [14_725]), 0); |
| |
| // memory_copy.wast:2595 |
| assert_return(() => call($15, "load8_u", [14_924]), 0); |
| |
| // memory_copy.wast:2596 |
| assert_return(() => call($15, "load8_u", [15_123]), 0); |
| |
| // memory_copy.wast:2597 |
| assert_return(() => call($15, "load8_u", [15_322]), 0); |
| |
| // memory_copy.wast:2598 |
| assert_return(() => call($15, "load8_u", [15_521]), 0); |
| |
| // memory_copy.wast:2599 |
| assert_return(() => call($15, "load8_u", [15_720]), 0); |
| |
| // memory_copy.wast:2600 |
| assert_return(() => call($15, "load8_u", [15_919]), 0); |
| |
| // memory_copy.wast:2601 |
| assert_return(() => call($15, "load8_u", [16_118]), 0); |
| |
| // memory_copy.wast:2602 |
| assert_return(() => call($15, "load8_u", [16_317]), 0); |
| |
| // memory_copy.wast:2603 |
| assert_return(() => call($15, "load8_u", [16_516]), 0); |
| |
| // memory_copy.wast:2604 |
| assert_return(() => call($15, "load8_u", [16_715]), 0); |
| |
| // memory_copy.wast:2605 |
| assert_return(() => call($15, "load8_u", [16_914]), 0); |
| |
| // memory_copy.wast:2606 |
| assert_return(() => call($15, "load8_u", [17_113]), 0); |
| |
| // memory_copy.wast:2607 |
| assert_return(() => call($15, "load8_u", [17_312]), 0); |
| |
| // memory_copy.wast:2608 |
| assert_return(() => call($15, "load8_u", [17_511]), 0); |
| |
| // memory_copy.wast:2609 |
| assert_return(() => call($15, "load8_u", [17_710]), 0); |
| |
| // memory_copy.wast:2610 |
| assert_return(() => call($15, "load8_u", [17_909]), 0); |
| |
| // memory_copy.wast:2611 |
| assert_return(() => call($15, "load8_u", [18_108]), 0); |
| |
| // memory_copy.wast:2612 |
| assert_return(() => call($15, "load8_u", [18_307]), 0); |
| |
| // memory_copy.wast:2613 |
| assert_return(() => call($15, "load8_u", [18_506]), 0); |
| |
| // memory_copy.wast:2614 |
| assert_return(() => call($15, "load8_u", [18_705]), 0); |
| |
| // memory_copy.wast:2615 |
| assert_return(() => call($15, "load8_u", [18_904]), 0); |
| |
| // memory_copy.wast:2616 |
| assert_return(() => call($15, "load8_u", [19_103]), 0); |
| |
| // memory_copy.wast:2617 |
| assert_return(() => call($15, "load8_u", [19_302]), 0); |
| |
| // memory_copy.wast:2618 |
| assert_return(() => call($15, "load8_u", [19_501]), 0); |
| |
| // memory_copy.wast:2619 |
| assert_return(() => call($15, "load8_u", [19_700]), 0); |
| |
| // memory_copy.wast:2620 |
| assert_return(() => call($15, "load8_u", [19_899]), 0); |
| |
| // memory_copy.wast:2621 |
| assert_return(() => call($15, "load8_u", [20_098]), 0); |
| |
| // memory_copy.wast:2622 |
| assert_return(() => call($15, "load8_u", [20_297]), 0); |
| |
| // memory_copy.wast:2623 |
| assert_return(() => call($15, "load8_u", [20_496]), 0); |
| |
| // memory_copy.wast:2624 |
| assert_return(() => call($15, "load8_u", [20_695]), 0); |
| |
| // memory_copy.wast:2625 |
| assert_return(() => call($15, "load8_u", [20_894]), 0); |
| |
| // memory_copy.wast:2626 |
| assert_return(() => call($15, "load8_u", [21_093]), 0); |
| |
| // memory_copy.wast:2627 |
| assert_return(() => call($15, "load8_u", [21_292]), 0); |
| |
| // memory_copy.wast:2628 |
| assert_return(() => call($15, "load8_u", [21_491]), 0); |
| |
| // memory_copy.wast:2629 |
| assert_return(() => call($15, "load8_u", [21_690]), 0); |
| |
| // memory_copy.wast:2630 |
| assert_return(() => call($15, "load8_u", [21_889]), 0); |
| |
| // memory_copy.wast:2631 |
| assert_return(() => call($15, "load8_u", [22_088]), 0); |
| |
| // memory_copy.wast:2632 |
| assert_return(() => call($15, "load8_u", [22_287]), 0); |
| |
| // memory_copy.wast:2633 |
| assert_return(() => call($15, "load8_u", [22_486]), 0); |
| |
| // memory_copy.wast:2634 |
| assert_return(() => call($15, "load8_u", [22_685]), 0); |
| |
| // memory_copy.wast:2635 |
| assert_return(() => call($15, "load8_u", [22_884]), 0); |
| |
| // memory_copy.wast:2636 |
| assert_return(() => call($15, "load8_u", [23_083]), 0); |
| |
| // memory_copy.wast:2637 |
| assert_return(() => call($15, "load8_u", [23_282]), 0); |
| |
| // memory_copy.wast:2638 |
| assert_return(() => call($15, "load8_u", [23_481]), 0); |
| |
| // memory_copy.wast:2639 |
| assert_return(() => call($15, "load8_u", [23_680]), 0); |
| |
| // memory_copy.wast:2640 |
| assert_return(() => call($15, "load8_u", [23_879]), 0); |
| |
| // memory_copy.wast:2641 |
| assert_return(() => call($15, "load8_u", [24_078]), 0); |
| |
| // memory_copy.wast:2642 |
| assert_return(() => call($15, "load8_u", [24_277]), 0); |
| |
| // memory_copy.wast:2643 |
| assert_return(() => call($15, "load8_u", [24_476]), 0); |
| |
| // memory_copy.wast:2644 |
| assert_return(() => call($15, "load8_u", [24_675]), 0); |
| |
| // memory_copy.wast:2645 |
| assert_return(() => call($15, "load8_u", [24_874]), 0); |
| |
| // memory_copy.wast:2646 |
| assert_return(() => call($15, "load8_u", [25_073]), 0); |
| |
| // memory_copy.wast:2647 |
| assert_return(() => call($15, "load8_u", [25_272]), 0); |
| |
| // memory_copy.wast:2648 |
| assert_return(() => call($15, "load8_u", [25_471]), 0); |
| |
| // memory_copy.wast:2649 |
| assert_return(() => call($15, "load8_u", [25_670]), 0); |
| |
| // memory_copy.wast:2650 |
| assert_return(() => call($15, "load8_u", [25_869]), 0); |
| |
| // memory_copy.wast:2651 |
| assert_return(() => call($15, "load8_u", [26_068]), 0); |
| |
| // memory_copy.wast:2652 |
| assert_return(() => call($15, "load8_u", [26_267]), 0); |
| |
| // memory_copy.wast:2653 |
| assert_return(() => call($15, "load8_u", [26_466]), 0); |
| |
| // memory_copy.wast:2654 |
| assert_return(() => call($15, "load8_u", [26_665]), 0); |
| |
| // memory_copy.wast:2655 |
| assert_return(() => call($15, "load8_u", [26_864]), 0); |
| |
| // memory_copy.wast:2656 |
| assert_return(() => call($15, "load8_u", [27_063]), 0); |
| |
| // memory_copy.wast:2657 |
| assert_return(() => call($15, "load8_u", [27_262]), 0); |
| |
| // memory_copy.wast:2658 |
| assert_return(() => call($15, "load8_u", [27_461]), 0); |
| |
| // memory_copy.wast:2659 |
| assert_return(() => call($15, "load8_u", [27_660]), 0); |
| |
| // memory_copy.wast:2660 |
| assert_return(() => call($15, "load8_u", [27_859]), 0); |
| |
| // memory_copy.wast:2661 |
| assert_return(() => call($15, "load8_u", [28_058]), 0); |
| |
| // memory_copy.wast:2662 |
| assert_return(() => call($15, "load8_u", [28_257]), 0); |
| |
| // memory_copy.wast:2663 |
| assert_return(() => call($15, "load8_u", [28_456]), 0); |
| |
| // memory_copy.wast:2664 |
| assert_return(() => call($15, "load8_u", [28_655]), 0); |
| |
| // memory_copy.wast:2665 |
| assert_return(() => call($15, "load8_u", [28_854]), 0); |
| |
| // memory_copy.wast:2666 |
| assert_return(() => call($15, "load8_u", [29_053]), 0); |
| |
| // memory_copy.wast:2667 |
| assert_return(() => call($15, "load8_u", [29_252]), 0); |
| |
| // memory_copy.wast:2668 |
| assert_return(() => call($15, "load8_u", [29_451]), 0); |
| |
| // memory_copy.wast:2669 |
| assert_return(() => call($15, "load8_u", [29_650]), 0); |
| |
| // memory_copy.wast:2670 |
| assert_return(() => call($15, "load8_u", [29_849]), 0); |
| |
| // memory_copy.wast:2671 |
| assert_return(() => call($15, "load8_u", [30_048]), 0); |
| |
| // memory_copy.wast:2672 |
| assert_return(() => call($15, "load8_u", [30_247]), 0); |
| |
| // memory_copy.wast:2673 |
| assert_return(() => call($15, "load8_u", [30_446]), 0); |
| |
| // memory_copy.wast:2674 |
| assert_return(() => call($15, "load8_u", [30_645]), 0); |
| |
| // memory_copy.wast:2675 |
| assert_return(() => call($15, "load8_u", [30_844]), 0); |
| |
| // memory_copy.wast:2676 |
| assert_return(() => call($15, "load8_u", [31_043]), 0); |
| |
| // memory_copy.wast:2677 |
| assert_return(() => call($15, "load8_u", [31_242]), 0); |
| |
| // memory_copy.wast:2678 |
| assert_return(() => call($15, "load8_u", [31_441]), 0); |
| |
| // memory_copy.wast:2679 |
| assert_return(() => call($15, "load8_u", [31_640]), 0); |
| |
| // memory_copy.wast:2680 |
| assert_return(() => call($15, "load8_u", [31_839]), 0); |
| |
| // memory_copy.wast:2681 |
| assert_return(() => call($15, "load8_u", [32_038]), 0); |
| |
| // memory_copy.wast:2682 |
| assert_return(() => call($15, "load8_u", [32_237]), 0); |
| |
| // memory_copy.wast:2683 |
| assert_return(() => call($15, "load8_u", [32_436]), 0); |
| |
| // memory_copy.wast:2684 |
| assert_return(() => call($15, "load8_u", [32_635]), 0); |
| |
| // memory_copy.wast:2685 |
| assert_return(() => call($15, "load8_u", [32_834]), 0); |
| |
| // memory_copy.wast:2686 |
| assert_return(() => call($15, "load8_u", [33_033]), 0); |
| |
| // memory_copy.wast:2687 |
| assert_return(() => call($15, "load8_u", [33_232]), 0); |
| |
| // memory_copy.wast:2688 |
| assert_return(() => call($15, "load8_u", [33_431]), 0); |
| |
| // memory_copy.wast:2689 |
| assert_return(() => call($15, "load8_u", [33_630]), 0); |
| |
| // memory_copy.wast:2690 |
| assert_return(() => call($15, "load8_u", [33_829]), 0); |
| |
| // memory_copy.wast:2691 |
| assert_return(() => call($15, "load8_u", [34_028]), 0); |
| |
| // memory_copy.wast:2692 |
| assert_return(() => call($15, "load8_u", [34_227]), 0); |
| |
| // memory_copy.wast:2693 |
| assert_return(() => call($15, "load8_u", [34_426]), 0); |
| |
| // memory_copy.wast:2694 |
| assert_return(() => call($15, "load8_u", [34_625]), 0); |
| |
| // memory_copy.wast:2695 |
| assert_return(() => call($15, "load8_u", [34_824]), 0); |
| |
| // memory_copy.wast:2696 |
| assert_return(() => call($15, "load8_u", [35_023]), 0); |
| |
| // memory_copy.wast:2697 |
| assert_return(() => call($15, "load8_u", [35_222]), 0); |
| |
| // memory_copy.wast:2698 |
| assert_return(() => call($15, "load8_u", [35_421]), 0); |
| |
| // memory_copy.wast:2699 |
| assert_return(() => call($15, "load8_u", [35_620]), 0); |
| |
| // memory_copy.wast:2700 |
| assert_return(() => call($15, "load8_u", [35_819]), 0); |
| |
| // memory_copy.wast:2701 |
| assert_return(() => call($15, "load8_u", [36_018]), 0); |
| |
| // memory_copy.wast:2702 |
| assert_return(() => call($15, "load8_u", [36_217]), 0); |
| |
| // memory_copy.wast:2703 |
| assert_return(() => call($15, "load8_u", [36_416]), 0); |
| |
| // memory_copy.wast:2704 |
| assert_return(() => call($15, "load8_u", [36_615]), 0); |
| |
| // memory_copy.wast:2705 |
| assert_return(() => call($15, "load8_u", [36_814]), 0); |
| |
| // memory_copy.wast:2706 |
| assert_return(() => call($15, "load8_u", [37_013]), 0); |
| |
| // memory_copy.wast:2707 |
| assert_return(() => call($15, "load8_u", [37_212]), 0); |
| |
| // memory_copy.wast:2708 |
| assert_return(() => call($15, "load8_u", [37_411]), 0); |
| |
| // memory_copy.wast:2709 |
| assert_return(() => call($15, "load8_u", [37_610]), 0); |
| |
| // memory_copy.wast:2710 |
| assert_return(() => call($15, "load8_u", [37_809]), 0); |
| |
| // memory_copy.wast:2711 |
| assert_return(() => call($15, "load8_u", [38_008]), 0); |
| |
| // memory_copy.wast:2712 |
| assert_return(() => call($15, "load8_u", [38_207]), 0); |
| |
| // memory_copy.wast:2713 |
| assert_return(() => call($15, "load8_u", [38_406]), 0); |
| |
| // memory_copy.wast:2714 |
| assert_return(() => call($15, "load8_u", [38_605]), 0); |
| |
| // memory_copy.wast:2715 |
| assert_return(() => call($15, "load8_u", [38_804]), 0); |
| |
| // memory_copy.wast:2716 |
| assert_return(() => call($15, "load8_u", [39_003]), 0); |
| |
| // memory_copy.wast:2717 |
| assert_return(() => call($15, "load8_u", [39_202]), 0); |
| |
| // memory_copy.wast:2718 |
| assert_return(() => call($15, "load8_u", [39_401]), 0); |
| |
| // memory_copy.wast:2719 |
| assert_return(() => call($15, "load8_u", [39_600]), 0); |
| |
| // memory_copy.wast:2720 |
| assert_return(() => call($15, "load8_u", [39_799]), 0); |
| |
| // memory_copy.wast:2721 |
| assert_return(() => call($15, "load8_u", [39_998]), 0); |
| |
| // memory_copy.wast:2722 |
| assert_return(() => call($15, "load8_u", [40_197]), 0); |
| |
| // memory_copy.wast:2723 |
| assert_return(() => call($15, "load8_u", [40_396]), 0); |
| |
| // memory_copy.wast:2724 |
| assert_return(() => call($15, "load8_u", [40_595]), 0); |
| |
| // memory_copy.wast:2725 |
| assert_return(() => call($15, "load8_u", [40_794]), 0); |
| |
| // memory_copy.wast:2726 |
| assert_return(() => call($15, "load8_u", [40_993]), 0); |
| |
| // memory_copy.wast:2727 |
| assert_return(() => call($15, "load8_u", [41_192]), 0); |
| |
| // memory_copy.wast:2728 |
| assert_return(() => call($15, "load8_u", [41_391]), 0); |
| |
| // memory_copy.wast:2729 |
| assert_return(() => call($15, "load8_u", [41_590]), 0); |
| |
| // memory_copy.wast:2730 |
| assert_return(() => call($15, "load8_u", [41_789]), 0); |
| |
| // memory_copy.wast:2731 |
| assert_return(() => call($15, "load8_u", [41_988]), 0); |
| |
| // memory_copy.wast:2732 |
| assert_return(() => call($15, "load8_u", [42_187]), 0); |
| |
| // memory_copy.wast:2733 |
| assert_return(() => call($15, "load8_u", [42_386]), 0); |
| |
| // memory_copy.wast:2734 |
| assert_return(() => call($15, "load8_u", [42_585]), 0); |
| |
| // memory_copy.wast:2735 |
| assert_return(() => call($15, "load8_u", [42_784]), 0); |
| |
| // memory_copy.wast:2736 |
| assert_return(() => call($15, "load8_u", [42_983]), 0); |
| |
| // memory_copy.wast:2737 |
| assert_return(() => call($15, "load8_u", [43_182]), 0); |
| |
| // memory_copy.wast:2738 |
| assert_return(() => call($15, "load8_u", [43_381]), 0); |
| |
| // memory_copy.wast:2739 |
| assert_return(() => call($15, "load8_u", [43_580]), 0); |
| |
| // memory_copy.wast:2740 |
| assert_return(() => call($15, "load8_u", [43_779]), 0); |
| |
| // memory_copy.wast:2741 |
| assert_return(() => call($15, "load8_u", [43_978]), 0); |
| |
| // memory_copy.wast:2742 |
| assert_return(() => call($15, "load8_u", [44_177]), 0); |
| |
| // memory_copy.wast:2743 |
| assert_return(() => call($15, "load8_u", [44_376]), 0); |
| |
| // memory_copy.wast:2744 |
| assert_return(() => call($15, "load8_u", [44_575]), 0); |
| |
| // memory_copy.wast:2745 |
| assert_return(() => call($15, "load8_u", [44_774]), 0); |
| |
| // memory_copy.wast:2746 |
| assert_return(() => call($15, "load8_u", [44_973]), 0); |
| |
| // memory_copy.wast:2747 |
| assert_return(() => call($15, "load8_u", [45_172]), 0); |
| |
| // memory_copy.wast:2748 |
| assert_return(() => call($15, "load8_u", [45_371]), 0); |
| |
| // memory_copy.wast:2749 |
| assert_return(() => call($15, "load8_u", [45_570]), 0); |
| |
| // memory_copy.wast:2750 |
| assert_return(() => call($15, "load8_u", [45_769]), 0); |
| |
| // memory_copy.wast:2751 |
| assert_return(() => call($15, "load8_u", [45_968]), 0); |
| |
| // memory_copy.wast:2752 |
| assert_return(() => call($15, "load8_u", [46_167]), 0); |
| |
| // memory_copy.wast:2753 |
| assert_return(() => call($15, "load8_u", [46_366]), 0); |
| |
| // memory_copy.wast:2754 |
| assert_return(() => call($15, "load8_u", [46_565]), 0); |
| |
| // memory_copy.wast:2755 |
| assert_return(() => call($15, "load8_u", [46_764]), 0); |
| |
| // memory_copy.wast:2756 |
| assert_return(() => call($15, "load8_u", [46_963]), 0); |
| |
| // memory_copy.wast:2757 |
| assert_return(() => call($15, "load8_u", [47_162]), 0); |
| |
| // memory_copy.wast:2758 |
| assert_return(() => call($15, "load8_u", [47_361]), 0); |
| |
| // memory_copy.wast:2759 |
| assert_return(() => call($15, "load8_u", [47_560]), 0); |
| |
| // memory_copy.wast:2760 |
| assert_return(() => call($15, "load8_u", [47_759]), 0); |
| |
| // memory_copy.wast:2761 |
| assert_return(() => call($15, "load8_u", [47_958]), 0); |
| |
| // memory_copy.wast:2762 |
| assert_return(() => call($15, "load8_u", [48_157]), 0); |
| |
| // memory_copy.wast:2763 |
| assert_return(() => call($15, "load8_u", [48_356]), 0); |
| |
| // memory_copy.wast:2764 |
| assert_return(() => call($15, "load8_u", [48_555]), 0); |
| |
| // memory_copy.wast:2765 |
| assert_return(() => call($15, "load8_u", [48_754]), 0); |
| |
| // memory_copy.wast:2766 |
| assert_return(() => call($15, "load8_u", [48_953]), 0); |
| |
| // memory_copy.wast:2767 |
| assert_return(() => call($15, "load8_u", [49_152]), 0); |
| |
| // memory_copy.wast:2768 |
| assert_return(() => call($15, "load8_u", [49_351]), 0); |
| |
| // memory_copy.wast:2769 |
| assert_return(() => call($15, "load8_u", [49_550]), 0); |
| |
| // memory_copy.wast:2770 |
| assert_return(() => call($15, "load8_u", [49_749]), 0); |
| |
| // memory_copy.wast:2771 |
| assert_return(() => call($15, "load8_u", [49_948]), 0); |
| |
| // memory_copy.wast:2772 |
| assert_return(() => call($15, "load8_u", [50_147]), 0); |
| |
| // memory_copy.wast:2773 |
| assert_return(() => call($15, "load8_u", [50_346]), 0); |
| |
| // memory_copy.wast:2774 |
| assert_return(() => call($15, "load8_u", [50_545]), 0); |
| |
| // memory_copy.wast:2775 |
| assert_return(() => call($15, "load8_u", [50_744]), 0); |
| |
| // memory_copy.wast:2776 |
| assert_return(() => call($15, "load8_u", [50_943]), 0); |
| |
| // memory_copy.wast:2777 |
| assert_return(() => call($15, "load8_u", [51_142]), 0); |
| |
| // memory_copy.wast:2778 |
| assert_return(() => call($15, "load8_u", [51_341]), 0); |
| |
| // memory_copy.wast:2779 |
| assert_return(() => call($15, "load8_u", [51_540]), 0); |
| |
| // memory_copy.wast:2780 |
| assert_return(() => call($15, "load8_u", [51_739]), 0); |
| |
| // memory_copy.wast:2781 |
| assert_return(() => call($15, "load8_u", [51_938]), 0); |
| |
| // memory_copy.wast:2782 |
| assert_return(() => call($15, "load8_u", [52_137]), 0); |
| |
| // memory_copy.wast:2783 |
| assert_return(() => call($15, "load8_u", [52_336]), 0); |
| |
| // memory_copy.wast:2784 |
| assert_return(() => call($15, "load8_u", [52_535]), 0); |
| |
| // memory_copy.wast:2785 |
| assert_return(() => call($15, "load8_u", [52_734]), 0); |
| |
| // memory_copy.wast:2786 |
| assert_return(() => call($15, "load8_u", [52_933]), 0); |
| |
| // memory_copy.wast:2787 |
| assert_return(() => call($15, "load8_u", [53_132]), 0); |
| |
| // memory_copy.wast:2788 |
| assert_return(() => call($15, "load8_u", [53_331]), 0); |
| |
| // memory_copy.wast:2789 |
| assert_return(() => call($15, "load8_u", [53_530]), 0); |
| |
| // memory_copy.wast:2790 |
| assert_return(() => call($15, "load8_u", [53_729]), 0); |
| |
| // memory_copy.wast:2791 |
| assert_return(() => call($15, "load8_u", [53_928]), 0); |
| |
| // memory_copy.wast:2792 |
| assert_return(() => call($15, "load8_u", [54_127]), 0); |
| |
| // memory_copy.wast:2793 |
| assert_return(() => call($15, "load8_u", [54_326]), 0); |
| |
| // memory_copy.wast:2794 |
| assert_return(() => call($15, "load8_u", [54_525]), 0); |
| |
| // memory_copy.wast:2795 |
| assert_return(() => call($15, "load8_u", [54_724]), 0); |
| |
| // memory_copy.wast:2796 |
| assert_return(() => call($15, "load8_u", [54_923]), 0); |
| |
| // memory_copy.wast:2797 |
| assert_return(() => call($15, "load8_u", [55_122]), 0); |
| |
| // memory_copy.wast:2798 |
| assert_return(() => call($15, "load8_u", [55_321]), 0); |
| |
| // memory_copy.wast:2799 |
| assert_return(() => call($15, "load8_u", [55_520]), 0); |
| |
| // memory_copy.wast:2800 |
| assert_return(() => call($15, "load8_u", [55_719]), 0); |
| |
| // memory_copy.wast:2801 |
| assert_return(() => call($15, "load8_u", [55_918]), 0); |
| |
| // memory_copy.wast:2802 |
| assert_return(() => call($15, "load8_u", [56_117]), 0); |
| |
| // memory_copy.wast:2803 |
| assert_return(() => call($15, "load8_u", [56_316]), 0); |
| |
| // memory_copy.wast:2804 |
| assert_return(() => call($15, "load8_u", [56_515]), 0); |
| |
| // memory_copy.wast:2805 |
| assert_return(() => call($15, "load8_u", [56_714]), 0); |
| |
| // memory_copy.wast:2806 |
| assert_return(() => call($15, "load8_u", [56_913]), 0); |
| |
| // memory_copy.wast:2807 |
| assert_return(() => call($15, "load8_u", [57_112]), 0); |
| |
| // memory_copy.wast:2808 |
| assert_return(() => call($15, "load8_u", [57_311]), 0); |
| |
| // memory_copy.wast:2809 |
| assert_return(() => call($15, "load8_u", [57_510]), 0); |
| |
| // memory_copy.wast:2810 |
| assert_return(() => call($15, "load8_u", [57_709]), 0); |
| |
| // memory_copy.wast:2811 |
| assert_return(() => call($15, "load8_u", [57_908]), 0); |
| |
| // memory_copy.wast:2812 |
| assert_return(() => call($15, "load8_u", [58_107]), 0); |
| |
| // memory_copy.wast:2813 |
| assert_return(() => call($15, "load8_u", [58_306]), 0); |
| |
| // memory_copy.wast:2814 |
| assert_return(() => call($15, "load8_u", [58_505]), 0); |
| |
| // memory_copy.wast:2815 |
| assert_return(() => call($15, "load8_u", [58_704]), 0); |
| |
| // memory_copy.wast:2816 |
| assert_return(() => call($15, "load8_u", [58_903]), 0); |
| |
| // memory_copy.wast:2817 |
| assert_return(() => call($15, "load8_u", [59_102]), 0); |
| |
| // memory_copy.wast:2818 |
| assert_return(() => call($15, "load8_u", [59_301]), 0); |
| |
| // memory_copy.wast:2819 |
| assert_return(() => call($15, "load8_u", [59_500]), 0); |
| |
| // memory_copy.wast:2820 |
| assert_return(() => call($15, "load8_u", [59_699]), 0); |
| |
| // memory_copy.wast:2821 |
| assert_return(() => call($15, "load8_u", [59_898]), 0); |
| |
| // memory_copy.wast:2822 |
| assert_return(() => call($15, "load8_u", [60_097]), 0); |
| |
| // memory_copy.wast:2823 |
| assert_return(() => call($15, "load8_u", [60_296]), 0); |
| |
| // memory_copy.wast:2824 |
| assert_return(() => call($15, "load8_u", [60_495]), 0); |
| |
| // memory_copy.wast:2825 |
| assert_return(() => call($15, "load8_u", [60_694]), 0); |
| |
| // memory_copy.wast:2826 |
| assert_return(() => call($15, "load8_u", [60_893]), 0); |
| |
| // memory_copy.wast:2827 |
| assert_return(() => call($15, "load8_u", [61_092]), 0); |
| |
| // memory_copy.wast:2828 |
| assert_return(() => call($15, "load8_u", [61_291]), 0); |
| |
| // memory_copy.wast:2829 |
| assert_return(() => call($15, "load8_u", [61_490]), 0); |
| |
| // memory_copy.wast:2830 |
| assert_return(() => call($15, "load8_u", [61_689]), 0); |
| |
| // memory_copy.wast:2831 |
| assert_return(() => call($15, "load8_u", [61_888]), 0); |
| |
| // memory_copy.wast:2832 |
| assert_return(() => call($15, "load8_u", [62_087]), 0); |
| |
| // memory_copy.wast:2833 |
| assert_return(() => call($15, "load8_u", [62_286]), 0); |
| |
| // memory_copy.wast:2834 |
| assert_return(() => call($15, "load8_u", [62_485]), 0); |
| |
| // memory_copy.wast:2835 |
| assert_return(() => call($15, "load8_u", [62_684]), 0); |
| |
| // memory_copy.wast:2836 |
| assert_return(() => call($15, "load8_u", [62_883]), 0); |
| |
| // memory_copy.wast:2837 |
| assert_return(() => call($15, "load8_u", [63_082]), 0); |
| |
| // memory_copy.wast:2838 |
| assert_return(() => call($15, "load8_u", [63_281]), 0); |
| |
| // memory_copy.wast:2839 |
| assert_return(() => call($15, "load8_u", [63_480]), 0); |
| |
| // memory_copy.wast:2840 |
| assert_return(() => call($15, "load8_u", [63_679]), 0); |
| |
| // memory_copy.wast:2841 |
| assert_return(() => call($15, "load8_u", [63_878]), 0); |
| |
| // memory_copy.wast:2842 |
| assert_return(() => call($15, "load8_u", [64_077]), 0); |
| |
| // memory_copy.wast:2843 |
| assert_return(() => call($15, "load8_u", [64_276]), 0); |
| |
| // memory_copy.wast:2844 |
| assert_return(() => call($15, "load8_u", [64_475]), 0); |
| |
| // memory_copy.wast:2845 |
| assert_return(() => call($15, "load8_u", [64_674]), 0); |
| |
| // memory_copy.wast:2846 |
| assert_return(() => call($15, "load8_u", [64_873]), 0); |
| |
| // memory_copy.wast:2847 |
| assert_return(() => call($15, "load8_u", [65_072]), 0); |
| |
| // memory_copy.wast:2848 |
| assert_return(() => call($15, "load8_u", [65_271]), 0); |
| |
| // memory_copy.wast:2849 |
| assert_return(() => call($15, "load8_u", [65_470]), 0); |
| |
| // memory_copy.wast:2850 |
| assert_return(() => call($15, "load8_u", [65_506]), 0); |
| |
| // memory_copy.wast:2851 |
| assert_return(() => call($15, "load8_u", [65_507]), 1); |
| |
| // memory_copy.wast:2852 |
| assert_return(() => call($15, "load8_u", [65_508]), 2); |
| |
| // memory_copy.wast:2853 |
| assert_return(() => call($15, "load8_u", [65_509]), 3); |
| |
| // memory_copy.wast:2854 |
| assert_return(() => call($15, "load8_u", [65_510]), 4); |
| |
| // memory_copy.wast:2855 |
| assert_return(() => call($15, "load8_u", [65_511]), 5); |
| |
| // memory_copy.wast:2856 |
| assert_return(() => call($15, "load8_u", [65_512]), 6); |
| |
| // memory_copy.wast:2857 |
| assert_return(() => call($15, "load8_u", [65_513]), 7); |
| |
| // memory_copy.wast:2858 |
| assert_return(() => call($15, "load8_u", [65_514]), 8); |
| |
| // memory_copy.wast:2859 |
| assert_return(() => call($15, "load8_u", [65_515]), 9); |
| |
| // memory_copy.wast:2860 |
| assert_return(() => call($15, "load8_u", [65_516]), 10); |
| |
| // memory_copy.wast:2861 |
| assert_return(() => call($15, "load8_u", [65_517]), 11); |
| |
| // memory_copy.wast:2862 |
| assert_return(() => call($15, "load8_u", [65_518]), 12); |
| |
| // memory_copy.wast:2863 |
| assert_return(() => call($15, "load8_u", [65_519]), 13); |
| |
| // memory_copy.wast:2864 |
| assert_return(() => call($15, "load8_u", [65_520]), 14); |
| |
| // memory_copy.wast:2865 |
| assert_return(() => call($15, "load8_u", [65_521]), 15); |
| |
| // memory_copy.wast:2866 |
| assert_return(() => call($15, "load8_u", [65_522]), 16); |
| |
| // memory_copy.wast:2867 |
| assert_return(() => call($15, "load8_u", [65_523]), 17); |
| |
| // memory_copy.wast:2868 |
| assert_return(() => call($15, "load8_u", [65_524]), 18); |
| |
| // memory_copy.wast:2869 |
| assert_return(() => call($15, "load8_u", [65_525]), 19); |
| |
| // memory_copy.wast:2871 |
| 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:2879 |
| assert_trap(() => call($16, "run", [65_506, 65_516, 40])); |
| |
| // memory_copy.wast:2882 |
| assert_return(() => call($16, "load8_u", [198]), 0); |
| |
| // memory_copy.wast:2883 |
| assert_return(() => call($16, "load8_u", [397]), 0); |
| |
| // memory_copy.wast:2884 |
| assert_return(() => call($16, "load8_u", [596]), 0); |
| |
| // memory_copy.wast:2885 |
| assert_return(() => call($16, "load8_u", [795]), 0); |
| |
| // memory_copy.wast:2886 |
| assert_return(() => call($16, "load8_u", [994]), 0); |
| |
| // memory_copy.wast:2887 |
| assert_return(() => call($16, "load8_u", [1_193]), 0); |
| |
| // memory_copy.wast:2888 |
| assert_return(() => call($16, "load8_u", [1_392]), 0); |
| |
| // memory_copy.wast:2889 |
| assert_return(() => call($16, "load8_u", [1_591]), 0); |
| |
| // memory_copy.wast:2890 |
| assert_return(() => call($16, "load8_u", [1_790]), 0); |
| |
| // memory_copy.wast:2891 |
| assert_return(() => call($16, "load8_u", [1_989]), 0); |
| |
| // memory_copy.wast:2892 |
| assert_return(() => call($16, "load8_u", [2_188]), 0); |
| |
| // memory_copy.wast:2893 |
| assert_return(() => call($16, "load8_u", [2_387]), 0); |
| |
| // memory_copy.wast:2894 |
| assert_return(() => call($16, "load8_u", [2_586]), 0); |
| |
| // memory_copy.wast:2895 |
| assert_return(() => call($16, "load8_u", [2_785]), 0); |
| |
| // memory_copy.wast:2896 |
| assert_return(() => call($16, "load8_u", [2_984]), 0); |
| |
| // memory_copy.wast:2897 |
| assert_return(() => call($16, "load8_u", [3_183]), 0); |
| |
| // memory_copy.wast:2898 |
| assert_return(() => call($16, "load8_u", [3_382]), 0); |
| |
| // memory_copy.wast:2899 |
| assert_return(() => call($16, "load8_u", [3_581]), 0); |
| |
| // memory_copy.wast:2900 |
| assert_return(() => call($16, "load8_u", [3_780]), 0); |
| |
| // memory_copy.wast:2901 |
| assert_return(() => call($16, "load8_u", [3_979]), 0); |
| |
| // memory_copy.wast:2902 |
| assert_return(() => call($16, "load8_u", [4_178]), 0); |
| |
| // memory_copy.wast:2903 |
| assert_return(() => call($16, "load8_u", [4_377]), 0); |
| |
| // memory_copy.wast:2904 |
| assert_return(() => call($16, "load8_u", [4_576]), 0); |
| |
| // memory_copy.wast:2905 |
| assert_return(() => call($16, "load8_u", [4_775]), 0); |
| |
| // memory_copy.wast:2906 |
| assert_return(() => call($16, "load8_u", [4_974]), 0); |
| |
| // memory_copy.wast:2907 |
| assert_return(() => call($16, "load8_u", [5_173]), 0); |
| |
| // memory_copy.wast:2908 |
| assert_return(() => call($16, "load8_u", [5_372]), 0); |
| |
| // memory_copy.wast:2909 |
| assert_return(() => call($16, "load8_u", [5_571]), 0); |
| |
| // memory_copy.wast:2910 |
| assert_return(() => call($16, "load8_u", [5_770]), 0); |
| |
| // memory_copy.wast:2911 |
| assert_return(() => call($16, "load8_u", [5_969]), 0); |
| |
| // memory_copy.wast:2912 |
| assert_return(() => call($16, "load8_u", [6_168]), 0); |
| |
| // memory_copy.wast:2913 |
| assert_return(() => call($16, "load8_u", [6_367]), 0); |
| |
| // memory_copy.wast:2914 |
| assert_return(() => call($16, "load8_u", [6_566]), 0); |
| |
| // memory_copy.wast:2915 |
| assert_return(() => call($16, "load8_u", [6_765]), 0); |
| |
| // memory_copy.wast:2916 |
| assert_return(() => call($16, "load8_u", [6_964]), 0); |
| |
| // memory_copy.wast:2917 |
| assert_return(() => call($16, "load8_u", [7_163]), 0); |
| |
| // memory_copy.wast:2918 |
| assert_return(() => call($16, "load8_u", [7_362]), 0); |
| |
| // memory_copy.wast:2919 |
| assert_return(() => call($16, "load8_u", [7_561]), 0); |
| |
| // memory_copy.wast:2920 |
| assert_return(() => call($16, "load8_u", [7_760]), 0); |
| |
| // memory_copy.wast:2921 |
| assert_return(() => call($16, "load8_u", [7_959]), 0); |
| |
| // memory_copy.wast:2922 |
| assert_return(() => call($16, "load8_u", [8_158]), 0); |
| |
| // memory_copy.wast:2923 |
| assert_return(() => call($16, "load8_u", [8_357]), 0); |
| |
| // memory_copy.wast:2924 |
| assert_return(() => call($16, "load8_u", [8_556]), 0); |
| |
| // memory_copy.wast:2925 |
| assert_return(() => call($16, "load8_u", [8_755]), 0); |
| |
| // memory_copy.wast:2926 |
| assert_return(() => call($16, "load8_u", [8_954]), 0); |
| |
| // memory_copy.wast:2927 |
| assert_return(() => call($16, "load8_u", [9_153]), 0); |
| |
| // memory_copy.wast:2928 |
| assert_return(() => call($16, "load8_u", [9_352]), 0); |
| |
| // memory_copy.wast:2929 |
| assert_return(() => call($16, "load8_u", [9_551]), 0); |
| |
| // memory_copy.wast:2930 |
| assert_return(() => call($16, "load8_u", [9_750]), 0); |
| |
| // memory_copy.wast:2931 |
| assert_return(() => call($16, "load8_u", [9_949]), 0); |
| |
| // memory_copy.wast:2932 |
| assert_return(() => call($16, "load8_u", [10_148]), 0); |
| |
| // memory_copy.wast:2933 |
| assert_return(() => call($16, "load8_u", [10_347]), 0); |
| |
| // memory_copy.wast:2934 |
| assert_return(() => call($16, "load8_u", [10_546]), 0); |
| |
| // memory_copy.wast:2935 |
| assert_return(() => call($16, "load8_u", [10_745]), 0); |
| |
| // memory_copy.wast:2936 |
| assert_return(() => call($16, "load8_u", [10_944]), 0); |
| |
| // memory_copy.wast:2937 |
| assert_return(() => call($16, "load8_u", [11_143]), 0); |
| |
| // memory_copy.wast:2938 |
| assert_return(() => call($16, "load8_u", [11_342]), 0); |
| |
| // memory_copy.wast:2939 |
| assert_return(() => call($16, "load8_u", [11_541]), 0); |
| |
| // memory_copy.wast:2940 |
| assert_return(() => call($16, "load8_u", [11_740]), 0); |
| |
| // memory_copy.wast:2941 |
| assert_return(() => call($16, "load8_u", [11_939]), 0); |
| |
| // memory_copy.wast:2942 |
| assert_return(() => call($16, "load8_u", [12_138]), 0); |
| |
| // memory_copy.wast:2943 |
| assert_return(() => call($16, "load8_u", [12_337]), 0); |
| |
| // memory_copy.wast:2944 |
| assert_return(() => call($16, "load8_u", [12_536]), 0); |
| |
| // memory_copy.wast:2945 |
| assert_return(() => call($16, "load8_u", [12_735]), 0); |
| |
| // memory_copy.wast:2946 |
| assert_return(() => call($16, "load8_u", [12_934]), 0); |
| |
| // memory_copy.wast:2947 |
| assert_return(() => call($16, "load8_u", [13_133]), 0); |
| |
| // memory_copy.wast:2948 |
| assert_return(() => call($16, "load8_u", [13_332]), 0); |
| |
| // memory_copy.wast:2949 |
| assert_return(() => call($16, "load8_u", [13_531]), 0); |
| |
| // memory_copy.wast:2950 |
| assert_return(() => call($16, "load8_u", [13_730]), 0); |
| |
| // memory_copy.wast:2951 |
| assert_return(() => call($16, "load8_u", [13_929]), 0); |
| |
| // memory_copy.wast:2952 |
| assert_return(() => call($16, "load8_u", [14_128]), 0); |
| |
| // memory_copy.wast:2953 |
| assert_return(() => call($16, "load8_u", [14_327]), 0); |
| |
| // memory_copy.wast:2954 |
| assert_return(() => call($16, "load8_u", [14_526]), 0); |
| |
| // memory_copy.wast:2955 |
| assert_return(() => call($16, "load8_u", [14_725]), 0); |
| |
| // memory_copy.wast:2956 |
| assert_return(() => call($16, "load8_u", [14_924]), 0); |
| |
| // memory_copy.wast:2957 |
| assert_return(() => call($16, "load8_u", [15_123]), 0); |
| |
| // memory_copy.wast:2958 |
| assert_return(() => call($16, "load8_u", [15_322]), 0); |
| |
| // memory_copy.wast:2959 |
| assert_return(() => call($16, "load8_u", [15_521]), 0); |
| |
| // memory_copy.wast:2960 |
| assert_return(() => call($16, "load8_u", [15_720]), 0); |
| |
| // memory_copy.wast:2961 |
| assert_return(() => call($16, "load8_u", [15_919]), 0); |
| |
| // memory_copy.wast:2962 |
| assert_return(() => call($16, "load8_u", [16_118]), 0); |
| |
| // memory_copy.wast:2963 |
| assert_return(() => call($16, "load8_u", [16_317]), 0); |
| |
| // memory_copy.wast:2964 |
| assert_return(() => call($16, "load8_u", [16_516]), 0); |
| |
| // memory_copy.wast:2965 |
| assert_return(() => call($16, "load8_u", [16_715]), 0); |
| |
| // memory_copy.wast:2966 |
| assert_return(() => call($16, "load8_u", [16_914]), 0); |
| |
| // memory_copy.wast:2967 |
| assert_return(() => call($16, "load8_u", [17_113]), 0); |
| |
| // memory_copy.wast:2968 |
| assert_return(() => call($16, "load8_u", [17_312]), 0); |
| |
| // memory_copy.wast:2969 |
| assert_return(() => call($16, "load8_u", [17_511]), 0); |
| |
| // memory_copy.wast:2970 |
| assert_return(() => call($16, "load8_u", [17_710]), 0); |
| |
| // memory_copy.wast:2971 |
| assert_return(() => call($16, "load8_u", [17_909]), 0); |
| |
| // memory_copy.wast:2972 |
| assert_return(() => call($16, "load8_u", [18_108]), 0); |
| |
| // memory_copy.wast:2973 |
| assert_return(() => call($16, "load8_u", [18_307]), 0); |
| |
| // memory_copy.wast:2974 |
| assert_return(() => call($16, "load8_u", [18_506]), 0); |
| |
| // memory_copy.wast:2975 |
| assert_return(() => call($16, "load8_u", [18_705]), 0); |
| |
| // memory_copy.wast:2976 |
| assert_return(() => call($16, "load8_u", [18_904]), 0); |
| |
| // memory_copy.wast:2977 |
| assert_return(() => call($16, "load8_u", [19_103]), 0); |
| |
| // memory_copy.wast:2978 |
| assert_return(() => call($16, "load8_u", [19_302]), 0); |
| |
| // memory_copy.wast:2979 |
| assert_return(() => call($16, "load8_u", [19_501]), 0); |
| |
| // memory_copy.wast:2980 |
| assert_return(() => call($16, "load8_u", [19_700]), 0); |
| |
| // memory_copy.wast:2981 |
| assert_return(() => call($16, "load8_u", [19_899]), 0); |
| |
| // memory_copy.wast:2982 |
| assert_return(() => call($16, "load8_u", [20_098]), 0); |
| |
| // memory_copy.wast:2983 |
| assert_return(() => call($16, "load8_u", [20_297]), 0); |
| |
| // memory_copy.wast:2984 |
| assert_return(() => call($16, "load8_u", [20_496]), 0); |
| |
| // memory_copy.wast:2985 |
| assert_return(() => call($16, "load8_u", [20_695]), 0); |
| |
| // memory_copy.wast:2986 |
| assert_return(() => call($16, "load8_u", [20_894]), 0); |
| |
| // memory_copy.wast:2987 |
| assert_return(() => call($16, "load8_u", [21_093]), 0); |
| |
| // memory_copy.wast:2988 |
| assert_return(() => call($16, "load8_u", [21_292]), 0); |
| |
| // memory_copy.wast:2989 |
| assert_return(() => call($16, "load8_u", [21_491]), 0); |
| |
| // memory_copy.wast:2990 |
| assert_return(() => call($16, "load8_u", [21_690]), 0); |
| |
| // memory_copy.wast:2991 |
| assert_return(() => call($16, "load8_u", [21_889]), 0); |
| |
| // memory_copy.wast:2992 |
| assert_return(() => call($16, "load8_u", [22_088]), 0); |
| |
| // memory_copy.wast:2993 |
| assert_return(() => call($16, "load8_u", [22_287]), 0); |
| |
| // memory_copy.wast:2994 |
| assert_return(() => call($16, "load8_u", [22_486]), 0); |
| |
| // memory_copy.wast:2995 |
| assert_return(() => call($16, "load8_u", [22_685]), 0); |
| |
| // memory_copy.wast:2996 |
| assert_return(() => call($16, "load8_u", [22_884]), 0); |
| |
| // memory_copy.wast:2997 |
| assert_return(() => call($16, "load8_u", [23_083]), 0); |
| |
| // memory_copy.wast:2998 |
| assert_return(() => call($16, "load8_u", [23_282]), 0); |
| |
| // memory_copy.wast:2999 |
| assert_return(() => call($16, "load8_u", [23_481]), 0); |
| |
| // memory_copy.wast:3000 |
| assert_return(() => call($16, "load8_u", [23_680]), 0); |
| |
| // memory_copy.wast:3001 |
| assert_return(() => call($16, "load8_u", [23_879]), 0); |
| |
| // memory_copy.wast:3002 |
| assert_return(() => call($16, "load8_u", [24_078]), 0); |
| |
| // memory_copy.wast:3003 |
| assert_return(() => call($16, "load8_u", [24_277]), 0); |
| |
| // memory_copy.wast:3004 |
| assert_return(() => call($16, "load8_u", [24_476]), 0); |
| |
| // memory_copy.wast:3005 |
| assert_return(() => call($16, "load8_u", [24_675]), 0); |
| |
| // memory_copy.wast:3006 |
| assert_return(() => call($16, "load8_u", [24_874]), 0); |
| |
| // memory_copy.wast:3007 |
| assert_return(() => call($16, "load8_u", [25_073]), 0); |
| |
| // memory_copy.wast:3008 |
| assert_return(() => call($16, "load8_u", [25_272]), 0); |
| |
| // memory_copy.wast:3009 |
| assert_return(() => call($16, "load8_u", [25_471]), 0); |
| |
| // memory_copy.wast:3010 |
| assert_return(() => call($16, "load8_u", [25_670]), 0); |
| |
| // memory_copy.wast:3011 |
| assert_return(() => call($16, "load8_u", [25_869]), 0); |
| |
| // memory_copy.wast:3012 |
| assert_return(() => call($16, "load8_u", [26_068]), 0); |
| |
| // memory_copy.wast:3013 |
| assert_return(() => call($16, "load8_u", [26_267]), 0); |
| |
| // memory_copy.wast:3014 |
| assert_return(() => call($16, "load8_u", [26_466]), 0); |
| |
| // memory_copy.wast:3015 |
| assert_return(() => call($16, "load8_u", [26_665]), 0); |
| |
| // memory_copy.wast:3016 |
| assert_return(() => call($16, "load8_u", [26_864]), 0); |
| |
| // memory_copy.wast:3017 |
| assert_return(() => call($16, "load8_u", [27_063]), 0); |
| |
| // memory_copy.wast:3018 |
| assert_return(() => call($16, "load8_u", [27_262]), 0); |
| |
| // memory_copy.wast:3019 |
| assert_return(() => call($16, "load8_u", [27_461]), 0); |
| |
| // memory_copy.wast:3020 |
| assert_return(() => call($16, "load8_u", [27_660]), 0); |
| |
| // memory_copy.wast:3021 |
| assert_return(() => call($16, "load8_u", [27_859]), 0); |
| |
| // memory_copy.wast:3022 |
| assert_return(() => call($16, "load8_u", [28_058]), 0); |
| |
| // memory_copy.wast:3023 |
| assert_return(() => call($16, "load8_u", [28_257]), 0); |
| |
| // memory_copy.wast:3024 |
| assert_return(() => call($16, "load8_u", [28_456]), 0); |
| |
| // memory_copy.wast:3025 |
| assert_return(() => call($16, "load8_u", [28_655]), 0); |
| |
| // memory_copy.wast:3026 |
| assert_return(() => call($16, "load8_u", [28_854]), 0); |
| |
| // memory_copy.wast:3027 |
| assert_return(() => call($16, "load8_u", [29_053]), 0); |
| |
| // memory_copy.wast:3028 |
| assert_return(() => call($16, "load8_u", [29_252]), 0); |
| |
| // memory_copy.wast:3029 |
| assert_return(() => call($16, "load8_u", [29_451]), 0); |
| |
| // memory_copy.wast:3030 |
| assert_return(() => call($16, "load8_u", [29_650]), 0); |
| |
| // memory_copy.wast:3031 |
| assert_return(() => call($16, "load8_u", [29_849]), 0); |
| |
| // memory_copy.wast:3032 |
| assert_return(() => call($16, "load8_u", [30_048]), 0); |
| |
| // memory_copy.wast:3033 |
| assert_return(() => call($16, "load8_u", [30_247]), 0); |
| |
| // memory_copy.wast:3034 |
| assert_return(() => call($16, "load8_u", [30_446]), 0); |
| |
| // memory_copy.wast:3035 |
| assert_return(() => call($16, "load8_u", [30_645]), 0); |
| |
| // memory_copy.wast:3036 |
| assert_return(() => call($16, "load8_u", [30_844]), 0); |
| |
| // memory_copy.wast:3037 |
| assert_return(() => call($16, "load8_u", [31_043]), 0); |
| |
| // memory_copy.wast:3038 |
| assert_return(() => call($16, "load8_u", [31_242]), 0); |
| |
| // memory_copy.wast:3039 |
| assert_return(() => call($16, "load8_u", [31_441]), 0); |
| |
| // memory_copy.wast:3040 |
| assert_return(() => call($16, "load8_u", [31_640]), 0); |
| |
| // memory_copy.wast:3041 |
| assert_return(() => call($16, "load8_u", [31_839]), 0); |
| |
| // memory_copy.wast:3042 |
| assert_return(() => call($16, "load8_u", [32_038]), 0); |
| |
| // memory_copy.wast:3043 |
| assert_return(() => call($16, "load8_u", [32_237]), 0); |
| |
| // memory_copy.wast:3044 |
| assert_return(() => call($16, "load8_u", [32_436]), 0); |
| |
| // memory_copy.wast:3045 |
| assert_return(() => call($16, "load8_u", [32_635]), 0); |
| |
| // memory_copy.wast:3046 |
| assert_return(() => call($16, "load8_u", [32_834]), 0); |
| |
| // memory_copy.wast:3047 |
| assert_return(() => call($16, "load8_u", [33_033]), 0); |
| |
| // memory_copy.wast:3048 |
| assert_return(() => call($16, "load8_u", [33_232]), 0); |
| |
| // memory_copy.wast:3049 |
| assert_return(() => call($16, "load8_u", [33_431]), 0); |
| |
| // memory_copy.wast:3050 |
| assert_return(() => call($16, "load8_u", [33_630]), 0); |
| |
| // memory_copy.wast:3051 |
| assert_return(() => call($16, "load8_u", [33_829]), 0); |
| |
| // memory_copy.wast:3052 |
| assert_return(() => call($16, "load8_u", [34_028]), 0); |
| |
| // memory_copy.wast:3053 |
| assert_return(() => call($16, "load8_u", [34_227]), 0); |
| |
| // memory_copy.wast:3054 |
| assert_return(() => call($16, "load8_u", [34_426]), 0); |
| |
| // memory_copy.wast:3055 |
| assert_return(() => call($16, "load8_u", [34_625]), 0); |
| |
| // memory_copy.wast:3056 |
| assert_return(() => call($16, "load8_u", [34_824]), 0); |
| |
| // memory_copy.wast:3057 |
| assert_return(() => call($16, "load8_u", [35_023]), 0); |
| |
| // memory_copy.wast:3058 |
| assert_return(() => call($16, "load8_u", [35_222]), 0); |
| |
| // memory_copy.wast:3059 |
| assert_return(() => call($16, "load8_u", [35_421]), 0); |
| |
| // memory_copy.wast:3060 |
| assert_return(() => call($16, "load8_u", [35_620]), 0); |
| |
| // memory_copy.wast:3061 |
| assert_return(() => call($16, "load8_u", [35_819]), 0); |
| |
| // memory_copy.wast:3062 |
| assert_return(() => call($16, "load8_u", [36_018]), 0); |
| |
| // memory_copy.wast:3063 |
| assert_return(() => call($16, "load8_u", [36_217]), 0); |
| |
| // memory_copy.wast:3064 |
| assert_return(() => call($16, "load8_u", [36_416]), 0); |
| |
| // memory_copy.wast:3065 |
| assert_return(() => call($16, "load8_u", [36_615]), 0); |
| |
| // memory_copy.wast:3066 |
| assert_return(() => call($16, "load8_u", [36_814]), 0); |
| |
| // memory_copy.wast:3067 |
| assert_return(() => call($16, "load8_u", [37_013]), 0); |
| |
| // memory_copy.wast:3068 |
| assert_return(() => call($16, "load8_u", [37_212]), 0); |
| |
| // memory_copy.wast:3069 |
| assert_return(() => call($16, "load8_u", [37_411]), 0); |
| |
| // memory_copy.wast:3070 |
| assert_return(() => call($16, "load8_u", [37_610]), 0); |
| |
| // memory_copy.wast:3071 |
| assert_return(() => call($16, "load8_u", [37_809]), 0); |
| |
| // memory_copy.wast:3072 |
| assert_return(() => call($16, "load8_u", [38_008]), 0); |
| |
| // memory_copy.wast:3073 |
| assert_return(() => call($16, "load8_u", [38_207]), 0); |
| |
| // memory_copy.wast:3074 |
| assert_return(() => call($16, "load8_u", [38_406]), 0); |
| |
| // memory_copy.wast:3075 |
| assert_return(() => call($16, "load8_u", [38_605]), 0); |
| |
| // memory_copy.wast:3076 |
| assert_return(() => call($16, "load8_u", [38_804]), 0); |
| |
| // memory_copy.wast:3077 |
| assert_return(() => call($16, "load8_u", [39_003]), 0); |
| |
| // memory_copy.wast:3078 |
| assert_return(() => call($16, "load8_u", [39_202]), 0); |
| |
| // memory_copy.wast:3079 |
| assert_return(() => call($16, "load8_u", [39_401]), 0); |
| |
| // memory_copy.wast:3080 |
| assert_return(() => call($16, "load8_u", [39_600]), 0); |
| |
| // memory_copy.wast:3081 |
| assert_return(() => call($16, "load8_u", [39_799]), 0); |
| |
| // memory_copy.wast:3082 |
| assert_return(() => call($16, "load8_u", [39_998]), 0); |
| |
| // memory_copy.wast:3083 |
| assert_return(() => call($16, "load8_u", [40_197]), 0); |
| |
| // memory_copy.wast:3084 |
| assert_return(() => call($16, "load8_u", [40_396]), 0); |
| |
| // memory_copy.wast:3085 |
| assert_return(() => call($16, "load8_u", [40_595]), 0); |
| |
| // memory_copy.wast:3086 |
| assert_return(() => call($16, "load8_u", [40_794]), 0); |
| |
| // memory_copy.wast:3087 |
| assert_return(() => call($16, "load8_u", [40_993]), 0); |
| |
| // memory_copy.wast:3088 |
| assert_return(() => call($16, "load8_u", [41_192]), 0); |
| |
| // memory_copy.wast:3089 |
| assert_return(() => call($16, "load8_u", [41_391]), 0); |
| |
| // memory_copy.wast:3090 |
| assert_return(() => call($16, "load8_u", [41_590]), 0); |
| |
| // memory_copy.wast:3091 |
| assert_return(() => call($16, "load8_u", [41_789]), 0); |
| |
| // memory_copy.wast:3092 |
| assert_return(() => call($16, "load8_u", [41_988]), 0); |
| |
| // memory_copy.wast:3093 |
| assert_return(() => call($16, "load8_u", [42_187]), 0); |
| |
| // memory_copy.wast:3094 |
| assert_return(() => call($16, "load8_u", [42_386]), 0); |
| |
| // memory_copy.wast:3095 |
| assert_return(() => call($16, "load8_u", [42_585]), 0); |
| |
| // memory_copy.wast:3096 |
| assert_return(() => call($16, "load8_u", [42_784]), 0); |
| |
| // memory_copy.wast:3097 |
| assert_return(() => call($16, "load8_u", [42_983]), 0); |
| |
| // memory_copy.wast:3098 |
| assert_return(() => call($16, "load8_u", [43_182]), 0); |
| |
| // memory_copy.wast:3099 |
| assert_return(() => call($16, "load8_u", [43_381]), 0); |
| |
| // memory_copy.wast:3100 |
| assert_return(() => call($16, "load8_u", [43_580]), 0); |
| |
| // memory_copy.wast:3101 |
| assert_return(() => call($16, "load8_u", [43_779]), 0); |
| |
| // memory_copy.wast:3102 |
| assert_return(() => call($16, "load8_u", [43_978]), 0); |
| |
| // memory_copy.wast:3103 |
| assert_return(() => call($16, "load8_u", [44_177]), 0); |
| |
| // memory_copy.wast:3104 |
| assert_return(() => call($16, "load8_u", [44_376]), 0); |
| |
| // memory_copy.wast:3105 |
| assert_return(() => call($16, "load8_u", [44_575]), 0); |
| |
| // memory_copy.wast:3106 |
| assert_return(() => call($16, "load8_u", [44_774]), 0); |
| |
| // memory_copy.wast:3107 |
| assert_return(() => call($16, "load8_u", [44_973]), 0); |
| |
| // memory_copy.wast:3108 |
| assert_return(() => call($16, "load8_u", [45_172]), 0); |
| |
| // memory_copy.wast:3109 |
| assert_return(() => call($16, "load8_u", [45_371]), 0); |
| |
| // memory_copy.wast:3110 |
| assert_return(() => call($16, "load8_u", [45_570]), 0); |
| |
| // memory_copy.wast:3111 |
| assert_return(() => call($16, "load8_u", [45_769]), 0); |
| |
| // memory_copy.wast:3112 |
| assert_return(() => call($16, "load8_u", [45_968]), 0); |
| |
| // memory_copy.wast:3113 |
| assert_return(() => call($16, "load8_u", [46_167]), 0); |
| |
| // memory_copy.wast:3114 |
| assert_return(() => call($16, "load8_u", [46_366]), 0); |
| |
| // memory_copy.wast:3115 |
| assert_return(() => call($16, "load8_u", [46_565]), 0); |
| |
| // memory_copy.wast:3116 |
| assert_return(() => call($16, "load8_u", [46_764]), 0); |
| |
| // memory_copy.wast:3117 |
| assert_return(() => call($16, "load8_u", [46_963]), 0); |
| |
| // memory_copy.wast:3118 |
| assert_return(() => call($16, "load8_u", [47_162]), 0); |
| |
| // memory_copy.wast:3119 |
| assert_return(() => call($16, "load8_u", [47_361]), 0); |
| |
| // memory_copy.wast:3120 |
| assert_return(() => call($16, "load8_u", [47_560]), 0); |
| |
| // memory_copy.wast:3121 |
| assert_return(() => call($16, "load8_u", [47_759]), 0); |
| |
| // memory_copy.wast:3122 |
| assert_return(() => call($16, "load8_u", [47_958]), 0); |
| |
| // memory_copy.wast:3123 |
| assert_return(() => call($16, "load8_u", [48_157]), 0); |
| |
| // memory_copy.wast:3124 |
| assert_return(() => call($16, "load8_u", [48_356]), 0); |
| |
| // memory_copy.wast:3125 |
| assert_return(() => call($16, "load8_u", [48_555]), 0); |
| |
| // memory_copy.wast:3126 |
| assert_return(() => call($16, "load8_u", [48_754]), 0); |
| |
| // memory_copy.wast:3127 |
| assert_return(() => call($16, "load8_u", [48_953]), 0); |
| |
| // memory_copy.wast:3128 |
| assert_return(() => call($16, "load8_u", [49_152]), 0); |
| |
| // memory_copy.wast:3129 |
| assert_return(() => call($16, "load8_u", [49_351]), 0); |
| |
| // memory_copy.wast:3130 |
| assert_return(() => call($16, "load8_u", [49_550]), 0); |
| |
| // memory_copy.wast:3131 |
| assert_return(() => call($16, "load8_u", [49_749]), 0); |
| |
| // memory_copy.wast:3132 |
| assert_return(() => call($16, "load8_u", [49_948]), 0); |
| |
| // memory_copy.wast:3133 |
| assert_return(() => call($16, "load8_u", [50_147]), 0); |
| |
| // memory_copy.wast:3134 |
| assert_return(() => call($16, "load8_u", [50_346]), 0); |
| |
| // memory_copy.wast:3135 |
| assert_return(() => call($16, "load8_u", [50_545]), 0); |
| |
| // memory_copy.wast:3136 |
| assert_return(() => call($16, "load8_u", [50_744]), 0); |
| |
| // memory_copy.wast:3137 |
| assert_return(() => call($16, "load8_u", [50_943]), 0); |
| |
| // memory_copy.wast:3138 |
| assert_return(() => call($16, "load8_u", [51_142]), 0); |
| |
| // memory_copy.wast:3139 |
| assert_return(() => call($16, "load8_u", [51_341]), 0); |
| |
| // memory_copy.wast:3140 |
| assert_return(() => call($16, "load8_u", [51_540]), 0); |
| |
| // memory_copy.wast:3141 |
| assert_return(() => call($16, "load8_u", [51_739]), 0); |
| |
| // memory_copy.wast:3142 |
| assert_return(() => call($16, "load8_u", [51_938]), 0); |
| |
| // memory_copy.wast:3143 |
| assert_return(() => call($16, "load8_u", [52_137]), 0); |
| |
| // memory_copy.wast:3144 |
| assert_return(() => call($16, "load8_u", [52_336]), 0); |
| |
| // memory_copy.wast:3145 |
| assert_return(() => call($16, "load8_u", [52_535]), 0); |
| |
| // memory_copy.wast:3146 |
| assert_return(() => call($16, "load8_u", [52_734]), 0); |
| |
| // memory_copy.wast:3147 |
| assert_return(() => call($16, "load8_u", [52_933]), 0); |
| |
| // memory_copy.wast:3148 |
| assert_return(() => call($16, "load8_u", [53_132]), 0); |
| |
| // memory_copy.wast:3149 |
| assert_return(() => call($16, "load8_u", [53_331]), 0); |
| |
| // memory_copy.wast:3150 |
| assert_return(() => call($16, "load8_u", [53_530]), 0); |
| |
| // memory_copy.wast:3151 |
| assert_return(() => call($16, "load8_u", [53_729]), 0); |
| |
| // memory_copy.wast:3152 |
| assert_return(() => call($16, "load8_u", [53_928]), 0); |
| |
| // memory_copy.wast:3153 |
| assert_return(() => call($16, "load8_u", [54_127]), 0); |
| |
| // memory_copy.wast:3154 |
| assert_return(() => call($16, "load8_u", [54_326]), 0); |
| |
| // memory_copy.wast:3155 |
| assert_return(() => call($16, "load8_u", [54_525]), 0); |
| |
| // memory_copy.wast:3156 |
| assert_return(() => call($16, "load8_u", [54_724]), 0); |
| |
| // memory_copy.wast:3157 |
| assert_return(() => call($16, "load8_u", [54_923]), 0); |
| |
| // memory_copy.wast:3158 |
| assert_return(() => call($16, "load8_u", [55_122]), 0); |
| |
| // memory_copy.wast:3159 |
| assert_return(() => call($16, "load8_u", [55_321]), 0); |
| |
| // memory_copy.wast:3160 |
| assert_return(() => call($16, "load8_u", [55_520]), 0); |
| |
| // memory_copy.wast:3161 |
| assert_return(() => call($16, "load8_u", [55_719]), 0); |
| |
| // memory_copy.wast:3162 |
| assert_return(() => call($16, "load8_u", [55_918]), 0); |
| |
| // memory_copy.wast:3163 |
| assert_return(() => call($16, "load8_u", [56_117]), 0); |
| |
| // memory_copy.wast:3164 |
| assert_return(() => call($16, "load8_u", [56_316]), 0); |
| |
| // memory_copy.wast:3165 |
| assert_return(() => call($16, "load8_u", [56_515]), 0); |
| |
| // memory_copy.wast:3166 |
| assert_return(() => call($16, "load8_u", [56_714]), 0); |
| |
| // memory_copy.wast:3167 |
| assert_return(() => call($16, "load8_u", [56_913]), 0); |
| |
| // memory_copy.wast:3168 |
| assert_return(() => call($16, "load8_u", [57_112]), 0); |
| |
| // memory_copy.wast:3169 |
| assert_return(() => call($16, "load8_u", [57_311]), 0); |
| |
| // memory_copy.wast:3170 |
| assert_return(() => call($16, "load8_u", [57_510]), 0); |
| |
| // memory_copy.wast:3171 |
| assert_return(() => call($16, "load8_u", [57_709]), 0); |
| |
| // memory_copy.wast:3172 |
| assert_return(() => call($16, "load8_u", [57_908]), 0); |
| |
| // memory_copy.wast:3173 |
| assert_return(() => call($16, "load8_u", [58_107]), 0); |
| |
| // memory_copy.wast:3174 |
| assert_return(() => call($16, "load8_u", [58_306]), 0); |
| |
| // memory_copy.wast:3175 |
| assert_return(() => call($16, "load8_u", [58_505]), 0); |
| |
| // memory_copy.wast:3176 |
| assert_return(() => call($16, "load8_u", [58_704]), 0); |
| |
| // memory_copy.wast:3177 |
| assert_return(() => call($16, "load8_u", [58_903]), 0); |
| |
| // memory_copy.wast:3178 |
| assert_return(() => call($16, "load8_u", [59_102]), 0); |
| |
| // memory_copy.wast:3179 |
| assert_return(() => call($16, "load8_u", [59_301]), 0); |
| |
| // memory_copy.wast:3180 |
| assert_return(() => call($16, "load8_u", [59_500]), 0); |
| |
| // memory_copy.wast:3181 |
| assert_return(() => call($16, "load8_u", [59_699]), 0); |
| |
| // memory_copy.wast:3182 |
| assert_return(() => call($16, "load8_u", [59_898]), 0); |
| |
| // memory_copy.wast:3183 |
| assert_return(() => call($16, "load8_u", [60_097]), 0); |
| |
| // memory_copy.wast:3184 |
| assert_return(() => call($16, "load8_u", [60_296]), 0); |
| |
| // memory_copy.wast:3185 |
| assert_return(() => call($16, "load8_u", [60_495]), 0); |
| |
| // memory_copy.wast:3186 |
| assert_return(() => call($16, "load8_u", [60_694]), 0); |
| |
| // memory_copy.wast:3187 |
| assert_return(() => call($16, "load8_u", [60_893]), 0); |
| |
| // memory_copy.wast:3188 |
| assert_return(() => call($16, "load8_u", [61_092]), 0); |
| |
| // memory_copy.wast:3189 |
| assert_return(() => call($16, "load8_u", [61_291]), 0); |
| |
| // memory_copy.wast:3190 |
| assert_return(() => call($16, "load8_u", [61_490]), 0); |
| |
| // memory_copy.wast:3191 |
| assert_return(() => call($16, "load8_u", [61_689]), 0); |
| |
| // memory_copy.wast:3192 |
| assert_return(() => call($16, "load8_u", [61_888]), 0); |
| |
| // memory_copy.wast:3193 |
| assert_return(() => call($16, "load8_u", [62_087]), 0); |
| |
| // memory_copy.wast:3194 |
| assert_return(() => call($16, "load8_u", [62_286]), 0); |
| |
| // memory_copy.wast:3195 |
| assert_return(() => call($16, "load8_u", [62_485]), 0); |
| |
| // memory_copy.wast:3196 |
| assert_return(() => call($16, "load8_u", [62_684]), 0); |
| |
| // memory_copy.wast:3197 |
| assert_return(() => call($16, "load8_u", [62_883]), 0); |
| |
| // memory_copy.wast:3198 |
| assert_return(() => call($16, "load8_u", [63_082]), 0); |
| |
| // memory_copy.wast:3199 |
| assert_return(() => call($16, "load8_u", [63_281]), 0); |
| |
| // memory_copy.wast:3200 |
| assert_return(() => call($16, "load8_u", [63_480]), 0); |
| |
| // memory_copy.wast:3201 |
| assert_return(() => call($16, "load8_u", [63_679]), 0); |
| |
| // memory_copy.wast:3202 |
| assert_return(() => call($16, "load8_u", [63_878]), 0); |
| |
| // memory_copy.wast:3203 |
| assert_return(() => call($16, "load8_u", [64_077]), 0); |
| |
| // memory_copy.wast:3204 |
| assert_return(() => call($16, "load8_u", [64_276]), 0); |
| |
| // memory_copy.wast:3205 |
| assert_return(() => call($16, "load8_u", [64_475]), 0); |
| |
| // memory_copy.wast:3206 |
| assert_return(() => call($16, "load8_u", [64_674]), 0); |
| |
| // memory_copy.wast:3207 |
| assert_return(() => call($16, "load8_u", [64_873]), 0); |
| |
| // memory_copy.wast:3208 |
| assert_return(() => call($16, "load8_u", [65_072]), 0); |
| |
| // memory_copy.wast:3209 |
| assert_return(() => call($16, "load8_u", [65_271]), 0); |
| |
| // memory_copy.wast:3210 |
| assert_return(() => call($16, "load8_u", [65_470]), 0); |
| |
| // memory_copy.wast:3211 |
| assert_return(() => call($16, "load8_u", [65_516]), 0); |
| |
| // memory_copy.wast:3212 |
| assert_return(() => call($16, "load8_u", [65_517]), 1); |
| |
| // memory_copy.wast:3213 |
| assert_return(() => call($16, "load8_u", [65_518]), 2); |
| |
| // memory_copy.wast:3214 |
| assert_return(() => call($16, "load8_u", [65_519]), 3); |
| |
| // memory_copy.wast:3215 |
| assert_return(() => call($16, "load8_u", [65_520]), 4); |
| |
| // memory_copy.wast:3216 |
| assert_return(() => call($16, "load8_u", [65_521]), 5); |
| |
| // memory_copy.wast:3217 |
| assert_return(() => call($16, "load8_u", [65_522]), 6); |
| |
| // memory_copy.wast:3218 |
| assert_return(() => call($16, "load8_u", [65_523]), 7); |
| |
| // memory_copy.wast:3219 |
| assert_return(() => call($16, "load8_u", [65_524]), 8); |
| |
| // memory_copy.wast:3220 |
| assert_return(() => call($16, "load8_u", [65_525]), 9); |
| |
| // memory_copy.wast:3221 |
| assert_return(() => call($16, "load8_u", [65_526]), 10); |
| |
| // memory_copy.wast:3222 |
| assert_return(() => call($16, "load8_u", [65_527]), 11); |
| |
| // memory_copy.wast:3223 |
| assert_return(() => call($16, "load8_u", [65_528]), 12); |
| |
| // memory_copy.wast:3224 |
| assert_return(() => call($16, "load8_u", [65_529]), 13); |
| |
| // memory_copy.wast:3225 |
| assert_return(() => call($16, "load8_u", [65_530]), 14); |
| |
| // memory_copy.wast:3226 |
| assert_return(() => call($16, "load8_u", [65_531]), 15); |
| |
| // memory_copy.wast:3227 |
| assert_return(() => call($16, "load8_u", [65_532]), 16); |
| |
| // memory_copy.wast:3228 |
| assert_return(() => call($16, "load8_u", [65_533]), 17); |
| |
| // memory_copy.wast:3229 |
| assert_return(() => call($16, "load8_u", [65_534]), 18); |
| |
| // memory_copy.wast:3230 |
| assert_return(() => call($16, "load8_u", [65_535]), 19); |
| |
| // memory_copy.wast:3232 |
| 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:3240 |
| assert_trap(() => call($17, "run", [65_516, 65_516, 40])); |
| |
| // memory_copy.wast:3243 |
| assert_return(() => call($17, "load8_u", [198]), 0); |
| |
| // memory_copy.wast:3244 |
| assert_return(() => call($17, "load8_u", [397]), 0); |
| |
| // memory_copy.wast:3245 |
| assert_return(() => call($17, "load8_u", [596]), 0); |
| |
| // memory_copy.wast:3246 |
| assert_return(() => call($17, "load8_u", [795]), 0); |
| |
| // memory_copy.wast:3247 |
| assert_return(() => call($17, "load8_u", [994]), 0); |
| |
| // memory_copy.wast:3248 |
| assert_return(() => call($17, "load8_u", [1_193]), 0); |
| |
| // memory_copy.wast:3249 |
| assert_return(() => call($17, "load8_u", [1_392]), 0); |
| |
| // memory_copy.wast:3250 |
| assert_return(() => call($17, "load8_u", [1_591]), 0); |
| |
| // memory_copy.wast:3251 |
| assert_return(() => call($17, "load8_u", [1_790]), 0); |
| |
| // memory_copy.wast:3252 |
| assert_return(() => call($17, "load8_u", [1_989]), 0); |
| |
| // memory_copy.wast:3253 |
| assert_return(() => call($17, "load8_u", [2_188]), 0); |
| |
| // memory_copy.wast:3254 |
| assert_return(() => call($17, "load8_u", [2_387]), 0); |
| |
| // memory_copy.wast:3255 |
| assert_return(() => call($17, "load8_u", [2_586]), 0); |
| |
| // memory_copy.wast:3256 |
| assert_return(() => call($17, "load8_u", [2_785]), 0); |
| |
| // memory_copy.wast:3257 |
| assert_return(() => call($17, "load8_u", [2_984]), 0); |
| |
| // memory_copy.wast:3258 |
| assert_return(() => call($17, "load8_u", [3_183]), 0); |
| |
| // memory_copy.wast:3259 |
| assert_return(() => call($17, "load8_u", [3_382]), 0); |
| |
| // memory_copy.wast:3260 |
| assert_return(() => call($17, "load8_u", [3_581]), 0); |
| |
| // memory_copy.wast:3261 |
| assert_return(() => call($17, "load8_u", [3_780]), 0); |
| |
| // memory_copy.wast:3262 |
| assert_return(() => call($17, "load8_u", [3_979]), 0); |
| |
| // memory_copy.wast:3263 |
| assert_return(() => call($17, "load8_u", [4_178]), 0); |
| |
| // memory_copy.wast:3264 |
| assert_return(() => call($17, "load8_u", [4_377]), 0); |
| |
| // memory_copy.wast:3265 |
| assert_return(() => call($17, "load8_u", [4_576]), 0); |
| |
| // memory_copy.wast:3266 |
| assert_return(() => call($17, "load8_u", [4_775]), 0); |
| |
| // memory_copy.wast:3267 |
| assert_return(() => call($17, "load8_u", [4_974]), 0); |
| |
| // memory_copy.wast:3268 |
| assert_return(() => call($17, "load8_u", [5_173]), 0); |
| |
| // memory_copy.wast:3269 |
| assert_return(() => call($17, "load8_u", [5_372]), 0); |
| |
| // memory_copy.wast:3270 |
| assert_return(() => call($17, "load8_u", [5_571]), 0); |
| |
| // memory_copy.wast:3271 |
| assert_return(() => call($17, "load8_u", [5_770]), 0); |
| |
| // memory_copy.wast:3272 |
| assert_return(() => call($17, "load8_u", [5_969]), 0); |
| |
| // memory_copy.wast:3273 |
| assert_return(() => call($17, "load8_u", [6_168]), 0); |
| |
| // memory_copy.wast:3274 |
| assert_return(() => call($17, "load8_u", [6_367]), 0); |
| |
| // memory_copy.wast:3275 |
| assert_return(() => call($17, "load8_u", [6_566]), 0); |
| |
| // memory_copy.wast:3276 |
| assert_return(() => call($17, "load8_u", [6_765]), 0); |
| |
| // memory_copy.wast:3277 |
| assert_return(() => call($17, "load8_u", [6_964]), 0); |
| |
| // memory_copy.wast:3278 |
| assert_return(() => call($17, "load8_u", [7_163]), 0); |
| |
| // memory_copy.wast:3279 |
| assert_return(() => call($17, "load8_u", [7_362]), 0); |
| |
| // memory_copy.wast:3280 |
| assert_return(() => call($17, "load8_u", [7_561]), 0); |
| |
| // memory_copy.wast:3281 |
| assert_return(() => call($17, "load8_u", [7_760]), 0); |
| |
| // memory_copy.wast:3282 |
| assert_return(() => call($17, "load8_u", [7_959]), 0); |
| |
| // memory_copy.wast:3283 |
| assert_return(() => call($17, "load8_u", [8_158]), 0); |
| |
| // memory_copy.wast:3284 |
| assert_return(() => call($17, "load8_u", [8_357]), 0); |
| |
| // memory_copy.wast:3285 |
| assert_return(() => call($17, "load8_u", [8_556]), 0); |
| |
| // memory_copy.wast:3286 |
| assert_return(() => call($17, "load8_u", [8_755]), 0); |
| |
| // memory_copy.wast:3287 |
| assert_return(() => call($17, "load8_u", [8_954]), 0); |
| |
| // memory_copy.wast:3288 |
| assert_return(() => call($17, "load8_u", [9_153]), 0); |
| |
| // memory_copy.wast:3289 |
| assert_return(() => call($17, "load8_u", [9_352]), 0); |
| |
| // memory_copy.wast:3290 |
| assert_return(() => call($17, "load8_u", [9_551]), 0); |
| |
| // memory_copy.wast:3291 |
| assert_return(() => call($17, "load8_u", [9_750]), 0); |
| |
| // memory_copy.wast:3292 |
| assert_return(() => call($17, "load8_u", [9_949]), 0); |
| |
| // memory_copy.wast:3293 |
| assert_return(() => call($17, "load8_u", [10_148]), 0); |
| |
| // memory_copy.wast:3294 |
| assert_return(() => call($17, "load8_u", [10_347]), 0); |
| |
| // memory_copy.wast:3295 |
| assert_return(() => call($17, "load8_u", [10_546]), 0); |
| |
| // memory_copy.wast:3296 |
| assert_return(() => call($17, "load8_u", [10_745]), 0); |
| |
| // memory_copy.wast:3297 |
| assert_return(() => call($17, "load8_u", [10_944]), 0); |
| |
| // memory_copy.wast:3298 |
| assert_return(() => call($17, "load8_u", [11_143]), 0); |
| |
| // memory_copy.wast:3299 |
| assert_return(() => call($17, "load8_u", [11_342]), 0); |
| |
| // memory_copy.wast:3300 |
| assert_return(() => call($17, "load8_u", [11_541]), 0); |
| |
| // memory_copy.wast:3301 |
| assert_return(() => call($17, "load8_u", [11_740]), 0); |
| |
| // memory_copy.wast:3302 |
| assert_return(() => call($17, "load8_u", [11_939]), 0); |
| |
| // memory_copy.wast:3303 |
| assert_return(() => call($17, "load8_u", [12_138]), 0); |
| |
| // memory_copy.wast:3304 |
| assert_return(() => call($17, "load8_u", [12_337]), 0); |
| |
| // memory_copy.wast:3305 |
| assert_return(() => call($17, "load8_u", [12_536]), 0); |
| |
| // memory_copy.wast:3306 |
| assert_return(() => call($17, "load8_u", [12_735]), 0); |
| |
| // memory_copy.wast:3307 |
| assert_return(() => call($17, "load8_u", [12_934]), 0); |
| |
| // memory_copy.wast:3308 |
| assert_return(() => call($17, "load8_u", [13_133]), 0); |
| |
| // memory_copy.wast:3309 |
| assert_return(() => call($17, "load8_u", [13_332]), 0); |
| |
| // memory_copy.wast:3310 |
| assert_return(() => call($17, "load8_u", [13_531]), 0); |
| |
| // memory_copy.wast:3311 |
| assert_return(() => call($17, "load8_u", [13_730]), 0); |
| |
| // memory_copy.wast:3312 |
| assert_return(() => call($17, "load8_u", [13_929]), 0); |
| |
| // memory_copy.wast:3313 |
| assert_return(() => call($17, "load8_u", [14_128]), 0); |
| |
| // memory_copy.wast:3314 |
| assert_return(() => call($17, "load8_u", [14_327]), 0); |
| |
| // memory_copy.wast:3315 |
| assert_return(() => call($17, "load8_u", [14_526]), 0); |
| |
| // memory_copy.wast:3316 |
| assert_return(() => call($17, "load8_u", [14_725]), 0); |
| |
| // memory_copy.wast:3317 |
| assert_return(() => call($17, "load8_u", [14_924]), 0); |
| |
| // memory_copy.wast:3318 |
| assert_return(() => call($17, "load8_u", [15_123]), 0); |
| |
| // memory_copy.wast:3319 |
| assert_return(() => call($17, "load8_u", [15_322]), 0); |
| |
| // memory_copy.wast:3320 |
| assert_return(() => call($17, "load8_u", [15_521]), 0); |
| |
| // memory_copy.wast:3321 |
| assert_return(() => call($17, "load8_u", [15_720]), 0); |
| |
| // memory_copy.wast:3322 |
| assert_return(() => call($17, "load8_u", [15_919]), 0); |
| |
| // memory_copy.wast:3323 |
| assert_return(() => call($17, "load8_u", [16_118]), 0); |
| |
| // memory_copy.wast:3324 |
| assert_return(() => call($17, "load8_u", [16_317]), 0); |
| |
| // memory_copy.wast:3325 |
| assert_return(() => call($17, "load8_u", [16_516]), 0); |
| |
| // memory_copy.wast:3326 |
| assert_return(() => call($17, "load8_u", [16_715]), 0); |
| |
| // memory_copy.wast:3327 |
| assert_return(() => call($17, "load8_u", [16_914]), 0); |
| |
| // memory_copy.wast:3328 |
| assert_return(() => call($17, "load8_u", [17_113]), 0); |
| |
| // memory_copy.wast:3329 |
| assert_return(() => call($17, "load8_u", [17_312]), 0); |
| |
| // memory_copy.wast:3330 |
| assert_return(() => call($17, "load8_u", [17_511]), 0); |
| |
| // memory_copy.wast:3331 |
| assert_return(() => call($17, "load8_u", [17_710]), 0); |
| |
| // memory_copy.wast:3332 |
| assert_return(() => call($17, "load8_u", [17_909]), 0); |
| |
| // memory_copy.wast:3333 |
| assert_return(() => call($17, "load8_u", [18_108]), 0); |
| |
| // memory_copy.wast:3334 |
| assert_return(() => call($17, "load8_u", [18_307]), 0); |
| |
| // memory_copy.wast:3335 |
| assert_return(() => call($17, "load8_u", [18_506]), 0); |
| |
| // memory_copy.wast:3336 |
| assert_return(() => call($17, "load8_u", [18_705]), 0); |
| |
| // memory_copy.wast:3337 |
| assert_return(() => call($17, "load8_u", [18_904]), 0); |
| |
| // memory_copy.wast:3338 |
| assert_return(() => call($17, "load8_u", [19_103]), 0); |
| |
| // memory_copy.wast:3339 |
| assert_return(() => call($17, "load8_u", [19_302]), 0); |
| |
| // memory_copy.wast:3340 |
| assert_return(() => call($17, "load8_u", [19_501]), 0); |
| |
| // memory_copy.wast:3341 |
| assert_return(() => call($17, "load8_u", [19_700]), 0); |
| |
| // memory_copy.wast:3342 |
| assert_return(() => call($17, "load8_u", [19_899]), 0); |
| |
| // memory_copy.wast:3343 |
| assert_return(() => call($17, "load8_u", [20_098]), 0); |
| |
| // memory_copy.wast:3344 |
| assert_return(() => call($17, "load8_u", [20_297]), 0); |
| |
| // memory_copy.wast:3345 |
| assert_return(() => call($17, "load8_u", [20_496]), 0); |
| |
| // memory_copy.wast:3346 |
| assert_return(() => call($17, "load8_u", [20_695]), 0); |
| |
| // memory_copy.wast:3347 |
| assert_return(() => call($17, "load8_u", [20_894]), 0); |
| |
| // memory_copy.wast:3348 |
| assert_return(() => call($17, "load8_u", [21_093]), 0); |
| |
| // memory_copy.wast:3349 |
| assert_return(() => call($17, "load8_u", [21_292]), 0); |
| |
| // memory_copy.wast:3350 |
| assert_return(() => call($17, "load8_u", [21_491]), 0); |
| |
| // memory_copy.wast:3351 |
| assert_return(() => call($17, "load8_u", [21_690]), 0); |
| |
| // memory_copy.wast:3352 |
| assert_return(() => call($17, "load8_u", [21_889]), 0); |
| |
| // memory_copy.wast:3353 |
| assert_return(() => call($17, "load8_u", [22_088]), 0); |
| |
| // memory_copy.wast:3354 |
| assert_return(() => call($17, "load8_u", [22_287]), 0); |
| |
| // memory_copy.wast:3355 |
| assert_return(() => call($17, "load8_u", [22_486]), 0); |
| |
| // memory_copy.wast:3356 |
| assert_return(() => call($17, "load8_u", [22_685]), 0); |
| |
| // memory_copy.wast:3357 |
| assert_return(() => call($17, "load8_u", [22_884]), 0); |
| |
| // memory_copy.wast:3358 |
| assert_return(() => call($17, "load8_u", [23_083]), 0); |
| |
| // memory_copy.wast:3359 |
| assert_return(() => call($17, "load8_u", [23_282]), 0); |
| |
| // memory_copy.wast:3360 |
| assert_return(() => call($17, "load8_u", [23_481]), 0); |
| |
| // memory_copy.wast:3361 |
| assert_return(() => call($17, "load8_u", [23_680]), 0); |
| |
| // memory_copy.wast:3362 |
| assert_return(() => call($17, "load8_u", [23_879]), 0); |
| |
| // memory_copy.wast:3363 |
| assert_return(() => call($17, "load8_u", [24_078]), 0); |
| |
| // memory_copy.wast:3364 |
| assert_return(() => call($17, "load8_u", [24_277]), 0); |
| |
| // memory_copy.wast:3365 |
| assert_return(() => call($17, "load8_u", [24_476]), 0); |
| |
| // memory_copy.wast:3366 |
| assert_return(() => call($17, "load8_u", [24_675]), 0); |
| |
| // memory_copy.wast:3367 |
| assert_return(() => call($17, "load8_u", [24_874]), 0); |
| |
| // memory_copy.wast:3368 |
| assert_return(() => call($17, "load8_u", [25_073]), 0); |
| |
| // memory_copy.wast:3369 |
| assert_return(() => call($17, "load8_u", [25_272]), 0); |
| |
| // memory_copy.wast:3370 |
| assert_return(() => call($17, "load8_u", [25_471]), 0); |
| |
| // memory_copy.wast:3371 |
| assert_return(() => call($17, "load8_u", [25_670]), 0); |
| |
| // memory_copy.wast:3372 |
| assert_return(() => call($17, "load8_u", [25_869]), 0); |
| |
| // memory_copy.wast:3373 |
| assert_return(() => call($17, "load8_u", [26_068]), 0); |
| |
| // memory_copy.wast:3374 |
| assert_return(() => call($17, "load8_u", [26_267]), 0); |
| |
| // memory_copy.wast:3375 |
| assert_return(() => call($17, "load8_u", [26_466]), 0); |
| |
| // memory_copy.wast:3376 |
| assert_return(() => call($17, "load8_u", [26_665]), 0); |
| |
| // memory_copy.wast:3377 |
| assert_return(() => call($17, "load8_u", [26_864]), 0); |
| |
| // memory_copy.wast:3378 |
| assert_return(() => call($17, "load8_u", [27_063]), 0); |
| |
| // memory_copy.wast:3379 |
| assert_return(() => call($17, "load8_u", [27_262]), 0); |
| |
| // memory_copy.wast:3380 |
| assert_return(() => call($17, "load8_u", [27_461]), 0); |
| |
| // memory_copy.wast:3381 |
| assert_return(() => call($17, "load8_u", [27_660]), 0); |
| |
| // memory_copy.wast:3382 |
| assert_return(() => call($17, "load8_u", [27_859]), 0); |
| |
| // memory_copy.wast:3383 |
| assert_return(() => call($17, "load8_u", [28_058]), 0); |
| |
| // memory_copy.wast:3384 |
| assert_return(() => call($17, "load8_u", [28_257]), 0); |
| |
| // memory_copy.wast:3385 |
| assert_return(() => call($17, "load8_u", [28_456]), 0); |
| |
| // memory_copy.wast:3386 |
| assert_return(() => call($17, "load8_u", [28_655]), 0); |
| |
| // memory_copy.wast:3387 |
| assert_return(() => call($17, "load8_u", [28_854]), 0); |
| |
| // memory_copy.wast:3388 |
| assert_return(() => call($17, "load8_u", [29_053]), 0); |
| |
| // memory_copy.wast:3389 |
| assert_return(() => call($17, "load8_u", [29_252]), 0); |
| |
| // memory_copy.wast:3390 |
| assert_return(() => call($17, "load8_u", [29_451]), 0); |
| |
| // memory_copy.wast:3391 |
| assert_return(() => call($17, "load8_u", [29_650]), 0); |
| |
| // memory_copy.wast:3392 |
| assert_return(() => call($17, "load8_u", [29_849]), 0); |
| |
| // memory_copy.wast:3393 |
| assert_return(() => call($17, "load8_u", [30_048]), 0); |
| |
| // memory_copy.wast:3394 |
| assert_return(() => call($17, "load8_u", [30_247]), 0); |
| |
| // memory_copy.wast:3395 |
| assert_return(() => call($17, "load8_u", [30_446]), 0); |
| |
| // memory_copy.wast:3396 |
| assert_return(() => call($17, "load8_u", [30_645]), 0); |
| |
| // memory_copy.wast:3397 |
| assert_return(() => call($17, "load8_u", [30_844]), 0); |
| |
| // memory_copy.wast:3398 |
| assert_return(() => call($17, "load8_u", [31_043]), 0); |
| |
| // memory_copy.wast:3399 |
| assert_return(() => call($17, "load8_u", [31_242]), 0); |
| |
| // memory_copy.wast:3400 |
| assert_return(() => call($17, "load8_u", [31_441]), 0); |
| |
| // memory_copy.wast:3401 |
| assert_return(() => call($17, "load8_u", [31_640]), 0); |
| |
| // memory_copy.wast:3402 |
| assert_return(() => call($17, "load8_u", [31_839]), 0); |
| |
| // memory_copy.wast:3403 |
| assert_return(() => call($17, "load8_u", [32_038]), 0); |
| |
| // memory_copy.wast:3404 |
| assert_return(() => call($17, "load8_u", [32_237]), 0); |
| |
| // memory_copy.wast:3405 |
| assert_return(() => call($17, "load8_u", [32_436]), 0); |
| |
| // memory_copy.wast:3406 |
| assert_return(() => call($17, "load8_u", [32_635]), 0); |
| |
| // memory_copy.wast:3407 |
| assert_return(() => call($17, "load8_u", [32_834]), 0); |
| |
| // memory_copy.wast:3408 |
| assert_return(() => call($17, "load8_u", [33_033]), 0); |
| |
| // memory_copy.wast:3409 |
| assert_return(() => call($17, "load8_u", [33_232]), 0); |
| |
| // memory_copy.wast:3410 |
| assert_return(() => call($17, "load8_u", [33_431]), 0); |
| |
| // memory_copy.wast:3411 |
| assert_return(() => call($17, "load8_u", [33_630]), 0); |
| |
| // memory_copy.wast:3412 |
| assert_return(() => call($17, "load8_u", [33_829]), 0); |
| |
| // memory_copy.wast:3413 |
| assert_return(() => call($17, "load8_u", [34_028]), 0); |
| |
| // memory_copy.wast:3414 |
| assert_return(() => call($17, "load8_u", [34_227]), 0); |
| |
| // memory_copy.wast:3415 |
| assert_return(() => call($17, "load8_u", [34_426]), 0); |
| |
| // memory_copy.wast:3416 |
| assert_return(() => call($17, "load8_u", [34_625]), 0); |
| |
| // memory_copy.wast:3417 |
| assert_return(() => call($17, "load8_u", [34_824]), 0); |
| |
| // memory_copy.wast:3418 |
| assert_return(() => call($17, "load8_u", [35_023]), 0); |
| |
| // memory_copy.wast:3419 |
| assert_return(() => call($17, "load8_u", [35_222]), 0); |
| |
| // memory_copy.wast:3420 |
| assert_return(() => call($17, "load8_u", [35_421]), 0); |
| |
| // memory_copy.wast:3421 |
| assert_return(() => call($17, "load8_u", [35_620]), 0); |
| |
| // memory_copy.wast:3422 |
| assert_return(() => call($17, "load8_u", [35_819]), 0); |
| |
| // memory_copy.wast:3423 |
| assert_return(() => call($17, "load8_u", [36_018]), 0); |
| |
| // memory_copy.wast:3424 |
| assert_return(() => call($17, "load8_u", [36_217]), 0); |
| |
| // memory_copy.wast:3425 |
| assert_return(() => call($17, "load8_u", [36_416]), 0); |
| |
| // memory_copy.wast:3426 |
| assert_return(() => call($17, "load8_u", [36_615]), 0); |
| |
| // memory_copy.wast:3427 |
| assert_return(() => call($17, "load8_u", [36_814]), 0); |
| |
| // memory_copy.wast:3428 |
| assert_return(() => call($17, "load8_u", [37_013]), 0); |
| |
| // memory_copy.wast:3429 |
| assert_return(() => call($17, "load8_u", [37_212]), 0); |
| |
| // memory_copy.wast:3430 |
| assert_return(() => call($17, "load8_u", [37_411]), 0); |
| |
| // memory_copy.wast:3431 |
| assert_return(() => call($17, "load8_u", [37_610]), 0); |
| |
| // memory_copy.wast:3432 |
| assert_return(() => call($17, "load8_u", [37_809]), 0); |
| |
| // memory_copy.wast:3433 |
| assert_return(() => call($17, "load8_u", [38_008]), 0); |
| |
| // memory_copy.wast:3434 |
| assert_return(() => call($17, "load8_u", [38_207]), 0); |
| |
| // memory_copy.wast:3435 |
| assert_return(() => call($17, "load8_u", [38_406]), 0); |
| |
| // memory_copy.wast:3436 |
| assert_return(() => call($17, "load8_u", [38_605]), 0); |
| |
| // memory_copy.wast:3437 |
| assert_return(() => call($17, "load8_u", [38_804]), 0); |
| |
| // memory_copy.wast:3438 |
| assert_return(() => call($17, "load8_u", [39_003]), 0); |
| |
| // memory_copy.wast:3439 |
| assert_return(() => call($17, "load8_u", [39_202]), 0); |
| |
| // memory_copy.wast:3440 |
| assert_return(() => call($17, "load8_u", [39_401]), 0); |
| |
| // memory_copy.wast:3441 |
| assert_return(() => call($17, "load8_u", [39_600]), 0); |
| |
| // memory_copy.wast:3442 |
| assert_return(() => call($17, "load8_u", [39_799]), 0); |
| |
| // memory_copy.wast:3443 |
| assert_return(() => call($17, "load8_u", [39_998]), 0); |
| |
| // memory_copy.wast:3444 |
| assert_return(() => call($17, "load8_u", [40_197]), 0); |
| |
| // memory_copy.wast:3445 |
| assert_return(() => call($17, "load8_u", [40_396]), 0); |
| |
| // memory_copy.wast:3446 |
| assert_return(() => call($17, "load8_u", [40_595]), 0); |
| |
| // memory_copy.wast:3447 |
| assert_return(() => call($17, "load8_u", [40_794]), 0); |
| |
| // memory_copy.wast:3448 |
| assert_return(() => call($17, "load8_u", [40_993]), 0); |
| |
| // memory_copy.wast:3449 |
| assert_return(() => call($17, "load8_u", [41_192]), 0); |
| |
| // memory_copy.wast:3450 |
| assert_return(() => call($17, "load8_u", [41_391]), 0); |
| |
| // memory_copy.wast:3451 |
| assert_return(() => call($17, "load8_u", [41_590]), 0); |
| |
| // memory_copy.wast:3452 |
| assert_return(() => call($17, "load8_u", [41_789]), 0); |
| |
| // memory_copy.wast:3453 |
| assert_return(() => call($17, "load8_u", [41_988]), 0); |
| |
| // memory_copy.wast:3454 |
| assert_return(() => call($17, "load8_u", [42_187]), 0); |
| |
| // memory_copy.wast:3455 |
| assert_return(() => call($17, "load8_u", [42_386]), 0); |
| |
| // memory_copy.wast:3456 |
| assert_return(() => call($17, "load8_u", [42_585]), 0); |
| |
| // memory_copy.wast:3457 |
| assert_return(() => call($17, "load8_u", [42_784]), 0); |
| |
| // memory_copy.wast:3458 |
| assert_return(() => call($17, "load8_u", [42_983]), 0); |
| |
| // memory_copy.wast:3459 |
| assert_return(() => call($17, "load8_u", [43_182]), 0); |
| |
| // memory_copy.wast:3460 |
| assert_return(() => call($17, "load8_u", [43_381]), 0); |
| |
| // memory_copy.wast:3461 |
| assert_return(() => call($17, "load8_u", [43_580]), 0); |
| |
| // memory_copy.wast:3462 |
| assert_return(() => call($17, "load8_u", [43_779]), 0); |
| |
| // memory_copy.wast:3463 |
| assert_return(() => call($17, "load8_u", [43_978]), 0); |
| |
| // memory_copy.wast:3464 |
| assert_return(() => call($17, "load8_u", [44_177]), 0); |
| |
| // memory_copy.wast:3465 |
| assert_return(() => call($17, "load8_u", [44_376]), 0); |
| |
| // memory_copy.wast:3466 |
| assert_return(() => call($17, "load8_u", [44_575]), 0); |
| |
| // memory_copy.wast:3467 |
| assert_return(() => call($17, "load8_u", [44_774]), 0); |
| |
| // memory_copy.wast:3468 |
| assert_return(() => call($17, "load8_u", [44_973]), 0); |
| |
| // memory_copy.wast:3469 |
| assert_return(() => call($17, "load8_u", [45_172]), 0); |
| |
| // memory_copy.wast:3470 |
| assert_return(() => call($17, "load8_u", [45_371]), 0); |
| |
| // memory_copy.wast:3471 |
| assert_return(() => call($17, "load8_u", [45_570]), 0); |
| |
| // memory_copy.wast:3472 |
| assert_return(() => call($17, "load8_u", [45_769]), 0); |
| |
| // memory_copy.wast:3473 |
| assert_return(() => call($17, "load8_u", [45_968]), 0); |
| |
| // memory_copy.wast:3474 |
| assert_return(() => call($17, "load8_u", [46_167]), 0); |
| |
| // memory_copy.wast:3475 |
| assert_return(() => call($17, "load8_u", [46_366]), 0); |
| |
| // memory_copy.wast:3476 |
| assert_return(() => call($17, "load8_u", [46_565]), 0); |
| |
| // memory_copy.wast:3477 |
| assert_return(() => call($17, "load8_u", [46_764]), 0); |
| |
| // memory_copy.wast:3478 |
| assert_return(() => call($17, "load8_u", [46_963]), 0); |
| |
| // memory_copy.wast:3479 |
| assert_return(() => call($17, "load8_u", [47_162]), 0); |
| |
| // memory_copy.wast:3480 |
| assert_return(() => call($17, "load8_u", [47_361]), 0); |
| |
| // memory_copy.wast:3481 |
| assert_return(() => call($17, "load8_u", [47_560]), 0); |
| |
| // memory_copy.wast:3482 |
| assert_return(() => call($17, "load8_u", [47_759]), 0); |
| |
| // memory_copy.wast:3483 |
| assert_return(() => call($17, "load8_u", [47_958]), 0); |
| |
| // memory_copy.wast:3484 |
| assert_return(() => call($17, "load8_u", [48_157]), 0); |
| |
| // memory_copy.wast:3485 |
| assert_return(() => call($17, "load8_u", [48_356]), 0); |
| |
| // memory_copy.wast:3486 |
| assert_return(() => call($17, "load8_u", [48_555]), 0); |
| |
| // memory_copy.wast:3487 |
| assert_return(() => call($17, "load8_u", [48_754]), 0); |
| |
| // memory_copy.wast:3488 |
| assert_return(() => call($17, "load8_u", [48_953]), 0); |
| |
| // memory_copy.wast:3489 |
| assert_return(() => call($17, "load8_u", [49_152]), 0); |
| |
| // memory_copy.wast:3490 |
| assert_return(() => call($17, "load8_u", [49_351]), 0); |
| |
| // memory_copy.wast:3491 |
| assert_return(() => call($17, "load8_u", [49_550]), 0); |
| |
| // memory_copy.wast:3492 |
| assert_return(() => call($17, "load8_u", [49_749]), 0); |
| |
| // memory_copy.wast:3493 |
| assert_return(() => call($17, "load8_u", [49_948]), 0); |
| |
| // memory_copy.wast:3494 |
| assert_return(() => call($17, "load8_u", [50_147]), 0); |
| |
| // memory_copy.wast:3495 |
| assert_return(() => call($17, "load8_u", [50_346]), 0); |
| |
| // memory_copy.wast:3496 |
| assert_return(() => call($17, "load8_u", [50_545]), 0); |
| |
| // memory_copy.wast:3497 |
| assert_return(() => call($17, "load8_u", [50_744]), 0); |
| |
| // memory_copy.wast:3498 |
| assert_return(() => call($17, "load8_u", [50_943]), 0); |
| |
| // memory_copy.wast:3499 |
| assert_return(() => call($17, "load8_u", [51_142]), 0); |
| |
| // memory_copy.wast:3500 |
| assert_return(() => call($17, "load8_u", [51_341]), 0); |
| |
| // memory_copy.wast:3501 |
| assert_return(() => call($17, "load8_u", [51_540]), 0); |
| |
| // memory_copy.wast:3502 |
| assert_return(() => call($17, "load8_u", [51_739]), 0); |
| |
| // memory_copy.wast:3503 |
| assert_return(() => call($17, "load8_u", [51_938]), 0); |
| |
| // memory_copy.wast:3504 |
| assert_return(() => call($17, "load8_u", [52_137]), 0); |
| |
| // memory_copy.wast:3505 |
| assert_return(() => call($17, "load8_u", [52_336]), 0); |
| |
| // memory_copy.wast:3506 |
| assert_return(() => call($17, "load8_u", [52_535]), 0); |
| |
| // memory_copy.wast:3507 |
| assert_return(() => call($17, "load8_u", [52_734]), 0); |
| |
| // memory_copy.wast:3508 |
| assert_return(() => call($17, "load8_u", [52_933]), 0); |
| |
| // memory_copy.wast:3509 |
| assert_return(() => call($17, "load8_u", [53_132]), 0); |
| |
| // memory_copy.wast:3510 |
| assert_return(() => call($17, "load8_u", [53_331]), 0); |
| |
| // memory_copy.wast:3511 |
| assert_return(() => call($17, "load8_u", [53_530]), 0); |
| |
| // memory_copy.wast:3512 |
| assert_return(() => call($17, "load8_u", [53_729]), 0); |
| |
| // memory_copy.wast:3513 |
| assert_return(() => call($17, "load8_u", [53_928]), 0); |
| |
| // memory_copy.wast:3514 |
| assert_return(() => call($17, "load8_u", [54_127]), 0); |
| |
| // memory_copy.wast:3515 |
| assert_return(() => call($17, "load8_u", [54_326]), 0); |
| |
| // memory_copy.wast:3516 |
| assert_return(() => call($17, "load8_u", [54_525]), 0); |
| |
| // memory_copy.wast:3517 |
| assert_return(() => call($17, "load8_u", [54_724]), 0); |
| |
| // memory_copy.wast:3518 |
| assert_return(() => call($17, "load8_u", [54_923]), 0); |
| |
| // memory_copy.wast:3519 |
| assert_return(() => call($17, "load8_u", [55_122]), 0); |
| |
| // memory_copy.wast:3520 |
| assert_return(() => call($17, "load8_u", [55_321]), 0); |
| |
| // memory_copy.wast:3521 |
| assert_return(() => call($17, "load8_u", [55_520]), 0); |
| |
| // memory_copy.wast:3522 |
| assert_return(() => call($17, "load8_u", [55_719]), 0); |
| |
| // memory_copy.wast:3523 |
| assert_return(() => call($17, "load8_u", [55_918]), 0); |
| |
| // memory_copy.wast:3524 |
| assert_return(() => call($17, "load8_u", [56_117]), 0); |
| |
| // memory_copy.wast:3525 |
| assert_return(() => call($17, "load8_u", [56_316]), 0); |
| |
| // memory_copy.wast:3526 |
| assert_return(() => call($17, "load8_u", [56_515]), 0); |
| |
| // memory_copy.wast:3527 |
| assert_return(() => call($17, "load8_u", [56_714]), 0); |
| |
| // memory_copy.wast:3528 |
| assert_return(() => call($17, "load8_u", [56_913]), 0); |
| |
| // memory_copy.wast:3529 |
| assert_return(() => call($17, "load8_u", [57_112]), 0); |
| |
| // memory_copy.wast:3530 |
| assert_return(() => call($17, "load8_u", [57_311]), 0); |
| |
| // memory_copy.wast:3531 |
| assert_return(() => call($17, "load8_u", [57_510]), 0); |
| |
| // memory_copy.wast:3532 |
| assert_return(() => call($17, "load8_u", [57_709]), 0); |
| |
| // memory_copy.wast:3533 |
| assert_return(() => call($17, "load8_u", [57_908]), 0); |
| |
| // memory_copy.wast:3534 |
| assert_return(() => call($17, "load8_u", [58_107]), 0); |
| |
| // memory_copy.wast:3535 |
| assert_return(() => call($17, "load8_u", [58_306]), 0); |
| |
| // memory_copy.wast:3536 |
| assert_return(() => call($17, "load8_u", [58_505]), 0); |
| |
| // memory_copy.wast:3537 |
| assert_return(() => call($17, "load8_u", [58_704]), 0); |
| |
| // memory_copy.wast:3538 |
| assert_return(() => call($17, "load8_u", [58_903]), 0); |
| |
| // memory_copy.wast:3539 |
| assert_return(() => call($17, "load8_u", [59_102]), 0); |
| |
| // memory_copy.wast:3540 |
| assert_return(() => call($17, "load8_u", [59_301]), 0); |
| |
| // memory_copy.wast:3541 |
| assert_return(() => call($17, "load8_u", [59_500]), 0); |
| |
| // memory_copy.wast:3542 |
| assert_return(() => call($17, "load8_u", [59_699]), 0); |
| |
| // memory_copy.wast:3543 |
| assert_return(() => call($17, "load8_u", [59_898]), 0); |
| |
| // memory_copy.wast:3544 |
| assert_return(() => call($17, "load8_u", [60_097]), 0); |
| |
| // memory_copy.wast:3545 |
| assert_return(() => call($17, "load8_u", [60_296]), 0); |
| |
| // memory_copy.wast:3546 |
| assert_return(() => call($17, "load8_u", [60_495]), 0); |
| |
| // memory_copy.wast:3547 |
| assert_return(() => call($17, "load8_u", [60_694]), 0); |
| |
| // memory_copy.wast:3548 |
| assert_return(() => call($17, "load8_u", [60_893]), 0); |
| |
| // memory_copy.wast:3549 |
| assert_return(() => call($17, "load8_u", [61_092]), 0); |
| |
| // memory_copy.wast:3550 |
| assert_return(() => call($17, "load8_u", [61_291]), 0); |
| |
| // memory_copy.wast:3551 |
| assert_return(() => call($17, "load8_u", [61_490]), 0); |
| |
| // memory_copy.wast:3552 |
| assert_return(() => call($17, "load8_u", [61_689]), 0); |
| |
| // memory_copy.wast:3553 |
| assert_return(() => call($17, "load8_u", [61_888]), 0); |
| |
| // memory_copy.wast:3554 |
| assert_return(() => call($17, "load8_u", [62_087]), 0); |
| |
| // memory_copy.wast:3555 |
| assert_return(() => call($17, "load8_u", [62_286]), 0); |
| |
| // memory_copy.wast:3556 |
| assert_return(() => call($17, "load8_u", [62_485]), 0); |
| |
| // memory_copy.wast:3557 |
| assert_return(() => call($17, "load8_u", [62_684]), 0); |
| |
| // memory_copy.wast:3558 |
| assert_return(() => call($17, "load8_u", [62_883]), 0); |
| |
| // memory_copy.wast:3559 |
| assert_return(() => call($17, "load8_u", [63_082]), 0); |
| |
| // memory_copy.wast:3560 |
| assert_return(() => call($17, "load8_u", [63_281]), 0); |
| |
| // memory_copy.wast:3561 |
| assert_return(() => call($17, "load8_u", [63_480]), 0); |
| |
| // memory_copy.wast:3562 |
| assert_return(() => call($17, "load8_u", [63_679]), 0); |
| |
| // memory_copy.wast:3563 |
| assert_return(() => call($17, "load8_u", [63_878]), 0); |
| |
| // memory_copy.wast:3564 |
| assert_return(() => call($17, "load8_u", [64_077]), 0); |
| |
| // memory_copy.wast:3565 |
| assert_return(() => call($17, "load8_u", [64_276]), 0); |
| |
| // memory_copy.wast:3566 |
| assert_return(() => call($17, "load8_u", [64_475]), 0); |
| |
| // memory_copy.wast:3567 |
| assert_return(() => call($17, "load8_u", [64_674]), 0); |
| |
| // memory_copy.wast:3568 |
| assert_return(() => call($17, "load8_u", [64_873]), 0); |
| |
| // memory_copy.wast:3569 |
| assert_return(() => call($17, "load8_u", [65_072]), 0); |
| |
| // memory_copy.wast:3570 |
| assert_return(() => call($17, "load8_u", [65_271]), 0); |
| |
| // memory_copy.wast:3571 |
| assert_return(() => call($17, "load8_u", [65_470]), 0); |
| |
| // memory_copy.wast:3572 |
| assert_return(() => call($17, "load8_u", [65_516]), 0); |
| |
| // memory_copy.wast:3573 |
| assert_return(() => call($17, "load8_u", [65_517]), 1); |
| |
| // memory_copy.wast:3574 |
| assert_return(() => call($17, "load8_u", [65_518]), 2); |
| |
| // memory_copy.wast:3575 |
| assert_return(() => call($17, "load8_u", [65_519]), 3); |
| |
| // memory_copy.wast:3576 |
| assert_return(() => call($17, "load8_u", [65_520]), 4); |
| |
| // memory_copy.wast:3577 |
| assert_return(() => call($17, "load8_u", [65_521]), 5); |
| |
| // memory_copy.wast:3578 |
| assert_return(() => call($17, "load8_u", [65_522]), 6); |
| |
| // memory_copy.wast:3579 |
| assert_return(() => call($17, "load8_u", [65_523]), 7); |
| |
| // memory_copy.wast:3580 |
| assert_return(() => call($17, "load8_u", [65_524]), 8); |
| |
| // memory_copy.wast:3581 |
| assert_return(() => call($17, "load8_u", [65_525]), 9); |
| |
| // memory_copy.wast:3582 |
| assert_return(() => call($17, "load8_u", [65_526]), 10); |
| |
| // memory_copy.wast:3583 |
| assert_return(() => call($17, "load8_u", [65_527]), 11); |
| |
| // memory_copy.wast:3584 |
| assert_return(() => call($17, "load8_u", [65_528]), 12); |
| |
| // memory_copy.wast:3585 |
| assert_return(() => call($17, "load8_u", [65_529]), 13); |
| |
| // memory_copy.wast:3586 |
| assert_return(() => call($17, "load8_u", [65_530]), 14); |
| |
| // memory_copy.wast:3587 |
| assert_return(() => call($17, "load8_u", [65_531]), 15); |
| |
| // memory_copy.wast:3588 |
| assert_return(() => call($17, "load8_u", [65_532]), 16); |
| |
| // memory_copy.wast:3589 |
| assert_return(() => call($17, "load8_u", [65_533]), 17); |
| |
| // memory_copy.wast:3590 |
| assert_return(() => call($17, "load8_u", [65_534]), 18); |
| |
| // memory_copy.wast:3591 |
| assert_return(() => call($17, "load8_u", [65_535]), 19); |
| |
| // memory_copy.wast:3593 |
| let $18 = 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\x83\x80\x80\x80\x00\x01\x00\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:3601 |
| assert_trap(() => call($18, "run", [0, 65_516, -4_096])); |
| |
| // memory_copy.wast:3604 |
| assert_return(() => call($18, "load8_u", [198]), 0); |
| |
| // memory_copy.wast:3605 |
| assert_return(() => call($18, "load8_u", [397]), 0); |
| |
| // memory_copy.wast:3606 |
| assert_return(() => call($18, "load8_u", [596]), 0); |
| |
| // memory_copy.wast:3607 |
| assert_return(() => call($18, "load8_u", [795]), 0); |
| |
| // memory_copy.wast:3608 |
| assert_return(() => call($18, "load8_u", [994]), 0); |
| |
| // memory_copy.wast:3609 |
| assert_return(() => call($18, "load8_u", [1_193]), 0); |
| |
| // memory_copy.wast:3610 |
| assert_return(() => call($18, "load8_u", [1_392]), 0); |
| |
| // memory_copy.wast:3611 |
| assert_return(() => call($18, "load8_u", [1_591]), 0); |
| |
| // memory_copy.wast:3612 |
| assert_return(() => call($18, "load8_u", [1_790]), 0); |
| |
| // memory_copy.wast:3613 |
| assert_return(() => call($18, "load8_u", [1_989]), 0); |
| |
| // memory_copy.wast:3614 |
| assert_return(() => call($18, "load8_u", [2_188]), 0); |
| |
| // memory_copy.wast:3615 |
| assert_return(() => call($18, "load8_u", [2_387]), 0); |
| |
| // memory_copy.wast:3616 |
| assert_return(() => call($18, "load8_u", [2_586]), 0); |
| |
| // memory_copy.wast:3617 |
| assert_return(() => call($18, "load8_u", [2_785]), 0); |
| |
| // memory_copy.wast:3618 |
| assert_return(() => call($18, "load8_u", [2_984]), 0); |
| |
| // memory_copy.wast:3619 |
| assert_return(() => call($18, "load8_u", [3_183]), 0); |
| |
| // memory_copy.wast:3620 |
| assert_return(() => call($18, "load8_u", [3_382]), 0); |
| |
| // memory_copy.wast:3621 |
| assert_return(() => call($18, "load8_u", [3_581]), 0); |
| |
| // memory_copy.wast:3622 |
| assert_return(() => call($18, "load8_u", [3_780]), 0); |
| |
| // memory_copy.wast:3623 |
| assert_return(() => call($18, "load8_u", [3_979]), 0); |
| |
| // memory_copy.wast:3624 |
| assert_return(() => call($18, "load8_u", [4_178]), 0); |
| |
| // memory_copy.wast:3625 |
| assert_return(() => call($18, "load8_u", [4_377]), 0); |
| |
| // memory_copy.wast:3626 |
| assert_return(() => call($18, "load8_u", [4_576]), 0); |
| |
| // memory_copy.wast:3627 |
| assert_return(() => call($18, "load8_u", [4_775]), 0); |
| |
| // memory_copy.wast:3628 |
| assert_return(() => call($18, "load8_u", [4_974]), 0); |
| |
| // memory_copy.wast:3629 |
| assert_return(() => call($18, "load8_u", [5_173]), 0); |
| |
| // memory_copy.wast:3630 |
| assert_return(() => call($18, "load8_u", [5_372]), 0); |
| |
| // memory_copy.wast:3631 |
| assert_return(() => call($18, "load8_u", [5_571]), 0); |
| |
| // memory_copy.wast:3632 |
| assert_return(() => call($18, "load8_u", [5_770]), 0); |
| |
| // memory_copy.wast:3633 |
| assert_return(() => call($18, "load8_u", [5_969]), 0); |
| |
| // memory_copy.wast:3634 |
| assert_return(() => call($18, "load8_u", [6_168]), 0); |
| |
| // memory_copy.wast:3635 |
| assert_return(() => call($18, "load8_u", [6_367]), 0); |
| |
| // memory_copy.wast:3636 |
| assert_return(() => call($18, "load8_u", [6_566]), 0); |
| |
| // memory_copy.wast:3637 |
| assert_return(() => call($18, "load8_u", [6_765]), 0); |
| |
| // memory_copy.wast:3638 |
| assert_return(() => call($18, "load8_u", [6_964]), 0); |
| |
| // memory_copy.wast:3639 |
| assert_return(() => call($18, "load8_u", [7_163]), 0); |
| |
| // memory_copy.wast:3640 |
| assert_return(() => call($18, "load8_u", [7_362]), 0); |
| |
| // memory_copy.wast:3641 |
| assert_return(() => call($18, "load8_u", [7_561]), 0); |
| |
| // memory_copy.wast:3642 |
| assert_return(() => call($18, "load8_u", [7_760]), 0); |
| |
| // memory_copy.wast:3643 |
| assert_return(() => call($18, "load8_u", [7_959]), 0); |
| |
| // memory_copy.wast:3644 |
| assert_return(() => call($18, "load8_u", [8_158]), 0); |
| |
| // memory_copy.wast:3645 |
| assert_return(() => call($18, "load8_u", [8_357]), 0); |
| |
| // memory_copy.wast:3646 |
| assert_return(() => call($18, "load8_u", [8_556]), 0); |
| |
| // memory_copy.wast:3647 |
| assert_return(() => call($18, "load8_u", [8_755]), 0); |
| |
| // memory_copy.wast:3648 |
| assert_return(() => call($18, "load8_u", [8_954]), 0); |
| |
| // memory_copy.wast:3649 |
| assert_return(() => call($18, "load8_u", [9_153]), 0); |
| |
| // memory_copy.wast:3650 |
| assert_return(() => call($18, "load8_u", [9_352]), 0); |
| |
| // memory_copy.wast:3651 |
| assert_return(() => call($18, "load8_u", [9_551]), 0); |
| |
| // memory_copy.wast:3652 |
| assert_return(() => call($18, "load8_u", [9_750]), 0); |
| |
| // memory_copy.wast:3653 |
| assert_return(() => call($18, "load8_u", [9_949]), 0); |
| |
| // memory_copy.wast:3654 |
| assert_return(() => call($18, "load8_u", [10_148]), 0); |
| |
| // memory_copy.wast:3655 |
| assert_return(() => call($18, "load8_u", [10_347]), 0); |
| |
| // memory_copy.wast:3656 |
| assert_return(() => call($18, "load8_u", [10_546]), 0); |
| |
| // memory_copy.wast:3657 |
| assert_return(() => call($18, "load8_u", [10_745]), 0); |
| |
| // memory_copy.wast:3658 |
| assert_return(() => call($18, "load8_u", [10_944]), 0); |
| |
| // memory_copy.wast:3659 |
| assert_return(() => call($18, "load8_u", [11_143]), 0); |
| |
| // memory_copy.wast:3660 |
| assert_return(() => call($18, "load8_u", [11_342]), 0); |
| |
| // memory_copy.wast:3661 |
| assert_return(() => call($18, "load8_u", [11_541]), 0); |
| |
| // memory_copy.wast:3662 |
| assert_return(() => call($18, "load8_u", [11_740]), 0); |
| |
| // memory_copy.wast:3663 |
| assert_return(() => call($18, "load8_u", [11_939]), 0); |
| |
| // memory_copy.wast:3664 |
| assert_return(() => call($18, "load8_u", [12_138]), 0); |
| |
| // memory_copy.wast:3665 |
| assert_return(() => call($18, "load8_u", [12_337]), 0); |
| |
| // memory_copy.wast:3666 |
| assert_return(() => call($18, "load8_u", [12_536]), 0); |
| |
| // memory_copy.wast:3667 |
| assert_return(() => call($18, "load8_u", [12_735]), 0); |
| |
| // memory_copy.wast:3668 |
| assert_return(() => call($18, "load8_u", [12_934]), 0); |
| |
| // memory_copy.wast:3669 |
| assert_return(() => call($18, "load8_u", [13_133]), 0); |
| |
| // memory_copy.wast:3670 |
| assert_return(() => call($18, "load8_u", [13_332]), 0); |
| |
| // memory_copy.wast:3671 |
| assert_return(() => call($18, "load8_u", [13_531]), 0); |
| |
| // memory_copy.wast:3672 |
| assert_return(() => call($18, "load8_u", [13_730]), 0); |
| |
| // memory_copy.wast:3673 |
| assert_return(() => call($18, "load8_u", [13_929]), 0); |
| |
| // memory_copy.wast:3674 |
| assert_return(() => call($18, "load8_u", [14_128]), 0); |
| |
| // memory_copy.wast:3675 |
| assert_return(() => call($18, "load8_u", [14_327]), 0); |
| |
| // memory_copy.wast:3676 |
| assert_return(() => call($18, "load8_u", [14_526]), 0); |
| |
| // memory_copy.wast:3677 |
| assert_return(() => call($18, "load8_u", [14_725]), 0); |
| |
| // memory_copy.wast:3678 |
| assert_return(() => call($18, "load8_u", [14_924]), 0); |
| |
| // memory_copy.wast:3679 |
| assert_return(() => call($18, "load8_u", [15_123]), 0); |
| |
| // memory_copy.wast:3680 |
| assert_return(() => call($18, "load8_u", [15_322]), 0); |
| |
| // memory_copy.wast:3681 |
| assert_return(() => call($18, "load8_u", [15_521]), 0); |
| |
| // memory_copy.wast:3682 |
| assert_return(() => call($18, "load8_u", [15_720]), 0); |
| |
| // memory_copy.wast:3683 |
| assert_return(() => call($18, "load8_u", [15_919]), 0); |
| |
| // memory_copy.wast:3684 |
| assert_return(() => call($18, "load8_u", [16_118]), 0); |
| |
| // memory_copy.wast:3685 |
| assert_return(() => call($18, "load8_u", [16_317]), 0); |
| |
| // memory_copy.wast:3686 |
| assert_return(() => call($18, "load8_u", [16_516]), 0); |
| |
| // memory_copy.wast:3687 |
| assert_return(() => call($18, "load8_u", [16_715]), 0); |
| |
| // memory_copy.wast:3688 |
| assert_return(() => call($18, "load8_u", [16_914]), 0); |
| |
| // memory_copy.wast:3689 |
| assert_return(() => call($18, "load8_u", [17_113]), 0); |
| |
| // memory_copy.wast:3690 |
| assert_return(() => call($18, "load8_u", [17_312]), 0); |
| |
| // memory_copy.wast:3691 |
| assert_return(() => call($18, "load8_u", [17_511]), 0); |
| |
| // memory_copy.wast:3692 |
| assert_return(() => call($18, "load8_u", [17_710]), 0); |
| |
| // memory_copy.wast:3693 |
| assert_return(() => call($18, "load8_u", [17_909]), 0); |
| |
| // memory_copy.wast:3694 |
| assert_return(() => call($18, "load8_u", [18_108]), 0); |
| |
| // memory_copy.wast:3695 |
| assert_return(() => call($18, "load8_u", [18_307]), 0); |
| |
| // memory_copy.wast:3696 |
| assert_return(() => call($18, "load8_u", [18_506]), 0); |
| |
| // memory_copy.wast:3697 |
| assert_return(() => call($18, "load8_u", [18_705]), 0); |
| |
| // memory_copy.wast:3698 |
| assert_return(() => call($18, "load8_u", [18_904]), 0); |
| |
| // memory_copy.wast:3699 |
| assert_return(() => call($18, "load8_u", [19_103]), 0); |
| |
| // memory_copy.wast:3700 |
| assert_return(() => call($18, "load8_u", [19_302]), 0); |
| |
| // memory_copy.wast:3701 |
| assert_return(() => call($18, "load8_u", [19_501]), 0); |
| |
| // memory_copy.wast:3702 |
| assert_return(() => call($18, "load8_u", [19_700]), 0); |
| |
| // memory_copy.wast:3703 |
| assert_return(() => call($18, "load8_u", [19_899]), 0); |
| |
| // memory_copy.wast:3704 |
| assert_return(() => call($18, "load8_u", [20_098]), 0); |
| |
| // memory_copy.wast:3705 |
| assert_return(() => call($18, "load8_u", [20_297]), 0); |
| |
| // memory_copy.wast:3706 |
| assert_return(() => call($18, "load8_u", [20_496]), 0); |
| |
| // memory_copy.wast:3707 |
| assert_return(() => call($18, "load8_u", [20_695]), 0); |
| |
| // memory_copy.wast:3708 |
| assert_return(() => call($18, "load8_u", [20_894]), 0); |
| |
| // memory_copy.wast:3709 |
| assert_return(() => call($18, "load8_u", [21_093]), 0); |
| |
| // memory_copy.wast:3710 |
| assert_return(() => call($18, "load8_u", [21_292]), 0); |
| |
| // memory_copy.wast:3711 |
| assert_return(() => call($18, "load8_u", [21_491]), 0); |
| |
| // memory_copy.wast:3712 |
| assert_return(() => call($18, "load8_u", [21_690]), 0); |
| |
| // memory_copy.wast:3713 |
| assert_return(() => call($18, "load8_u", [21_889]), 0); |
| |
| // memory_copy.wast:3714 |
| assert_return(() => call($18, "load8_u", [22_088]), 0); |
| |
| // memory_copy.wast:3715 |
| assert_return(() => call($18, "load8_u", [22_287]), 0); |
| |
| // memory_copy.wast:3716 |
| assert_return(() => call($18, "load8_u", [22_486]), 0); |
| |
| // memory_copy.wast:3717 |
| assert_return(() => call($18, "load8_u", [22_685]), 0); |
| |
| // memory_copy.wast:3718 |
| assert_return(() => call($18, "load8_u", [22_884]), 0); |
| |
| // memory_copy.wast:3719 |
| assert_return(() => call($18, "load8_u", [23_083]), 0); |
| |
| // memory_copy.wast:3720 |
| assert_return(() => call($18, "load8_u", [23_282]), 0); |
| |
| // memory_copy.wast:3721 |
| assert_return(() => call($18, "load8_u", [23_481]), 0); |
| |
| // memory_copy.wast:3722 |
| assert_return(() => call($18, "load8_u", [23_680]), 0); |
| |
| // memory_copy.wast:3723 |
| assert_return(() => call($18, "load8_u", [23_879]), 0); |
| |
| // memory_copy.wast:3724 |
| assert_return(() => call($18, "load8_u", [24_078]), 0); |
| |
| // memory_copy.wast:3725 |
| assert_return(() => call($18, "load8_u", [24_277]), 0); |
| |
| // memory_copy.wast:3726 |
| assert_return(() => call($18, "load8_u", [24_476]), 0); |
| |
| // memory_copy.wast:3727 |
| assert_return(() => call($18, "load8_u", [24_675]), 0); |
| |
| // memory_copy.wast:3728 |
| assert_return(() => call($18, "load8_u", [24_874]), 0); |
| |
| // memory_copy.wast:3729 |
| assert_return(() => call($18, "load8_u", [25_073]), 0); |
| |
| // memory_copy.wast:3730 |
| assert_return(() => call($18, "load8_u", [25_272]), 0); |
| |
| // memory_copy.wast:3731 |
| assert_return(() => call($18, "load8_u", [25_471]), 0); |
| |
| // memory_copy.wast:3732 |
| assert_return(() => call($18, "load8_u", [25_670]), 0); |
| |
| // memory_copy.wast:3733 |
| assert_return(() => call($18, "load8_u", [25_869]), 0); |
| |
| // memory_copy.wast:3734 |
| assert_return(() => call($18, "load8_u", [26_068]), 0); |
| |
| // memory_copy.wast:3735 |
| assert_return(() => call($18, "load8_u", [26_267]), 0); |
| |
| // memory_copy.wast:3736 |
| assert_return(() => call($18, "load8_u", [26_466]), 0); |
| |
| // memory_copy.wast:3737 |
| assert_return(() => call($18, "load8_u", [26_665]), 0); |
| |
| // memory_copy.wast:3738 |
| assert_return(() => call($18, "load8_u", [26_864]), 0); |
| |
| // memory_copy.wast:3739 |
| assert_return(() => call($18, "load8_u", [27_063]), 0); |
| |
| // memory_copy.wast:3740 |
| assert_return(() => call($18, "load8_u", [27_262]), 0); |
| |
| // memory_copy.wast:3741 |
| assert_return(() => call($18, "load8_u", [27_461]), 0); |
| |
| // memory_copy.wast:3742 |
| assert_return(() => call($18, "load8_u", [27_660]), 0); |
| |
| // memory_copy.wast:3743 |
| assert_return(() => call($18, "load8_u", [27_859]), 0); |
| |
| // memory_copy.wast:3744 |
| assert_return(() => call($18, "load8_u", [28_058]), 0); |
| |
| // memory_copy.wast:3745 |
| assert_return(() => call($18, "load8_u", [28_257]), 0); |
| |
| // memory_copy.wast:3746 |
| assert_return(() => call($18, "load8_u", [28_456]), 0); |
| |
| // memory_copy.wast:3747 |
| assert_return(() => call($18, "load8_u", [28_655]), 0); |
| |
| // memory_copy.wast:3748 |
| assert_return(() => call($18, "load8_u", [28_854]), 0); |
| |
| // memory_copy.wast:3749 |
| assert_return(() => call($18, "load8_u", [29_053]), 0); |
| |
| // memory_copy.wast:3750 |
| assert_return(() => call($18, "load8_u", [29_252]), 0); |
| |
| // memory_copy.wast:3751 |
| assert_return(() => call($18, "load8_u", [29_451]), 0); |
| |
| // memory_copy.wast:3752 |
| assert_return(() => call($18, "load8_u", [29_650]), 0); |
| |
| // memory_copy.wast:3753 |
| assert_return(() => call($18, "load8_u", [29_849]), 0); |
| |
| // memory_copy.wast:3754 |
| assert_return(() => call($18, "load8_u", [30_048]), 0); |
| |
| // memory_copy.wast:3755 |
| assert_return(() => call($18, "load8_u", [30_247]), 0); |
| |
| // memory_copy.wast:3756 |
| assert_return(() => call($18, "load8_u", [30_446]), 0); |
| |
| // memory_copy.wast:3757 |
| assert_return(() => call($18, "load8_u", [30_645]), 0); |
| |
| // memory_copy.wast:3758 |
| assert_return(() => call($18, "load8_u", [30_844]), 0); |
| |
| // memory_copy.wast:3759 |
| assert_return(() => call($18, "load8_u", [31_043]), 0); |
| |
| // memory_copy.wast:3760 |
| assert_return(() => call($18, "load8_u", [31_242]), 0); |
| |
| // memory_copy.wast:3761 |
| assert_return(() => call($18, "load8_u", [31_441]), 0); |
| |
| // memory_copy.wast:3762 |
| assert_return(() => call($18, "load8_u", [31_640]), 0); |
| |
| // memory_copy.wast:3763 |
| assert_return(() => call($18, "load8_u", [31_839]), 0); |
| |
| // memory_copy.wast:3764 |
| assert_return(() => call($18, "load8_u", [32_038]), 0); |
| |
| // memory_copy.wast:3765 |
| assert_return(() => call($18, "load8_u", [32_237]), 0); |
| |
| // memory_copy.wast:3766 |
| assert_return(() => call($18, "load8_u", [32_436]), 0); |
| |
| // memory_copy.wast:3767 |
| assert_return(() => call($18, "load8_u", [32_635]), 0); |
| |
| // memory_copy.wast:3768 |
| assert_return(() => call($18, "load8_u", [32_834]), 0); |
| |
| // memory_copy.wast:3769 |
| assert_return(() => call($18, "load8_u", [33_033]), 0); |
| |
| // memory_copy.wast:3770 |
| assert_return(() => call($18, "load8_u", [33_232]), 0); |
| |
| // memory_copy.wast:3771 |
| assert_return(() => call($18, "load8_u", [33_431]), 0); |
| |
| // memory_copy.wast:3772 |
| assert_return(() => call($18, "load8_u", [33_630]), 0); |
| |
| // memory_copy.wast:3773 |
| assert_return(() => call($18, "load8_u", [33_829]), 0); |
| |
| // memory_copy.wast:3774 |
| assert_return(() => call($18, "load8_u", [34_028]), 0); |
| |
| // memory_copy.wast:3775 |
| assert_return(() => call($18, "load8_u", [34_227]), 0); |
| |
| // memory_copy.wast:3776 |
| assert_return(() => call($18, "load8_u", [34_426]), 0); |
| |
| // memory_copy.wast:3777 |
| assert_return(() => call($18, "load8_u", [34_625]), 0); |
| |
| // memory_copy.wast:3778 |
| assert_return(() => call($18, "load8_u", [34_824]), 0); |
| |
| // memory_copy.wast:3779 |
| assert_return(() => call($18, "load8_u", [35_023]), 0); |
| |
| // memory_copy.wast:3780 |
| assert_return(() => call($18, "load8_u", [35_222]), 0); |
| |
| // memory_copy.wast:3781 |
| assert_return(() => call($18, "load8_u", [35_421]), 0); |
| |
| // memory_copy.wast:3782 |
| assert_return(() => call($18, "load8_u", [35_620]), 0); |
| |
| // memory_copy.wast:3783 |
| assert_return(() => call($18, "load8_u", [35_819]), 0); |
| |
| // memory_copy.wast:3784 |
| assert_return(() => call($18, "load8_u", [36_018]), 0); |
| |
| // memory_copy.wast:3785 |
| assert_return(() => call($18, "load8_u", [36_217]), 0); |
| |
| // memory_copy.wast:3786 |
| assert_return(() => call($18, "load8_u", [36_416]), 0); |
| |
| // memory_copy.wast:3787 |
| assert_return(() => call($18, "load8_u", [36_615]), 0); |
| |
| // memory_copy.wast:3788 |
| assert_return(() => call($18, "load8_u", [36_814]), 0); |
| |
| // memory_copy.wast:3789 |
| assert_return(() => call($18, "load8_u", [37_013]), 0); |
| |
| // memory_copy.wast:3790 |
| assert_return(() => call($18, "load8_u", [37_212]), 0); |
| |
| // memory_copy.wast:3791 |
| assert_return(() => call($18, "load8_u", [37_411]), 0); |
| |
| // memory_copy.wast:3792 |
| assert_return(() => call($18, "load8_u", [37_610]), 0); |
| |
| // memory_copy.wast:3793 |
| assert_return(() => call($18, "load8_u", [37_809]), 0); |
| |
| // memory_copy.wast:3794 |
| assert_return(() => call($18, "load8_u", [38_008]), 0); |
| |
| // memory_copy.wast:3795 |
| assert_return(() => call($18, "load8_u", [38_207]), 0); |
| |
| // memory_copy.wast:3796 |
| assert_return(() => call($18, "load8_u", [38_406]), 0); |
| |
| // memory_copy.wast:3797 |
| assert_return(() => call($18, "load8_u", [38_605]), 0); |
| |
| // memory_copy.wast:3798 |
| assert_return(() => call($18, "load8_u", [38_804]), 0); |
| |
| // memory_copy.wast:3799 |
| assert_return(() => call($18, "load8_u", [39_003]), 0); |
| |
| // memory_copy.wast:3800 |
| assert_return(() => call($18, "load8_u", [39_202]), 0); |
| |
| // memory_copy.wast:3801 |
| assert_return(() => call($18, "load8_u", [39_401]), 0); |
| |
| // memory_copy.wast:3802 |
| assert_return(() => call($18, "load8_u", [39_600]), 0); |
| |
| // memory_copy.wast:3803 |
| assert_return(() => call($18, "load8_u", [39_799]), 0); |
| |
| // memory_copy.wast:3804 |
| assert_return(() => call($18, "load8_u", [39_998]), 0); |
| |
| // memory_copy.wast:3805 |
| assert_return(() => call($18, "load8_u", [40_197]), 0); |
| |
| // memory_copy.wast:3806 |
| assert_return(() => call($18, "load8_u", [40_396]), 0); |
| |
| // memory_copy.wast:3807 |
| assert_return(() => call($18, "load8_u", [40_595]), 0); |
| |
| // memory_copy.wast:3808 |
| assert_return(() => call($18, "load8_u", [40_794]), 0); |
| |
| // memory_copy.wast:3809 |
| assert_return(() => call($18, "load8_u", [40_993]), 0); |
| |
| // memory_copy.wast:3810 |
| assert_return(() => call($18, "load8_u", [41_192]), 0); |
| |
| // memory_copy.wast:3811 |
| assert_return(() => call($18, "load8_u", [41_391]), 0); |
| |
| // memory_copy.wast:3812 |
| assert_return(() => call($18, "load8_u", [41_590]), 0); |
| |
| // memory_copy.wast:3813 |
| assert_return(() => call($18, "load8_u", [41_789]), 0); |
| |
| // memory_copy.wast:3814 |
| assert_return(() => call($18, "load8_u", [41_988]), 0); |
| |
| // memory_copy.wast:3815 |
| assert_return(() => call($18, "load8_u", [42_187]), 0); |
| |
| // memory_copy.wast:3816 |
| assert_return(() => call($18, "load8_u", [42_386]), 0); |
| |
| // memory_copy.wast:3817 |
| assert_return(() => call($18, "load8_u", [42_585]), 0); |
| |
| // memory_copy.wast:3818 |
| assert_return(() => call($18, "load8_u", [42_784]), 0); |
| |
| // memory_copy.wast:3819 |
| assert_return(() => call($18, "load8_u", [42_983]), 0); |
| |
| // memory_copy.wast:3820 |
| assert_return(() => call($18, "load8_u", [43_182]), 0); |
| |
| // memory_copy.wast:3821 |
| assert_return(() => call($18, "load8_u", [43_381]), 0); |
| |
| // memory_copy.wast:3822 |
| assert_return(() => call($18, "load8_u", [43_580]), 0); |
| |
| // memory_copy.wast:3823 |
| assert_return(() => call($18, "load8_u", [43_779]), 0); |
| |
| // memory_copy.wast:3824 |
| assert_return(() => call($18, "load8_u", [43_978]), 0); |
| |
| // memory_copy.wast:3825 |
| assert_return(() => call($18, "load8_u", [44_177]), 0); |
| |
| // memory_copy.wast:3826 |
| assert_return(() => call($18, "load8_u", [44_376]), 0); |
| |
| // memory_copy.wast:3827 |
| assert_return(() => call($18, "load8_u", [44_575]), 0); |
| |
| // memory_copy.wast:3828 |
| assert_return(() => call($18, "load8_u", [44_774]), 0); |
| |
| // memory_copy.wast:3829 |
| assert_return(() => call($18, "load8_u", [44_973]), 0); |
| |
| // memory_copy.wast:3830 |
| assert_return(() => call($18, "load8_u", [45_172]), 0); |
| |
| // memory_copy.wast:3831 |
| assert_return(() => call($18, "load8_u", [45_371]), 0); |
| |
| // memory_copy.wast:3832 |
| assert_return(() => call($18, "load8_u", [45_570]), 0); |
| |
| // memory_copy.wast:3833 |
| assert_return(() => call($18, "load8_u", [45_769]), 0); |
| |
| // memory_copy.wast:3834 |
| assert_return(() => call($18, "load8_u", [45_968]), 0); |
| |
| // memory_copy.wast:3835 |
| assert_return(() => call($18, "load8_u", [46_167]), 0); |
| |
| // memory_copy.wast:3836 |
| assert_return(() => call($18, "load8_u", [46_366]), 0); |
| |
| // memory_copy.wast:3837 |
| assert_return(() => call($18, "load8_u", [46_565]), 0); |
| |
| // memory_copy.wast:3838 |
| assert_return(() => call($18, "load8_u", [46_764]), 0); |
| |
| // memory_copy.wast:3839 |
| assert_return(() => call($18, "load8_u", [46_963]), 0); |
| |
| // memory_copy.wast:3840 |
| assert_return(() => call($18, "load8_u", [47_162]), 0); |
| |
| // memory_copy.wast:3841 |
| assert_return(() => call($18, "load8_u", [47_361]), 0); |
| |
| // memory_copy.wast:3842 |
| assert_return(() => call($18, "load8_u", [47_560]), 0); |
| |
| // memory_copy.wast:3843 |
| assert_return(() => call($18, "load8_u", [47_759]), 0); |
| |
| // memory_copy.wast:3844 |
| assert_return(() => call($18, "load8_u", [47_958]), 0); |
| |
| // memory_copy.wast:3845 |
| assert_return(() => call($18, "load8_u", [48_157]), 0); |
| |
| // memory_copy.wast:3846 |
| assert_return(() => call($18, "load8_u", [48_356]), 0); |
| |
| // memory_copy.wast:3847 |
| assert_return(() => call($18, "load8_u", [48_555]), 0); |
| |
| // memory_copy.wast:3848 |
| assert_return(() => call($18, "load8_u", [48_754]), 0); |
| |
| // memory_copy.wast:3849 |
| assert_return(() => call($18, "load8_u", [48_953]), 0); |
| |
| // memory_copy.wast:3850 |
| assert_return(() => call($18, "load8_u", [49_152]), 0); |
| |
| // memory_copy.wast:3851 |
| assert_return(() => call($18, "load8_u", [49_351]), 0); |
| |
| // memory_copy.wast:3852 |
| assert_return(() => call($18, "load8_u", [49_550]), 0); |
| |
| // memory_copy.wast:3853 |
| assert_return(() => call($18, "load8_u", [49_749]), 0); |
| |
| // memory_copy.wast:3854 |
| assert_return(() => call($18, "load8_u", [49_948]), 0); |
| |
| // memory_copy.wast:3855 |
| assert_return(() => call($18, "load8_u", [50_147]), 0); |
| |
| // memory_copy.wast:3856 |
| assert_return(() => call($18, "load8_u", [50_346]), 0); |
| |
| // memory_copy.wast:3857 |
| assert_return(() => call($18, "load8_u", [50_545]), 0); |
| |
| // memory_copy.wast:3858 |
| assert_return(() => call($18, "load8_u", [50_744]), 0); |
| |
| // memory_copy.wast:3859 |
| assert_return(() => call($18, "load8_u", [50_943]), 0); |
| |
| // memory_copy.wast:3860 |
| assert_return(() => call($18, "load8_u", [51_142]), 0); |
| |
| // memory_copy.wast:3861 |
| assert_return(() => call($18, "load8_u", [51_341]), 0); |
| |
| // memory_copy.wast:3862 |
| assert_return(() => call($18, "load8_u", [51_540]), 0); |
| |
| // memory_copy.wast:3863 |
| assert_return(() => call($18, "load8_u", [51_739]), 0); |
| |
| // memory_copy.wast:3864 |
| assert_return(() => call($18, "load8_u", [51_938]), 0); |
| |
| // memory_copy.wast:3865 |
| assert_return(() => call($18, "load8_u", [52_137]), 0); |
| |
| // memory_copy.wast:3866 |
| assert_return(() => call($18, "load8_u", [52_336]), 0); |
| |
| // memory_copy.wast:3867 |
| assert_return(() => call($18, "load8_u", [52_535]), 0); |
| |
| // memory_copy.wast:3868 |
| assert_return(() => call($18, "load8_u", [52_734]), 0); |
| |
| // memory_copy.wast:3869 |
| assert_return(() => call($18, "load8_u", [52_933]), 0); |
| |
| // memory_copy.wast:3870 |
| assert_return(() => call($18, "load8_u", [53_132]), 0); |
| |
| // memory_copy.wast:3871 |
| assert_return(() => call($18, "load8_u", [53_331]), 0); |
| |
| // memory_copy.wast:3872 |
| assert_return(() => call($18, "load8_u", [53_530]), 0); |
| |
| // memory_copy.wast:3873 |
| assert_return(() => call($18, "load8_u", [53_729]), 0); |
| |
| // memory_copy.wast:3874 |
| assert_return(() => call($18, "load8_u", [53_928]), 0); |
| |
| // memory_copy.wast:3875 |
| assert_return(() => call($18, "load8_u", [54_127]), 0); |
| |
| // memory_copy.wast:3876 |
| assert_return(() => call($18, "load8_u", [54_326]), 0); |
| |
| // memory_copy.wast:3877 |
| assert_return(() => call($18, "load8_u", [54_525]), 0); |
| |
| // memory_copy.wast:3878 |
| assert_return(() => call($18, "load8_u", [54_724]), 0); |
| |
| // memory_copy.wast:3879 |
| assert_return(() => call($18, "load8_u", [54_923]), 0); |
| |
| // memory_copy.wast:3880 |
| assert_return(() => call($18, "load8_u", [55_122]), 0); |
| |
| // memory_copy.wast:3881 |
| assert_return(() => call($18, "load8_u", [55_321]), 0); |
| |
| // memory_copy.wast:3882 |
| assert_return(() => call($18, "load8_u", [55_520]), 0); |
| |
| // memory_copy.wast:3883 |
| assert_return(() => call($18, "load8_u", [55_719]), 0); |
| |
| // memory_copy.wast:3884 |
| assert_return(() => call($18, "load8_u", [55_918]), 0); |
| |
| // memory_copy.wast:3885 |
| assert_return(() => call($18, "load8_u", [56_117]), 0); |
| |
| // memory_copy.wast:3886 |
| assert_return(() => call($18, "load8_u", [56_316]), 0); |
| |
| // memory_copy.wast:3887 |
| assert_return(() => call($18, "load8_u", [56_515]), 0); |
| |
| // memory_copy.wast:3888 |
| assert_return(() => call($18, "load8_u", [56_714]), 0); |
| |
| // memory_copy.wast:3889 |
| assert_return(() => call($18, "load8_u", [56_913]), 0); |
| |
| // memory_copy.wast:3890 |
| assert_return(() => call($18, "load8_u", [57_112]), 0); |
| |
| // memory_copy.wast:3891 |
| assert_return(() => call($18, "load8_u", [57_311]), 0); |
| |
| // memory_copy.wast:3892 |
| assert_return(() => call($18, "load8_u", [57_510]), 0); |
| |
| // memory_copy.wast:3893 |
| assert_return(() => call($18, "load8_u", [57_709]), 0); |
| |
| // memory_copy.wast:3894 |
| assert_return(() => call($18, "load8_u", [57_908]), 0); |
| |
| // memory_copy.wast:3895 |
| assert_return(() => call($18, "load8_u", [58_107]), 0); |
| |
| // memory_copy.wast:3896 |
| assert_return(() => call($18, "load8_u", [58_306]), 0); |
| |
| // memory_copy.wast:3897 |
| assert_return(() => call($18, "load8_u", [58_505]), 0); |
| |
| // memory_copy.wast:3898 |
| assert_return(() => call($18, "load8_u", [58_704]), 0); |
| |
| // memory_copy.wast:3899 |
| assert_return(() => call($18, "load8_u", [58_903]), 0); |
| |
| // memory_copy.wast:3900 |
| assert_return(() => call($18, "load8_u", [59_102]), 0); |
| |
| // memory_copy.wast:3901 |
| assert_return(() => call($18, "load8_u", [59_301]), 0); |
| |
| // memory_copy.wast:3902 |
| assert_return(() => call($18, "load8_u", [59_500]), 0); |
| |
| // memory_copy.wast:3903 |
| assert_return(() => call($18, "load8_u", [59_699]), 0); |
| |
| // memory_copy.wast:3904 |
| assert_return(() => call($18, "load8_u", [59_898]), 0); |
| |
| // memory_copy.wast:3905 |
| assert_return(() => call($18, "load8_u", [60_097]), 0); |
| |
| // memory_copy.wast:3906 |
| assert_return(() => call($18, "load8_u", [60_296]), 0); |
| |
| // memory_copy.wast:3907 |
| assert_return(() => call($18, "load8_u", [60_495]), 0); |
| |
| // memory_copy.wast:3908 |
| assert_return(() => call($18, "load8_u", [60_694]), 0); |
| |
| // memory_copy.wast:3909 |
| assert_return(() => call($18, "load8_u", [60_893]), 0); |
| |
| // memory_copy.wast:3910 |
| assert_return(() => call($18, "load8_u", [61_092]), 0); |
| |
| // memory_copy.wast:3911 |
| assert_return(() => call($18, "load8_u", [61_291]), 0); |
| |
| // memory_copy.wast:3912 |
| assert_return(() => call($18, "load8_u", [61_490]), 0); |
| |
| // memory_copy.wast:3913 |
| assert_return(() => call($18, "load8_u", [61_689]), 0); |
| |
| // memory_copy.wast:3914 |
| assert_return(() => call($18, "load8_u", [61_888]), 0); |
| |
| // memory_copy.wast:3915 |
| assert_return(() => call($18, "load8_u", [62_087]), 0); |
| |
| // memory_copy.wast:3916 |
| assert_return(() => call($18, "load8_u", [62_286]), 0); |
| |
| // memory_copy.wast:3917 |
| assert_return(() => call($18, "load8_u", [62_485]), 0); |
| |
| // memory_copy.wast:3918 |
| assert_return(() => call($18, "load8_u", [62_684]), 0); |
| |
| // memory_copy.wast:3919 |
| assert_return(() => call($18, "load8_u", [62_883]), 0); |
| |
| // memory_copy.wast:3920 |
| assert_return(() => call($18, "load8_u", [63_082]), 0); |
| |
| // memory_copy.wast:3921 |
| assert_return(() => call($18, "load8_u", [63_281]), 0); |
| |
| // memory_copy.wast:3922 |
| assert_return(() => call($18, "load8_u", [63_480]), 0); |
| |
| // memory_copy.wast:3923 |
| assert_return(() => call($18, "load8_u", [63_679]), 0); |
| |
| // memory_copy.wast:3924 |
| assert_return(() => call($18, "load8_u", [63_878]), 0); |
| |
| // memory_copy.wast:3925 |
| assert_return(() => call($18, "load8_u", [64_077]), 0); |
| |
| // memory_copy.wast:3926 |
| assert_return(() => call($18, "load8_u", [64_276]), 0); |
| |
| // memory_copy.wast:3927 |
| assert_return(() => call($18, "load8_u", [64_475]), 0); |
| |
| // memory_copy.wast:3928 |
| assert_return(() => call($18, "load8_u", [64_674]), 0); |
| |
| // memory_copy.wast:3929 |
| assert_return(() => call($18, "load8_u", [64_873]), 0); |
| |
| // memory_copy.wast:3930 |
| assert_return(() => call($18, "load8_u", [65_072]), 0); |
| |
| // memory_copy.wast:3931 |
| assert_return(() => call($18, "load8_u", [65_271]), 0); |
| |
| // memory_copy.wast:3932 |
| assert_return(() => call($18, "load8_u", [65_470]), 0); |
| |
| // memory_copy.wast:3933 |
| assert_return(() => call($18, "load8_u", [65_516]), 0); |
| |
| // memory_copy.wast:3934 |
| assert_return(() => call($18, "load8_u", [65_517]), 1); |
| |
| // memory_copy.wast:3935 |
| assert_return(() => call($18, "load8_u", [65_518]), 2); |
| |
| // memory_copy.wast:3936 |
| assert_return(() => call($18, "load8_u", [65_519]), 3); |
| |
| // memory_copy.wast:3937 |
| assert_return(() => call($18, "load8_u", [65_520]), 4); |
| |
| // memory_copy.wast:3938 |
| assert_return(() => call($18, "load8_u", [65_521]), 5); |
| |
| // memory_copy.wast:3939 |
| assert_return(() => call($18, "load8_u", [65_522]), 6); |
| |
| // memory_copy.wast:3940 |
| assert_return(() => call($18, "load8_u", [65_523]), 7); |
| |
| // memory_copy.wast:3941 |
| assert_return(() => call($18, "load8_u", [65_524]), 8); |
| |
| // memory_copy.wast:3942 |
| assert_return(() => call($18, "load8_u", [65_525]), 9); |
| |
| // memory_copy.wast:3943 |
| assert_return(() => call($18, "load8_u", [65_526]), 10); |
| |
| // memory_copy.wast:3944 |
| assert_return(() => call($18, "load8_u", [65_527]), 11); |
| |
| // memory_copy.wast:3945 |
| assert_return(() => call($18, "load8_u", [65_528]), 12); |
| |
| // memory_copy.wast:3946 |
| assert_return(() => call($18, "load8_u", [65_529]), 13); |
| |
| // memory_copy.wast:3947 |
| assert_return(() => call($18, "load8_u", [65_530]), 14); |
| |
| // memory_copy.wast:3948 |
| assert_return(() => call($18, "load8_u", [65_531]), 15); |
| |
| // memory_copy.wast:3949 |
| assert_return(() => call($18, "load8_u", [65_532]), 16); |
| |
| // memory_copy.wast:3950 |
| assert_return(() => call($18, "load8_u", [65_533]), 17); |
| |
| // memory_copy.wast:3951 |
| assert_return(() => call($18, "load8_u", [65_534]), 18); |
| |
| // memory_copy.wast:3952 |
| assert_return(() => call($18, "load8_u", [65_535]), 19); |
| |
| // memory_copy.wast:3954 |
| let $19 = 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\x80\xe0\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:3962 |
| assert_trap(() => call($19, "run", [65_516, 61_440, -256])); |
| |
| // memory_copy.wast:3965 |
| assert_return(() => call($19, "load8_u", [198]), 0); |
| |
| // memory_copy.wast:3966 |
| assert_return(() => call($19, "load8_u", [397]), 0); |
| |
| // memory_copy.wast:3967 |
| assert_return(() => call($19, "load8_u", [596]), 0); |
| |
| // memory_copy.wast:3968 |
| assert_return(() => call($19, "load8_u", [795]), 0); |
| |
| // memory_copy.wast:3969 |
| assert_return(() => call($19, "load8_u", [994]), 0); |
| |
| // memory_copy.wast:3970 |
| assert_return(() => call($19, "load8_u", [1_193]), 0); |
| |
| // memory_copy.wast:3971 |
| assert_return(() => call($19, "load8_u", [1_392]), 0); |
| |
| // memory_copy.wast:3972 |
| assert_return(() => call($19, "load8_u", [1_591]), 0); |
| |
| // memory_copy.wast:3973 |
| assert_return(() => call($19, "load8_u", [1_790]), 0); |
| |
| // memory_copy.wast:3974 |
| assert_return(() => call($19, "load8_u", [1_989]), 0); |
| |
| // memory_copy.wast:3975 |
| assert_return(() => call($19, "load8_u", [2_188]), 0); |
| |
| // memory_copy.wast:3976 |
| assert_return(() => call($19, "load8_u", [2_387]), 0); |
| |
| // memory_copy.wast:3977 |
| assert_return(() => call($19, "load8_u", [2_586]), 0); |
| |
| // memory_copy.wast:3978 |
| assert_return(() => call($19, "load8_u", [2_785]), 0); |
| |
| // memory_copy.wast:3979 |
| assert_return(() => call($19, "load8_u", [2_984]), 0); |
| |
| // memory_copy.wast:3980 |
| assert_return(() => call($19, "load8_u", [3_183]), 0); |
| |
| // memory_copy.wast:3981 |
| assert_return(() => call($19, "load8_u", [3_382]), 0); |
| |
| // memory_copy.wast:3982 |
| assert_return(() => call($19, "load8_u", [3_581]), 0); |
| |
| // memory_copy.wast:3983 |
| assert_return(() => call($19, "load8_u", [3_780]), 0); |
| |
| // memory_copy.wast:3984 |
| assert_return(() => call($19, "load8_u", [3_979]), 0); |
| |
| // memory_copy.wast:3985 |
| assert_return(() => call($19, "load8_u", [4_178]), 0); |
| |
| // memory_copy.wast:3986 |
| assert_return(() => call($19, "load8_u", [4_377]), 0); |
| |
| // memory_copy.wast:3987 |
| assert_return(() => call($19, "load8_u", [4_576]), 0); |
| |
| // memory_copy.wast:3988 |
| assert_return(() => call($19, "load8_u", [4_775]), 0); |
| |
| // memory_copy.wast:3989 |
| assert_return(() => call($19, "load8_u", [4_974]), 0); |
| |
| // memory_copy.wast:3990 |
| assert_return(() => call($19, "load8_u", [5_173]), 0); |
| |
| // memory_copy.wast:3991 |
| assert_return(() => call($19, "load8_u", [5_372]), 0); |
| |
| // memory_copy.wast:3992 |
| assert_return(() => call($19, "load8_u", [5_571]), 0); |
| |
| // memory_copy.wast:3993 |
| assert_return(() => call($19, "load8_u", [5_770]), 0); |
| |
| // memory_copy.wast:3994 |
| assert_return(() => call($19, "load8_u", [5_969]), 0); |
| |
| // memory_copy.wast:3995 |
| assert_return(() => call($19, "load8_u", [6_168]), 0); |
| |
| // memory_copy.wast:3996 |
| assert_return(() => call($19, "load8_u", [6_367]), 0); |
| |
| // memory_copy.wast:3997 |
| assert_return(() => call($19, "load8_u", [6_566]), 0); |
| |
| // memory_copy.wast:3998 |
| assert_return(() => call($19, "load8_u", [6_765]), 0); |
| |
| // memory_copy.wast:3999 |
| assert_return(() => call($19, "load8_u", [6_964]), 0); |
| |
| // memory_copy.wast:4000 |
| assert_return(() => call($19, "load8_u", [7_163]), 0); |
| |
| // memory_copy.wast:4001 |
| assert_return(() => call($19, "load8_u", [7_362]), 0); |
| |
| // memory_copy.wast:4002 |
| assert_return(() => call($19, "load8_u", [7_561]), 0); |
| |
| // memory_copy.wast:4003 |
| assert_return(() => call($19, "load8_u", [7_760]), 0); |
| |
| // memory_copy.wast:4004 |
| assert_return(() => call($19, "load8_u", [7_959]), 0); |
| |
| // memory_copy.wast:4005 |
| assert_return(() => call($19, "load8_u", [8_158]), 0); |
| |
| // memory_copy.wast:4006 |
| assert_return(() => call($19, "load8_u", [8_357]), 0); |
| |
| // memory_copy.wast:4007 |
| assert_return(() => call($19, "load8_u", [8_556]), 0); |
| |
| // memory_copy.wast:4008 |
| assert_return(() => call($19, "load8_u", [8_755]), 0); |
| |
| // memory_copy.wast:4009 |
| assert_return(() => call($19, "load8_u", [8_954]), 0); |
| |
| // memory_copy.wast:4010 |
| assert_return(() => call($19, "load8_u", [9_153]), 0); |
| |
| // memory_copy.wast:4011 |
| assert_return(() => call($19, "load8_u", [9_352]), 0); |
| |
| // memory_copy.wast:4012 |
| assert_return(() => call($19, "load8_u", [9_551]), 0); |
| |
| // memory_copy.wast:4013 |
| assert_return(() => call($19, "load8_u", [9_750]), 0); |
| |
| // memory_copy.wast:4014 |
| assert_return(() => call($19, "load8_u", [9_949]), 0); |
| |
| // memory_copy.wast:4015 |
| assert_return(() => call($19, "load8_u", [10_148]), 0); |
| |
| // memory_copy.wast:4016 |
| assert_return(() => call($19, "load8_u", [10_347]), 0); |
| |
| // memory_copy.wast:4017 |
| assert_return(() => call($19, "load8_u", [10_546]), 0); |
| |
| // memory_copy.wast:4018 |
| assert_return(() => call($19, "load8_u", [10_745]), 0); |
| |
| // memory_copy.wast:4019 |
| assert_return(() => call($19, "load8_u", [10_944]), 0); |
| |
| // memory_copy.wast:4020 |
| assert_return(() => call($19, "load8_u", [11_143]), 0); |
| |
| // memory_copy.wast:4021 |
| assert_return(() => call($19, "load8_u", [11_342]), 0); |
| |
| // memory_copy.wast:4022 |
| assert_return(() => call($19, "load8_u", [11_541]), 0); |
| |
| // memory_copy.wast:4023 |
| assert_return(() => call($19, "load8_u", [11_740]), 0); |
| |
| // memory_copy.wast:4024 |
| assert_return(() => call($19, "load8_u", [11_939]), 0); |
| |
| // memory_copy.wast:4025 |
| assert_return(() => call($19, "load8_u", [12_138]), 0); |
| |
| // memory_copy.wast:4026 |
| assert_return(() => call($19, "load8_u", [12_337]), 0); |
| |
| // memory_copy.wast:4027 |
| assert_return(() => call($19, "load8_u", [12_536]), 0); |
| |
| // memory_copy.wast:4028 |
| assert_return(() => call($19, "load8_u", [12_735]), 0); |
| |
| // memory_copy.wast:4029 |
| assert_return(() => call($19, "load8_u", [12_934]), 0); |
| |
| // memory_copy.wast:4030 |
| assert_return(() => call($19, "load8_u", [13_133]), 0); |
| |
| // memory_copy.wast:4031 |
| assert_return(() => call($19, "load8_u", [13_332]), 0); |
| |
| // memory_copy.wast:4032 |
| assert_return(() => call($19, "load8_u", [13_531]), 0); |
| |
| // memory_copy.wast:4033 |
| assert_return(() => call($19, "load8_u", [13_730]), 0); |
| |
| // memory_copy.wast:4034 |
| assert_return(() => call($19, "load8_u", [13_929]), 0); |
| |
| // memory_copy.wast:4035 |
| assert_return(() => call($19, "load8_u", [14_128]), 0); |
| |
| // memory_copy.wast:4036 |
| assert_return(() => call($19, "load8_u", [14_327]), 0); |
| |
| // memory_copy.wast:4037 |
| assert_return(() => call($19, "load8_u", [14_526]), 0); |
| |
| // memory_copy.wast:4038 |
| assert_return(() => call($19, "load8_u", [14_725]), 0); |
| |
| // memory_copy.wast:4039 |
| assert_return(() => call($19, "load8_u", [14_924]), 0); |
| |
| // memory_copy.wast:4040 |
| assert_return(() => call($19, "load8_u", [15_123]), 0); |
| |
| // memory_copy.wast:4041 |
| assert_return(() => call($19, "load8_u", [15_322]), 0); |
| |
| // memory_copy.wast:4042 |
| assert_return(() => call($19, "load8_u", [15_521]), 0); |
| |
| // memory_copy.wast:4043 |
| assert_return(() => call($19, "load8_u", [15_720]), 0); |
| |
| // memory_copy.wast:4044 |
| assert_return(() => call($19, "load8_u", [15_919]), 0); |
| |
| // memory_copy.wast:4045 |
| assert_return(() => call($19, "load8_u", [16_118]), 0); |
| |
| // memory_copy.wast:4046 |
| assert_return(() => call($19, "load8_u", [16_317]), 0); |
| |
| // memory_copy.wast:4047 |
| assert_return(() => call($19, "load8_u", [16_516]), 0); |
| |
| // memory_copy.wast:4048 |
| assert_return(() => call($19, "load8_u", [16_715]), 0); |
| |
| // memory_copy.wast:4049 |
| assert_return(() => call($19, "load8_u", [16_914]), 0); |
| |
| // memory_copy.wast:4050 |
| assert_return(() => call($19, "load8_u", [17_113]), 0); |
| |
| // memory_copy.wast:4051 |
| assert_return(() => call($19, "load8_u", [17_312]), 0); |
| |
| // memory_copy.wast:4052 |
| assert_return(() => call($19, "load8_u", [17_511]), 0); |
| |
| // memory_copy.wast:4053 |
| assert_return(() => call($19, "load8_u", [17_710]), 0); |
| |
| // memory_copy.wast:4054 |
| assert_return(() => call($19, "load8_u", [17_909]), 0); |
| |
| // memory_copy.wast:4055 |
| assert_return(() => call($19, "load8_u", [18_108]), 0); |
| |
| // memory_copy.wast:4056 |
| assert_return(() => call($19, "load8_u", [18_307]), 0); |
| |
| // memory_copy.wast:4057 |
| assert_return(() => call($19, "load8_u", [18_506]), 0); |
| |
| // memory_copy.wast:4058 |
| assert_return(() => call($19, "load8_u", [18_705]), 0); |
| |
| // memory_copy.wast:4059 |
| assert_return(() => call($19, "load8_u", [18_904]), 0); |
| |
| // memory_copy.wast:4060 |
| assert_return(() => call($19, "load8_u", [19_103]), 0); |
| |
| // memory_copy.wast:4061 |
| assert_return(() => call($19, "load8_u", [19_302]), 0); |
| |
| // memory_copy.wast:4062 |
| assert_return(() => call($19, "load8_u", [19_501]), 0); |
| |
| // memory_copy.wast:4063 |
| assert_return(() => call($19, "load8_u", [19_700]), 0); |
| |
| // memory_copy.wast:4064 |
| assert_return(() => call($19, "load8_u", [19_899]), 0); |
| |
| // memory_copy.wast:4065 |
| assert_return(() => call($19, "load8_u", [20_098]), 0); |
| |
| // memory_copy.wast:4066 |
| assert_return(() => call($19, "load8_u", [20_297]), 0); |
| |
| // memory_copy.wast:4067 |
| assert_return(() => call($19, "load8_u", [20_496]), 0); |
| |
| // memory_copy.wast:4068 |
| assert_return(() => call($19, "load8_u", [20_695]), 0); |
| |
| // memory_copy.wast:4069 |
| assert_return(() => call($19, "load8_u", [20_894]), 0); |
| |
| // memory_copy.wast:4070 |
| assert_return(() => call($19, "load8_u", [21_093]), 0); |
| |
| // memory_copy.wast:4071 |
| assert_return(() => call($19, "load8_u", [21_292]), 0); |
| |
| // memory_copy.wast:4072 |
| assert_return(() => call($19, "load8_u", [21_491]), 0); |
| |
| // memory_copy.wast:4073 |
| assert_return(() => call($19, "load8_u", [21_690]), 0); |
| |
| // memory_copy.wast:4074 |
| assert_return(() => call($19, "load8_u", [21_889]), 0); |
| |
| // memory_copy.wast:4075 |
| assert_return(() => call($19, "load8_u", [22_088]), 0); |
| |
| // memory_copy.wast:4076 |
| assert_return(() => call($19, "load8_u", [22_287]), 0); |
| |
| // memory_copy.wast:4077 |
| assert_return(() => call($19, "load8_u", [22_486]), 0); |
| |
| // memory_copy.wast:4078 |
| assert_return(() => call($19, "load8_u", [22_685]), 0); |
| |
| // memory_copy.wast:4079 |
| assert_return(() => call($19, "load8_u", [22_884]), 0); |
| |
| // memory_copy.wast:4080 |
| assert_return(() => call($19, "load8_u", [23_083]), 0); |
| |
| // memory_copy.wast:4081 |
| assert_return(() => call($19, "load8_u", [23_282]), 0); |
| |
| // memory_copy.wast:4082 |
| assert_return(() => call($19, "load8_u", [23_481]), 0); |
| |
| // memory_copy.wast:4083 |
| assert_return(() => call($19, "load8_u", [23_680]), 0); |
| |
| // memory_copy.wast:4084 |
| assert_return(() => call($19, "load8_u", [23_879]), 0); |
| |
| // memory_copy.wast:4085 |
| assert_return(() => call($19, "load8_u", [24_078]), 0); |
| |
| // memory_copy.wast:4086 |
| assert_return(() => call($19, "load8_u", [24_277]), 0); |
| |
| // memory_copy.wast:4087 |
| assert_return(() => call($19, "load8_u", [24_476]), 0); |
| |
| // memory_copy.wast:4088 |
| assert_return(() => call($19, "load8_u", [24_675]), 0); |
| |
| // memory_copy.wast:4089 |
| assert_return(() => call($19, "load8_u", [24_874]), 0); |
| |
| // memory_copy.wast:4090 |
| assert_return(() => call($19, "load8_u", [25_073]), 0); |
| |
| // memory_copy.wast:4091 |
| assert_return(() => call($19, "load8_u", [25_272]), 0); |
| |
| // memory_copy.wast:4092 |
| assert_return(() => call($19, "load8_u", [25_471]), 0); |
| |
| // memory_copy.wast:4093 |
| assert_return(() => call($19, "load8_u", [25_670]), 0); |
| |
| // memory_copy.wast:4094 |
| assert_return(() => call($19, "load8_u", [25_869]), 0); |
| |
| // memory_copy.wast:4095 |
| assert_return(() => call($19, "load8_u", [26_068]), 0); |
| |
| // memory_copy.wast:4096 |
| assert_return(() => call($19, "load8_u", [26_267]), 0); |
| |
| // memory_copy.wast:4097 |
| assert_return(() => call($19, "load8_u", [26_466]), 0); |
| |
| // memory_copy.wast:4098 |
| assert_return(() => call($19, "load8_u", [26_665]), 0); |
| |
| // memory_copy.wast:4099 |
| assert_return(() => call($19, "load8_u", [26_864]), 0); |
| |
| // memory_copy.wast:4100 |
| assert_return(() => call($19, "load8_u", [27_063]), 0); |
| |
| // memory_copy.wast:4101 |
| assert_return(() => call($19, "load8_u", [27_262]), 0); |
| |
| // memory_copy.wast:4102 |
| assert_return(() => call($19, "load8_u", [27_461]), 0); |
| |
| // memory_copy.wast:4103 |
| assert_return(() => call($19, "load8_u", [27_660]), 0); |
| |
| // memory_copy.wast:4104 |
| assert_return(() => call($19, "load8_u", [27_859]), 0); |
| |
| // memory_copy.wast:4105 |
| assert_return(() => call($19, "load8_u", [28_058]), 0); |
| |
| // memory_copy.wast:4106 |
| assert_return(() => call($19, "load8_u", [28_257]), 0); |
| |
| // memory_copy.wast:4107 |
| assert_return(() => call($19, "load8_u", [28_456]), 0); |
| |
| // memory_copy.wast:4108 |
| assert_return(() => call($19, "load8_u", [28_655]), 0); |
| |
| // memory_copy.wast:4109 |
| assert_return(() => call($19, "load8_u", [28_854]), 0); |
| |
| // memory_copy.wast:4110 |
| assert_return(() => call($19, "load8_u", [29_053]), 0); |
| |
| // memory_copy.wast:4111 |
| assert_return(() => call($19, "load8_u", [29_252]), 0); |
| |
| // memory_copy.wast:4112 |
| assert_return(() => call($19, "load8_u", [29_451]), 0); |
| |
| // memory_copy.wast:4113 |
| assert_return(() => call($19, "load8_u", [29_650]), 0); |
| |
| // memory_copy.wast:4114 |
| assert_return(() => call($19, "load8_u", [29_849]), 0); |
| |
| // memory_copy.wast:4115 |
| assert_return(() => call($19, "load8_u", [30_048]), 0); |
| |
| // memory_copy.wast:4116 |
| assert_return(() => call($19, "load8_u", [30_247]), 0); |
| |
| // memory_copy.wast:4117 |
| assert_return(() => call($19, "load8_u", [30_446]), 0); |
| |
| // memory_copy.wast:4118 |
| assert_return(() => call($19, "load8_u", [30_645]), 0); |
| |
| // memory_copy.wast:4119 |
| assert_return(() => call($19, "load8_u", [30_844]), 0); |
| |
| // memory_copy.wast:4120 |
| assert_return(() => call($19, "load8_u", [31_043]), 0); |
| |
| // memory_copy.wast:4121 |
| assert_return(() => call($19, "load8_u", [31_242]), 0); |
| |
| // memory_copy.wast:4122 |
| assert_return(() => call($19, "load8_u", [31_441]), 0); |
| |
| // memory_copy.wast:4123 |
| assert_return(() => call($19, "load8_u", [31_640]), 0); |
| |
| // memory_copy.wast:4124 |
| assert_return(() => call($19, "load8_u", [31_839]), 0); |
| |
| // memory_copy.wast:4125 |
| assert_return(() => call($19, "load8_u", [32_038]), 0); |
| |
| // memory_copy.wast:4126 |
| assert_return(() => call($19, "load8_u", [32_237]), 0); |
| |
| // memory_copy.wast:4127 |
| assert_return(() => call($19, "load8_u", [32_436]), 0); |
| |
| // memory_copy.wast:4128 |
| assert_return(() => call($19, "load8_u", [32_635]), 0); |
| |
| // memory_copy.wast:4129 |
| assert_return(() => call($19, "load8_u", [32_834]), 0); |
| |
| // memory_copy.wast:4130 |
| assert_return(() => call($19, "load8_u", [33_033]), 0); |
| |
| // memory_copy.wast:4131 |
| assert_return(() => call($19, "load8_u", [33_232]), 0); |
| |
| // memory_copy.wast:4132 |
| assert_return(() => call($19, "load8_u", [33_431]), 0); |
| |
| // memory_copy.wast:4133 |
| assert_return(() => call($19, "load8_u", [33_630]), 0); |
| |
| // memory_copy.wast:4134 |
| assert_return(() => call($19, "load8_u", [33_829]), 0); |
| |
| // memory_copy.wast:4135 |
| assert_return(() => call($19, "load8_u", [34_028]), 0); |
| |
| // memory_copy.wast:4136 |
| assert_return(() => call($19, "load8_u", [34_227]), 0); |
| |
| // memory_copy.wast:4137 |
| assert_return(() => call($19, "load8_u", [34_426]), 0); |
| |
| // memory_copy.wast:4138 |
| assert_return(() => call($19, "load8_u", [34_625]), 0); |
| |
| // memory_copy.wast:4139 |
| assert_return(() => call($19, "load8_u", [34_824]), 0); |
| |
| // memory_copy.wast:4140 |
| assert_return(() => call($19, "load8_u", [35_023]), 0); |
| |
| // memory_copy.wast:4141 |
| assert_return(() => call($19, "load8_u", [35_222]), 0); |
| |
| // memory_copy.wast:4142 |
| assert_return(() => call($19, "load8_u", [35_421]), 0); |
| |
| // memory_copy.wast:4143 |
| assert_return(() => call($19, "load8_u", [35_620]), 0); |
| |
| // memory_copy.wast:4144 |
| assert_return(() => call($19, "load8_u", [35_819]), 0); |
| |
| // memory_copy.wast:4145 |
| assert_return(() => call($19, "load8_u", [36_018]), 0); |
| |
| // memory_copy.wast:4146 |
| assert_return(() => call($19, "load8_u", [36_217]), 0); |
| |
| // memory_copy.wast:4147 |
| assert_return(() => call($19, "load8_u", [36_416]), 0); |
| |
| // memory_copy.wast:4148 |
| assert_return(() => call($19, "load8_u", [36_615]), 0); |
| |
| // memory_copy.wast:4149 |
| assert_return(() => call($19, "load8_u", [36_814]), 0); |
| |
| // memory_copy.wast:4150 |
| assert_return(() => call($19, "load8_u", [37_013]), 0); |
| |
| // memory_copy.wast:4151 |
| assert_return(() => call($19, "load8_u", [37_212]), 0); |
| |
| // memory_copy.wast:4152 |
| assert_return(() => call($19, "load8_u", [37_411]), 0); |
| |
| // memory_copy.wast:4153 |
| assert_return(() => call($19, "load8_u", [37_610]), 0); |
| |
| // memory_copy.wast:4154 |
| assert_return(() => call($19, "load8_u", [37_809]), 0); |
| |
| // memory_copy.wast:4155 |
| assert_return(() => call($19, "load8_u", [38_008]), 0); |
| |
| // memory_copy.wast:4156 |
| assert_return(() => call($19, "load8_u", [38_207]), 0); |
| |
| // memory_copy.wast:4157 |
| assert_return(() => call($19, "load8_u", [38_406]), 0); |
| |
| // memory_copy.wast:4158 |
| assert_return(() => call($19, "load8_u", [38_605]), 0); |
| |
| // memory_copy.wast:4159 |
| assert_return(() => call($19, "load8_u", [38_804]), 0); |
| |
| // memory_copy.wast:4160 |
| assert_return(() => call($19, "load8_u", [39_003]), 0); |
| |
| // memory_copy.wast:4161 |
| assert_return(() => call($19, "load8_u", [39_202]), 0); |
| |
| // memory_copy.wast:4162 |
| assert_return(() => call($19, "load8_u", [39_401]), 0); |
| |
| // memory_copy.wast:4163 |
| assert_return(() => call($19, "load8_u", [39_600]), 0); |
| |
| // memory_copy.wast:4164 |
| assert_return(() => call($19, "load8_u", [39_799]), 0); |
| |
| // memory_copy.wast:4165 |
| assert_return(() => call($19, "load8_u", [39_998]), 0); |
| |
| // memory_copy.wast:4166 |
| assert_return(() => call($19, "load8_u", [40_197]), 0); |
| |
| // memory_copy.wast:4167 |
| assert_return(() => call($19, "load8_u", [40_396]), 0); |
| |
| // memory_copy.wast:4168 |
| assert_return(() => call($19, "load8_u", [40_595]), 0); |
| |
| // memory_copy.wast:4169 |
| assert_return(() => call($19, "load8_u", [40_794]), 0); |
| |
| // memory_copy.wast:4170 |
| assert_return(() => call($19, "load8_u", [40_993]), 0); |
| |
| // memory_copy.wast:4171 |
| assert_return(() => call($19, "load8_u", [41_192]), 0); |
| |
| // memory_copy.wast:4172 |
| assert_return(() => call($19, "load8_u", [41_391]), 0); |
| |
| // memory_copy.wast:4173 |
| assert_return(() => call($19, "load8_u", [41_590]), 0); |
| |
| // memory_copy.wast:4174 |
| assert_return(() => call($19, "load8_u", [41_789]), 0); |
| |
| // memory_copy.wast:4175 |
| assert_return(() => call($19, "load8_u", [41_988]), 0); |
| |
| // memory_copy.wast:4176 |
| assert_return(() => call($19, "load8_u", [42_187]), 0); |
| |
| // memory_copy.wast:4177 |
| assert_return(() => call($19, "load8_u", [42_386]), 0); |
| |
| // memory_copy.wast:4178 |
| assert_return(() => call($19, "load8_u", [42_585]), 0); |
| |
| // memory_copy.wast:4179 |
| assert_return(() => call($19, "load8_u", [42_784]), 0); |
| |
| // memory_copy.wast:4180 |
| assert_return(() => call($19, "load8_u", [42_983]), 0); |
| |
| // memory_copy.wast:4181 |
| assert_return(() => call($19, "load8_u", [43_182]), 0); |
| |
| // memory_copy.wast:4182 |
| assert_return(() => call($19, "load8_u", [43_381]), 0); |
| |
| // memory_copy.wast:4183 |
| assert_return(() => call($19, "load8_u", [43_580]), 0); |
| |
| // memory_copy.wast:4184 |
| assert_return(() => call($19, "load8_u", [43_779]), 0); |
| |
| // memory_copy.wast:4185 |
| assert_return(() => call($19, "load8_u", [43_978]), 0); |
| |
| // memory_copy.wast:4186 |
| assert_return(() => call($19, "load8_u", [44_177]), 0); |
| |
| // memory_copy.wast:4187 |
| assert_return(() => call($19, "load8_u", [44_376]), 0); |
| |
| // memory_copy.wast:4188 |
| assert_return(() => call($19, "load8_u", [44_575]), 0); |
| |
| // memory_copy.wast:4189 |
| assert_return(() => call($19, "load8_u", [44_774]), 0); |
| |
| // memory_copy.wast:4190 |
| assert_return(() => call($19, "load8_u", [44_973]), 0); |
| |
| // memory_copy.wast:4191 |
| assert_return(() => call($19, "load8_u", [45_172]), 0); |
| |
| // memory_copy.wast:4192 |
| assert_return(() => call($19, "load8_u", [45_371]), 0); |
| |
| // memory_copy.wast:4193 |
| assert_return(() => call($19, "load8_u", [45_570]), 0); |
| |
| // memory_copy.wast:4194 |
| assert_return(() => call($19, "load8_u", [45_769]), 0); |
| |
| // memory_copy.wast:4195 |
| assert_return(() => call($19, "load8_u", [45_968]), 0); |
| |
| // memory_copy.wast:4196 |
| assert_return(() => call($19, "load8_u", [46_167]), 0); |
| |
| // memory_copy.wast:4197 |
| assert_return(() => call($19, "load8_u", [46_366]), 0); |
| |
| // memory_copy.wast:4198 |
| assert_return(() => call($19, "load8_u", [46_565]), 0); |
| |
| // memory_copy.wast:4199 |
| assert_return(() => call($19, "load8_u", [46_764]), 0); |
| |
| // memory_copy.wast:4200 |
| assert_return(() => call($19, "load8_u", [46_963]), 0); |
| |
| // memory_copy.wast:4201 |
| assert_return(() => call($19, "load8_u", [47_162]), 0); |
| |
| // memory_copy.wast:4202 |
| assert_return(() => call($19, "load8_u", [47_361]), 0); |
| |
| // memory_copy.wast:4203 |
| assert_return(() => call($19, "load8_u", [47_560]), 0); |
| |
| // memory_copy.wast:4204 |
| assert_return(() => call($19, "load8_u", [47_759]), 0); |
| |
| // memory_copy.wast:4205 |
| assert_return(() => call($19, "load8_u", [47_958]), 0); |
| |
| // memory_copy.wast:4206 |
| assert_return(() => call($19, "load8_u", [48_157]), 0); |
| |
| // memory_copy.wast:4207 |
| assert_return(() => call($19, "load8_u", [48_356]), 0); |
| |
| // memory_copy.wast:4208 |
| assert_return(() => call($19, "load8_u", [48_555]), 0); |
| |
| // memory_copy.wast:4209 |
| assert_return(() => call($19, "load8_u", [48_754]), 0); |
| |
| // memory_copy.wast:4210 |
| assert_return(() => call($19, "load8_u", [48_953]), 0); |
| |
| // memory_copy.wast:4211 |
| assert_return(() => call($19, "load8_u", [49_152]), 0); |
| |
| // memory_copy.wast:4212 |
| assert_return(() => call($19, "load8_u", [49_351]), 0); |
| |
| // memory_copy.wast:4213 |
| assert_return(() => call($19, "load8_u", [49_550]), 0); |
| |
| // memory_copy.wast:4214 |
| assert_return(() => call($19, "load8_u", [49_749]), 0); |
| |
| // memory_copy.wast:4215 |
| assert_return(() => call($19, "load8_u", [49_948]), 0); |
| |
| // memory_copy.wast:4216 |
| assert_return(() => call($19, "load8_u", [50_147]), 0); |
| |
| // memory_copy.wast:4217 |
| assert_return(() => call($19, "load8_u", [50_346]), 0); |
| |
| // memory_copy.wast:4218 |
| assert_return(() => call($19, "load8_u", [50_545]), 0); |
| |
| // memory_copy.wast:4219 |
| assert_return(() => call($19, "load8_u", [50_744]), 0); |
| |
| // memory_copy.wast:4220 |
| assert_return(() => call($19, "load8_u", [50_943]), 0); |
| |
| // memory_copy.wast:4221 |
| assert_return(() => call($19, "load8_u", [51_142]), 0); |
| |
| // memory_copy.wast:4222 |
| assert_return(() => call($19, "load8_u", [51_341]), 0); |
| |
| // memory_copy.wast:4223 |
| assert_return(() => call($19, "load8_u", [51_540]), 0); |
| |
| // memory_copy.wast:4224 |
| assert_return(() => call($19, "load8_u", [51_739]), 0); |
| |
| // memory_copy.wast:4225 |
| assert_return(() => call($19, "load8_u", [51_938]), 0); |
| |
| // memory_copy.wast:4226 |
| assert_return(() => call($19, "load8_u", [52_137]), 0); |
| |
| // memory_copy.wast:4227 |
| assert_return(() => call($19, "load8_u", [52_336]), 0); |
| |
| // memory_copy.wast:4228 |
| assert_return(() => call($19, "load8_u", [52_535]), 0); |
| |
| // memory_copy.wast:4229 |
| assert_return(() => call($19, "load8_u", [52_734]), 0); |
| |
| // memory_copy.wast:4230 |
| assert_return(() => call($19, "load8_u", [52_933]), 0); |
| |
| // memory_copy.wast:4231 |
| assert_return(() => call($19, "load8_u", [53_132]), 0); |
| |
| // memory_copy.wast:4232 |
| assert_return(() => call($19, "load8_u", [53_331]), 0); |
| |
| // memory_copy.wast:4233 |
| assert_return(() => call($19, "load8_u", [53_530]), 0); |
| |
| // memory_copy.wast:4234 |
| assert_return(() => call($19, "load8_u", [53_729]), 0); |
| |
| // memory_copy.wast:4235 |
| assert_return(() => call($19, "load8_u", [53_928]), 0); |
| |
| // memory_copy.wast:4236 |
| assert_return(() => call($19, "load8_u", [54_127]), 0); |
| |
| // memory_copy.wast:4237 |
| assert_return(() => call($19, "load8_u", [54_326]), 0); |
| |
| // memory_copy.wast:4238 |
| assert_return(() => call($19, "load8_u", [54_525]), 0); |
| |
| // memory_copy.wast:4239 |
| assert_return(() => call($19, "load8_u", [54_724]), 0); |
| |
| // memory_copy.wast:4240 |
| assert_return(() => call($19, "load8_u", [54_923]), 0); |
| |
| // memory_copy.wast:4241 |
| assert_return(() => call($19, "load8_u", [55_122]), 0); |
| |
| // memory_copy.wast:4242 |
| assert_return(() => call($19, "load8_u", [55_321]), 0); |
| |
| // memory_copy.wast:4243 |
| assert_return(() => call($19, "load8_u", [55_520]), 0); |
| |
| // memory_copy.wast:4244 |
| assert_return(() => call($19, "load8_u", [55_719]), 0); |
| |
| // memory_copy.wast:4245 |
| assert_return(() => call($19, "load8_u", [55_918]), 0); |
| |
| // memory_copy.wast:4246 |
| assert_return(() => call($19, "load8_u", [56_117]), 0); |
| |
| // memory_copy.wast:4247 |
| assert_return(() => call($19, "load8_u", [56_316]), 0); |
| |
| // memory_copy.wast:4248 |
| assert_return(() => call($19, "load8_u", [56_515]), 0); |
| |
| // memory_copy.wast:4249 |
| assert_return(() => call($19, "load8_u", [56_714]), 0); |
| |
| // memory_copy.wast:4250 |
| assert_return(() => call($19, "load8_u", [56_913]), 0); |
| |
| // memory_copy.wast:4251 |
| assert_return(() => call($19, "load8_u", [57_112]), 0); |
| |
| // memory_copy.wast:4252 |
| assert_return(() => call($19, "load8_u", [57_311]), 0); |
| |
| // memory_copy.wast:4253 |
| assert_return(() => call($19, "load8_u", [57_510]), 0); |
| |
| // memory_copy.wast:4254 |
| assert_return(() => call($19, "load8_u", [57_709]), 0); |
| |
| // memory_copy.wast:4255 |
| assert_return(() => call($19, "load8_u", [57_908]), 0); |
| |
| // memory_copy.wast:4256 |
| assert_return(() => call($19, "load8_u", [58_107]), 0); |
| |
| // memory_copy.wast:4257 |
| assert_return(() => call($19, "load8_u", [58_306]), 0); |
| |
| // memory_copy.wast:4258 |
| assert_return(() => call($19, "load8_u", [58_505]), 0); |
| |
| // memory_copy.wast:4259 |
| assert_return(() => call($19, "load8_u", [58_704]), 0); |
| |
| // memory_copy.wast:4260 |
| assert_return(() => call($19, "load8_u", [58_903]), 0); |
| |
| // memory_copy.wast:4261 |
| assert_return(() => call($19, "load8_u", [59_102]), 0); |
| |
| // memory_copy.wast:4262 |
| assert_return(() => call($19, "load8_u", [59_301]), 0); |
| |
| // memory_copy.wast:4263 |
| assert_return(() => call($19, "load8_u", [59_500]), 0); |
| |
| // memory_copy.wast:4264 |
| assert_return(() => call($19, "load8_u", [59_699]), 0); |
| |
| // memory_copy.wast:4265 |
| assert_return(() => call($19, "load8_u", [59_898]), 0); |
| |
| // memory_copy.wast:4266 |
| assert_return(() => call($19, "load8_u", [60_097]), 0); |
| |
| // memory_copy.wast:4267 |
| assert_return(() => call($19, "load8_u", [60_296]), 0); |
| |
| // memory_copy.wast:4268 |
| assert_return(() => call($19, "load8_u", [60_495]), 0); |
| |
| // memory_copy.wast:4269 |
| assert_return(() => call($19, "load8_u", [60_694]), 0); |
| |
| // memory_copy.wast:4270 |
| assert_return(() => call($19, "load8_u", [60_893]), 0); |
| |
| // memory_copy.wast:4271 |
| assert_return(() => call($19, "load8_u", [61_092]), 0); |
| |
| // memory_copy.wast:4272 |
| assert_return(() => call($19, "load8_u", [61_291]), 0); |
| |
| // memory_copy.wast:4273 |
| assert_return(() => call($19, "load8_u", [61_440]), 0); |
| |
| // memory_copy.wast:4274 |
| assert_return(() => call($19, "load8_u", [61_441]), 1); |
| |
| // memory_copy.wast:4275 |
| assert_return(() => call($19, "load8_u", [61_442]), 2); |
| |
| // memory_copy.wast:4276 |
| assert_return(() => call($19, "load8_u", [61_443]), 3); |
| |
| // memory_copy.wast:4277 |
| assert_return(() => call($19, "load8_u", [61_444]), 4); |
| |
| // memory_copy.wast:4278 |
| assert_return(() => call($19, "load8_u", [61_445]), 5); |
| |
| // memory_copy.wast:4279 |
| assert_return(() => call($19, "load8_u", [61_446]), 6); |
| |
| // memory_copy.wast:4280 |
| assert_return(() => call($19, "load8_u", [61_447]), 7); |
| |
| // memory_copy.wast:4281 |
| assert_return(() => call($19, "load8_u", [61_448]), 8); |
| |
| // memory_copy.wast:4282 |
| assert_return(() => call($19, "load8_u", [61_449]), 9); |
| |
| // memory_copy.wast:4283 |
| assert_return(() => call($19, "load8_u", [61_450]), 10); |
| |
| // memory_copy.wast:4284 |
| assert_return(() => call($19, "load8_u", [61_451]), 11); |
| |
| // memory_copy.wast:4285 |
| assert_return(() => call($19, "load8_u", [61_452]), 12); |
| |
| // memory_copy.wast:4286 |
| assert_return(() => call($19, "load8_u", [61_453]), 13); |
| |
| // memory_copy.wast:4287 |
| assert_return(() => call($19, "load8_u", [61_454]), 14); |
| |
| // memory_copy.wast:4288 |
| assert_return(() => call($19, "load8_u", [61_455]), 15); |
| |
| // memory_copy.wast:4289 |
| assert_return(() => call($19, "load8_u", [61_456]), 16); |
| |
| // memory_copy.wast:4290 |
| assert_return(() => call($19, "load8_u", [61_457]), 17); |
| |
| // memory_copy.wast:4291 |
| assert_return(() => call($19, "load8_u", [61_458]), 18); |
| |
| // memory_copy.wast:4292 |
| assert_return(() => call($19, "load8_u", [61_459]), 19); |
| |
| // memory_copy.wast:4293 |
| assert_return(() => call($19, "load8_u", [61_510]), 0); |
| |
| // memory_copy.wast:4294 |
| assert_return(() => call($19, "load8_u", [61_709]), 0); |
| |
| // memory_copy.wast:4295 |
| assert_return(() => call($19, "load8_u", [61_908]), 0); |
| |
| // memory_copy.wast:4296 |
| assert_return(() => call($19, "load8_u", [62_107]), 0); |
| |
| // memory_copy.wast:4297 |
| assert_return(() => call($19, "load8_u", [62_306]), 0); |
| |
| // memory_copy.wast:4298 |
| assert_return(() => call($19, "load8_u", [62_505]), 0); |
| |
| // memory_copy.wast:4299 |
| assert_return(() => call($19, "load8_u", [62_704]), 0); |
| |
| // memory_copy.wast:4300 |
| assert_return(() => call($19, "load8_u", [62_903]), 0); |
| |
| // memory_copy.wast:4301 |
| assert_return(() => call($19, "load8_u", [63_102]), 0); |
| |
| // memory_copy.wast:4302 |
| assert_return(() => call($19, "load8_u", [63_301]), 0); |
| |
| // memory_copy.wast:4303 |
| assert_return(() => call($19, "load8_u", [63_500]), 0); |
| |
| // memory_copy.wast:4304 |
| assert_return(() => call($19, "load8_u", [63_699]), 0); |
| |
| // memory_copy.wast:4305 |
| assert_return(() => call($19, "load8_u", [63_898]), 0); |
| |
| // memory_copy.wast:4306 |
| assert_return(() => call($19, "load8_u", [64_097]), 0); |
| |
| // memory_copy.wast:4307 |
| assert_return(() => call($19, "load8_u", [64_296]), 0); |
| |
| // memory_copy.wast:4308 |
| assert_return(() => call($19, "load8_u", [64_495]), 0); |
| |
| // memory_copy.wast:4309 |
| assert_return(() => call($19, "load8_u", [64_694]), 0); |
| |
| // memory_copy.wast:4310 |
| assert_return(() => call($19, "load8_u", [64_893]), 0); |
| |
| // memory_copy.wast:4311 |
| assert_return(() => call($19, "load8_u", [65_092]), 0); |
| |
| // memory_copy.wast:4312 |
| assert_return(() => call($19, "load8_u", [65_291]), 0); |
| |
| // memory_copy.wast:4313 |
| assert_return(() => call($19, "load8_u", [65_490]), 0); |
| |
| // memory_copy.wast:4315 |
| assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x07\x8a\x80\x80\x80\x00\x01\x06\x74\x65\x73\x74\x66\x6e\x00\x00\x0a\x92\x80\x80\x80\x00\x01\x8c\x80\x80\x80\x00\x00\x41\x0a\x41\x14\x41\x1e\xfc\x0a\x00\x00\x0b"); |
| |
| // memory_copy.wast:4321 |
| assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x05\x84\x80\x80\x80\x00\x01\x01\x01\x01\x07\x8a\x80\x80\x80\x00\x01\x06\x74\x65\x73\x74\x66\x6e\x00\x00\x0a\x95\x80\x80\x80\x00\x01\x8f\x80\x80\x80\x00\x00\x41\x0a\x41\x14\x43\x00\x00\xf0\x41\xfc\x0a\x00\x00\x0b"); |
| |
| // memory_copy.wast:4328 |
| assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x05\x84\x80\x80\x80\x00\x01\x01\x01\x01\x07\x8a\x80\x80\x80\x00\x01\x06\x74\x65\x73\x74\x66\x6e\x00\x00\x0a\x92\x80\x80\x80\x00\x01\x8c\x80\x80\x80\x00\x00\x41\x0a\x41\x14\x42\x1e\xfc\x0a\x00\x00\x0b"); |
| |
| // memory_copy.wast:4335 |
| assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x05\x84\x80\x80\x80\x00\x01\x01\x01\x01\x07\x8a\x80\x80\x80\x00\x01\x06\x74\x65\x73\x74\x66\x6e\x00\x00\x0a\x99\x80\x80\x80\x00\x01\x93\x80\x80\x80\x00\x00\x41\x0a\x41\x14\x44\x00\x00\x00\x00\x00\x00\x3e\x40\xfc\x0a\x00\x00\x0b"); |
| |
| // memory_copy.wast:4342 |
| assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x05\x84\x80\x80\x80\x00\x01\x01\x01\x01\x07\x8a\x80\x80\x80\x00\x01\x06\x74\x65\x73\x74\x66\x6e\x00\x00\x0a\x95\x80\x80\x80\x00\x01\x8f\x80\x80\x80\x00\x00\x41\x0a\x43\x00\x00\xa0\x41\x41\x1e\xfc\x0a\x00\x00\x0b"); |
| |
| // memory_copy.wast:4349 |
| assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x05\x84\x80\x80\x80\x00\x01\x01\x01\x01\x07\x8a\x80\x80\x80\x00\x01\x06\x74\x65\x73\x74\x66\x6e\x00\x00\x0a\x98\x80\x80\x80\x00\x01\x92\x80\x80\x80\x00\x00\x41\x0a\x43\x00\x00\xa0\x41\x43\x00\x00\xf0\x41\xfc\x0a\x00\x00\x0b"); |
| |
| // memory_copy.wast:4356 |
| assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x05\x84\x80\x80\x80\x00\x01\x01\x01\x01\x07\x8a\x80\x80\x80\x00\x01\x06\x74\x65\x73\x74\x66\x6e\x00\x00\x0a\x95\x80\x80\x80\x00\x01\x8f\x80\x80\x80\x00\x00\x41\x0a\x43\x00\x00\xa0\x41\x42\x1e\xfc\x0a\x00\x00\x0b"); |
| |
| // memory_copy.wast:4363 |
| assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x05\x84\x80\x80\x80\x00\x01\x01\x01\x01\x07\x8a\x80\x80\x80\x00\x01\x06\x74\x65\x73\x74\x66\x6e\x00\x00\x0a\x9c\x80\x80\x80\x00\x01\x96\x80\x80\x80\x00\x00\x41\x0a\x43\x00\x00\xa0\x41\x44\x00\x00\x00\x00\x00\x00\x3e\x40\xfc\x0a\x00\x00\x0b"); |
| |
| // memory_copy.wast:4370 |
| assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x05\x84\x80\x80\x80\x00\x01\x01\x01\x01\x07\x8a\x80\x80\x80\x00\x01\x06\x74\x65\x73\x74\x66\x6e\x00\x00\x0a\x92\x80\x80\x80\x00\x01\x8c\x80\x80\x80\x00\x00\x41\x0a\x42\x14\x41\x1e\xfc\x0a\x00\x00\x0b"); |
| |
| // memory_copy.wast:4377 |
| assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x05\x84\x80\x80\x80\x00\x01\x01\x01\x01\x07\x8a\x80\x80\x80\x00\x01\x06\x74\x65\x73\x74\x66\x6e\x00\x00\x0a\x95\x80\x80\x80\x00\x01\x8f\x80\x80\x80\x00\x00\x41\x0a\x42\x14\x43\x00\x00\xf0\x41\xfc\x0a\x00\x00\x0b"); |
| |
| // memory_copy.wast:4384 |
| assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x05\x84\x80\x80\x80\x00\x01\x01\x01\x01\x07\x8a\x80\x80\x80\x00\x01\x06\x74\x65\x73\x74\x66\x6e\x00\x00\x0a\x92\x80\x80\x80\x00\x01\x8c\x80\x80\x80\x00\x00\x41\x0a\x42\x14\x42\x1e\xfc\x0a\x00\x00\x0b"); |
| |
| // memory_copy.wast:4391 |
| assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x05\x84\x80\x80\x80\x00\x01\x01\x01\x01\x07\x8a\x80\x80\x80\x00\x01\x06\x74\x65\x73\x74\x66\x6e\x00\x00\x0a\x99\x80\x80\x80\x00\x01\x93\x80\x80\x80\x00\x00\x41\x0a\x42\x14\x44\x00\x00\x00\x00\x00\x00\x3e\x40\xfc\x0a\x00\x00\x0b"); |
| |
| // memory_copy.wast:4398 |
| assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x05\x84\x80\x80\x80\x00\x01\x01\x01\x01\x07\x8a\x80\x80\x80\x00\x01\x06\x74\x65\x73\x74\x66\x6e\x00\x00\x0a\x99\x80\x80\x80\x00\x01\x93\x80\x80\x80\x00\x00\x41\x0a\x44\x00\x00\x00\x00\x00\x00\x34\x40\x41\x1e\xfc\x0a\x00\x00\x0b"); |
| |
| // memory_copy.wast:4405 |
| assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x05\x84\x80\x80\x80\x00\x01\x01\x01\x01\x07\x8a\x80\x80\x80\x00\x01\x06\x74\x65\x73\x74\x66\x6e\x00\x00\x0a\x9c\x80\x80\x80\x00\x01\x96\x80\x80\x80\x00\x00\x41\x0a\x44\x00\x00\x00\x00\x00\x00\x34\x40\x43\x00\x00\xf0\x41\xfc\x0a\x00\x00\x0b"); |
| |
| // memory_copy.wast:4412 |
| assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x05\x84\x80\x80\x80\x00\x01\x01\x01\x01\x07\x8a\x80\x80\x80\x00\x01\x06\x74\x65\x73\x74\x66\x6e\x00\x00\x0a\x99\x80\x80\x80\x00\x01\x93\x80\x80\x80\x00\x00\x41\x0a\x44\x00\x00\x00\x00\x00\x00\x34\x40\x42\x1e\xfc\x0a\x00\x00\x0b"); |
| |
| // memory_copy.wast:4419 |
| assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x05\x84\x80\x80\x80\x00\x01\x01\x01\x01\x07\x8a\x80\x80\x80\x00\x01\x06\x74\x65\x73\x74\x66\x6e\x00\x00\x0a\xa0\x80\x80\x80\x00\x01\x9a\x80\x80\x80\x00\x00\x41\x0a\x44\x00\x00\x00\x00\x00\x00\x34\x40\x44\x00\x00\x00\x00\x00\x00\x3e\x40\xfc\x0a\x00\x00\x0b"); |
| |
| // memory_copy.wast:4426 |
| assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x05\x84\x80\x80\x80\x00\x01\x01\x01\x01\x07\x8a\x80\x80\x80\x00\x01\x06\x74\x65\x73\x74\x66\x6e\x00\x00\x0a\x95\x80\x80\x80\x00\x01\x8f\x80\x80\x80\x00\x00\x43\x00\x00\x20\x41\x41\x14\x41\x1e\xfc\x0a\x00\x00\x0b"); |
| |
| // memory_copy.wast:4433 |
| assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x05\x84\x80\x80\x80\x00\x01\x01\x01\x01\x07\x8a\x80\x80\x80\x00\x01\x06\x74\x65\x73\x74\x66\x6e\x00\x00\x0a\x98\x80\x80\x80\x00\x01\x92\x80\x80\x80\x00\x00\x43\x00\x00\x20\x41\x41\x14\x43\x00\x00\xf0\x41\xfc\x0a\x00\x00\x0b"); |
| |
| // memory_copy.wast:4440 |
| assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x05\x84\x80\x80\x80\x00\x01\x01\x01\x01\x07\x8a\x80\x80\x80\x00\x01\x06\x74\x65\x73\x74\x66\x6e\x00\x00\x0a\x95\x80\x80\x80\x00\x01\x8f\x80\x80\x80\x00\x00\x43\x00\x00\x20\x41\x41\x14\x42\x1e\xfc\x0a\x00\x00\x0b"); |
| |
| // memory_copy.wast:4447 |
| assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x05\x84\x80\x80\x80\x00\x01\x01\x01\x01\x07\x8a\x80\x80\x80\x00\x01\x06\x74\x65\x73\x74\x66\x6e\x00\x00\x0a\x9c\x80\x80\x80\x00\x01\x96\x80\x80\x80\x00\x00\x43\x00\x00\x20\x41\x41\x14\x44\x00\x00\x00\x00\x00\x00\x3e\x40\xfc\x0a\x00\x00\x0b"); |
| |
| // memory_copy.wast:4454 |
| assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x05\x84\x80\x80\x80\x00\x01\x01\x01\x01\x07\x8a\x80\x80\x80\x00\x01\x06\x74\x65\x73\x74\x66\x6e\x00\x00\x0a\x98\x80\x80\x80\x00\x01\x92\x80\x80\x80\x00\x00\x43\x00\x00\x20\x41\x43\x00\x00\xa0\x41\x41\x1e\xfc\x0a\x00\x00\x0b"); |
| |
| // memory_copy.wast:4461 |
| assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x05\x84\x80\x80\x80\x00\x01\x01\x01\x01\x07\x8a\x80\x80\x80\x00\x01\x06\x74\x65\x73\x74\x66\x6e\x00\x00\x0a\x9b\x80\x80\x80\x00\x01\x95\x80\x80\x80\x00\x00\x43\x00\x00\x20\x41\x43\x00\x00\xa0\x41\x43\x00\x00\xf0\x41\xfc\x0a\x00\x00\x0b"); |
| |
| // memory_copy.wast:4468 |
| assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x05\x84\x80\x80\x80\x00\x01\x01\x01\x01\x07\x8a\x80\x80\x80\x00\x01\x06\x74\x65\x73\x74\x66\x6e\x00\x00\x0a\x98\x80\x80\x80\x00\x01\x92\x80\x80\x80\x00\x00\x43\x00\x00\x20\x41\x43\x00\x00\xa0\x41\x42\x1e\xfc\x0a\x00\x00\x0b"); |
| |
| // memory_copy.wast:4475 |
| assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x05\x84\x80\x80\x80\x00\x01\x01\x01\x01\x07\x8a\x80\x80\x80\x00\x01\x06\x74\x65\x73\x74\x66\x6e\x00\x00\x0a\x9f\x80\x80\x80\x00\x01\x99\x80\x80\x80\x00\x00\x43\x00\x00\x20\x41\x43\x00\x00\xa0\x41\x44\x00\x00\x00\x00\x00\x00\x3e\x40\xfc\x0a\x00\x00\x0b"); |
| |
| // memory_copy.wast:4482 |
| assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x05\x84\x80\x80\x80\x00\x01\x01\x01\x01\x07\x8a\x80\x80\x80\x00\x01\x06\x74\x65\x73\x74\x66\x6e\x00\x00\x0a\x95\x80\x80\x80\x00\x01\x8f\x80\x80\x80\x00\x00\x43\x00\x00\x20\x41\x42\x14\x41\x1e\xfc\x0a\x00\x00\x0b"); |
| |
| // memory_copy.wast:4489 |
| assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x05\x84\x80\x80\x80\x00\x01\x01\x01\x01\x07\x8a\x80\x80\x80\x00\x01\x06\x74\x65\x73\x74\x66\x6e\x00\x00\x0a\x98\x80\x80\x80\x00\x01\x92\x80\x80\x80\x00\x00\x43\x00\x00\x20\x41\x42\x14\x43\x00\x00\xf0\x41\xfc\x0a\x00\x00\x0b"); |
| |
| // memory_copy.wast:4496 |
| assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x05\x84\x80\x80\x80\x00\x01\x01\x01\x01\x07\x8a\x80\x80\x80\x00\x01\x06\x74\x65\x73\x74\x66\x6e\x00\x00\x0a\x95\x80\x80\x80\x00\x01\x8f\x80\x80\x80\x00\x00\x43\x00\x00\x20\x41\x42\x14\x42\x1e\xfc\x0a\x00\x00\x0b"); |
| |
| // memory_copy.wast:4503 |
| assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x05\x84\x80\x80\x80\x00\x01\x01\x01\x01\x07\x8a\x80\x80\x80\x00\x01\x06\x74\x65\x73\x74\x66\x6e\x00\x00\x0a\x9c\x80\x80\x80\x00\x01\x96\x80\x80\x80\x00\x00\x43\x00\x00\x20\x41\x42\x14\x44\x00\x00\x00\x00\x00\x00\x3e\x40\xfc\x0a\x00\x00\x0b"); |
| |
| // memory_copy.wast:4510 |
| assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x05\x84\x80\x80\x80\x00\x01\x01\x01\x01\x07\x8a\x80\x80\x80\x00\x01\x06\x74\x65\x73\x74\x66\x6e\x00\x00\x0a\x9c\x80\x80\x80\x00\x01\x96\x80\x80\x80\x00\x00\x43\x00\x00\x20\x41\x44\x00\x00\x00\x00\x00\x00\x34\x40\x41\x1e\xfc\x0a\x00\x00\x0b"); |
| |
| // memory_copy.wast:4517 |
| assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x05\x84\x80\x80\x80\x00\x01\x01\x01\x01\x07\x8a\x80\x80\x80\x00\x01\x06\x74\x65\x73\x74\x66\x6e\x00\x00\x0a\x9f\x80\x80\x80\x00\x01\x99\x80\x80\x80\x00\x00\x43\x00\x00\x20\x41\x44\x00\x00\x00\x00\x00\x00\x34\x40\x43\x00\x00\xf0\x41\xfc\x0a\x00\x00\x0b"); |
| |
| // memory_copy.wast:4524 |
| assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x05\x84\x80\x80\x80\x00\x01\x01\x01\x01\x07\x8a\x80\x80\x80\x00\x01\x06\x74\x65\x73\x74\x66\x6e\x00\x00\x0a\x9c\x80\x80\x80\x00\x01\x96\x80\x80\x80\x00\x00\x43\x00\x00\x20\x41\x44\x00\x00\x00\x00\x00\x00\x34\x40\x42\x1e\xfc\x0a\x00\x00\x0b"); |
| |
| // memory_copy.wast:4531 |
| assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x05\x84\x80\x80\x80\x00\x01\x01\x01\x01\x07\x8a\x80\x80\x80\x00\x01\x06\x74\x65\x73\x74\x66\x6e\x00\x00\x0a\xa3\x80\x80\x80\x00\x01\x9d\x80\x80\x80\x00\x00\x43\x00\x00\x20\x41\x44\x00\x00\x00\x00\x00\x00\x34\x40\x44\x00\x00\x00\x00\x00\x00\x3e\x40\xfc\x0a\x00\x00\x0b"); |
| |
| // memory_copy.wast:4538 |
| assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x05\x84\x80\x80\x80\x00\x01\x01\x01\x01\x07\x8a\x80\x80\x80\x00\x01\x06\x74\x65\x73\x74\x66\x6e\x00\x00\x0a\x92\x80\x80\x80\x00\x01\x8c\x80\x80\x80\x00\x00\x42\x0a\x41\x14\x41\x1e\xfc\x0a\x00\x00\x0b"); |
| |
| // memory_copy.wast:4545 |
| assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x05\x84\x80\x80\x80\x00\x01\x01\x01\x01\x07\x8a\x80\x80\x80\x00\x01\x06\x74\x65\x73\x74\x66\x6e\x00\x00\x0a\x95\x80\x80\x80\x00\x01\x8f\x80\x80\x80\x00\x00\x42\x0a\x41\x14\x43\x00\x00\xf0\x41\xfc\x0a\x00\x00\x0b"); |
| |
| // memory_copy.wast:4552 |
| assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x05\x84\x80\x80\x80\x00\x01\x01\x01\x01\x07\x8a\x80\x80\x80\x00\x01\x06\x74\x65\x73\x74\x66\x6e\x00\x00\x0a\x92\x80\x80\x80\x00\x01\x8c\x80\x80\x80\x00\x00\x42\x0a\x41\x14\x42\x1e\xfc\x0a\x00\x00\x0b"); |
| |
| // memory_copy.wast:4559 |
| assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x05\x84\x80\x80\x80\x00\x01\x01\x01\x01\x07\x8a\x80\x80\x80\x00\x01\x06\x74\x65\x73\x74\x66\x6e\x00\x00\x0a\x99\x80\x80\x80\x00\x01\x93\x80\x80\x80\x00\x00\x42\x0a\x41\x14\x44\x00\x00\x00\x00\x00\x00\x3e\x40\xfc\x0a\x00\x00\x0b"); |
| |
| // memory_copy.wast:4566 |
| assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x05\x84\x80\x80\x80\x00\x01\x01\x01\x01\x07\x8a\x80\x80\x80\x00\x01\x06\x74\x65\x73\x74\x66\x6e\x00\x00\x0a\x95\x80\x80\x80\x00\x01\x8f\x80\x80\x80\x00\x00\x42\x0a\x43\x00\x00\xa0\x41\x41\x1e\xfc\x0a\x00\x00\x0b"); |
| |
| // memory_copy.wast:4573 |
| assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x05\x84\x80\x80\x80\x00\x01\x01\x01\x01\x07\x8a\x80\x80\x80\x00\x01\x06\x74\x65\x73\x74\x66\x6e\x00\x00\x0a\x98\x80\x80\x80\x00\x01\x92\x80\x80\x80\x00\x00\x42\x0a\x43\x00\x00\xa0\x41\x43\x00\x00\xf0\x41\xfc\x0a\x00\x00\x0b"); |
| |
| // memory_copy.wast:4580 |
| assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x05\x84\x80\x80\x80\x00\x01\x01\x01\x01\x07\x8a\x80\x80\x80\x00\x01\x06\x74\x65\x73\x74\x66\x6e\x00\x00\x0a\x95\x80\x80\x80\x00\x01\x8f\x80\x80\x80\x00\x00\x42\x0a\x43\x00\x00\xa0\x41\x42\x1e\xfc\x0a\x00\x00\x0b"); |
| |
| // memory_copy.wast:4587 |
| assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x05\x84\x80\x80\x80\x00\x01\x01\x01\x01\x07\x8a\x80\x80\x80\x00\x01\x06\x74\x65\x73\x74\x66\x6e\x00\x00\x0a\x9c\x80\x80\x80\x00\x01\x96\x80\x80\x80\x00\x00\x42\x0a\x43\x00\x00\xa0\x41\x44\x00\x00\x00\x00\x00\x00\x3e\x40\xfc\x0a\x00\x00\x0b"); |
| |
| // memory_copy.wast:4594 |
| assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x05\x84\x80\x80\x80\x00\x01\x01\x01\x01\x07\x8a\x80\x80\x80\x00\x01\x06\x74\x65\x73\x74\x66\x6e\x00\x00\x0a\x92\x80\x80\x80\x00\x01\x8c\x80\x80\x80\x00\x00\x42\x0a\x42\x14\x41\x1e\xfc\x0a\x00\x00\x0b"); |
| |
| // memory_copy.wast:4601 |
| assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x05\x84\x80\x80\x80\x00\x01\x01\x01\x01\x07\x8a\x80\x80\x80\x00\x01\x06\x74\x65\x73\x74\x66\x6e\x00\x00\x0a\x95\x80\x80\x80\x00\x01\x8f\x80\x80\x80\x00\x00\x42\x0a\x42\x14\x43\x00\x00\xf0\x41\xfc\x0a\x00\x00\x0b"); |
| |
| // memory_copy.wast:4608 |
| assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x05\x84\x80\x80\x80\x00\x01\x01\x01\x01\x07\x8a\x80\x80\x80\x00\x01\x06\x74\x65\x73\x74\x66\x6e\x00\x00\x0a\x92\x80\x80\x80\x00\x01\x8c\x80\x80\x80\x00\x00\x42\x0a\x42\x14\x42\x1e\xfc\x0a\x00\x00\x0b"); |
| |
| // memory_copy.wast:4615 |
| assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x05\x84\x80\x80\x80\x00\x01\x01\x01\x01\x07\x8a\x80\x80\x80\x00\x01\x06\x74\x65\x73\x74\x66\x6e\x00\x00\x0a\x99\x80\x80\x80\x00\x01\x93\x80\x80\x80\x00\x00\x42\x0a\x42\x14\x44\x00\x00\x00\x00\x00\x00\x3e\x40\xfc\x0a\x00\x00\x0b"); |
| |
| // memory_copy.wast:4622 |
| assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x05\x84\x80\x80\x80\x00\x01\x01\x01\x01\x07\x8a\x80\x80\x80\x00\x01\x06\x74\x65\x73\x74\x66\x6e\x00\x00\x0a\x99\x80\x80\x80\x00\x01\x93\x80\x80\x80\x00\x00\x42\x0a\x44\x00\x00\x00\x00\x00\x00\x34\x40\x41\x1e\xfc\x0a\x00\x00\x0b"); |
| |
| // memory_copy.wast:4629 |
| assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x05\x84\x80\x80\x80\x00\x01\x01\x01\x01\x07\x8a\x80\x80\x80\x00\x01\x06\x74\x65\x73\x74\x66\x6e\x00\x00\x0a\x9c\x80\x80\x80\x00\x01\x96\x80\x80\x80\x00\x00\x42\x0a\x44\x00\x00\x00\x00\x00\x00\x34\x40\x43\x00\x00\xf0\x41\xfc\x0a\x00\x00\x0b"); |
| |
| // memory_copy.wast:4636 |
| assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x05\x84\x80\x80\x80\x00\x01\x01\x01\x01\x07\x8a\x80\x80\x80\x00\x01\x06\x74\x65\x73\x74\x66\x6e\x00\x00\x0a\x99\x80\x80\x80\x00\x01\x93\x80\x80\x80\x00\x00\x42\x0a\x44\x00\x00\x00\x00\x00\x00\x34\x40\x42\x1e\xfc\x0a\x00\x00\x0b"); |
| |
| // memory_copy.wast:4643 |
| assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x05\x84\x80\x80\x80\x00\x01\x01\x01\x01\x07\x8a\x80\x80\x80\x00\x01\x06\x74\x65\x73\x74\x66\x6e\x00\x00\x0a\xa0\x80\x80\x80\x00\x01\x9a\x80\x80\x80\x00\x00\x42\x0a\x44\x00\x00\x00\x00\x00\x00\x34\x40\x44\x00\x00\x00\x00\x00\x00\x3e\x40\xfc\x0a\x00\x00\x0b"); |
| |
| // memory_copy.wast:4650 |
| assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x05\x84\x80\x80\x80\x00\x01\x01\x01\x01\x07\x8a\x80\x80\x80\x00\x01\x06\x74\x65\x73\x74\x66\x6e\x00\x00\x0a\x99\x80\x80\x80\x00\x01\x93\x80\x80\x80\x00\x00\x44\x00\x00\x00\x00\x00\x00\x24\x40\x41\x14\x41\x1e\xfc\x0a\x00\x00\x0b"); |
| |
| // memory_copy.wast:4657 |
| assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x05\x84\x80\x80\x80\x00\x01\x01\x01\x01\x07\x8a\x80\x80\x80\x00\x01\x06\x74\x65\x73\x74\x66\x6e\x00\x00\x0a\x9c\x80\x80\x80\x00\x01\x96\x80\x80\x80\x00\x00\x44\x00\x00\x00\x00\x00\x00\x24\x40\x41\x14\x43\x00\x00\xf0\x41\xfc\x0a\x00\x00\x0b"); |
| |
| // memory_copy.wast:4664 |
| assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x05\x84\x80\x80\x80\x00\x01\x01\x01\x01\x07\x8a\x80\x80\x80\x00\x01\x06\x74\x65\x73\x74\x66\x6e\x00\x00\x0a\x99\x80\x80\x80\x00\x01\x93\x80\x80\x80\x00\x00\x44\x00\x00\x00\x00\x00\x00\x24\x40\x41\x14\x42\x1e\xfc\x0a\x00\x00\x0b"); |
| |
| // memory_copy.wast:4671 |
| assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x05\x84\x80\x80\x80\x00\x01\x01\x01\x01\x07\x8a\x80\x80\x80\x00\x01\x06\x74\x65\x73\x74\x66\x6e\x00\x00\x0a\xa0\x80\x80\x80\x00\x01\x9a\x80\x80\x80\x00\x00\x44\x00\x00\x00\x00\x00\x00\x24\x40\x41\x14\x44\x00\x00\x00\x00\x00\x00\x3e\x40\xfc\x0a\x00\x00\x0b"); |
| |
| // memory_copy.wast:4678 |
| assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x05\x84\x80\x80\x80\x00\x01\x01\x01\x01\x07\x8a\x80\x80\x80\x00\x01\x06\x74\x65\x73\x74\x66\x6e\x00\x00\x0a\x9c\x80\x80\x80\x00\x01\x96\x80\x80\x80\x00\x00\x44\x00\x00\x00\x00\x00\x00\x24\x40\x43\x00\x00\xa0\x41\x41\x1e\xfc\x0a\x00\x00\x0b"); |
| |
| // memory_copy.wast:4685 |
| assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x05\x84\x80\x80\x80\x00\x01\x01\x01\x01\x07\x8a\x80\x80\x80\x00\x01\x06\x74\x65\x73\x74\x66\x6e\x00\x00\x0a\x9f\x80\x80\x80\x00\x01\x99\x80\x80\x80\x00\x00\x44\x00\x00\x00\x00\x00\x00\x24\x40\x43\x00\x00\xa0\x41\x43\x00\x00\xf0\x41\xfc\x0a\x00\x00\x0b"); |
| |
| // memory_copy.wast:4692 |
| assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x05\x84\x80\x80\x80\x00\x01\x01\x01\x01\x07\x8a\x80\x80\x80\x00\x01\x06\x74\x65\x73\x74\x66\x6e\x00\x00\x0a\x9c\x80\x80\x80\x00\x01\x96\x80\x80\x80\x00\x00\x44\x00\x00\x00\x00\x00\x00\x24\x40\x43\x00\x00\xa0\x41\x42\x1e\xfc\x0a\x00\x00\x0b"); |
| |
| // memory_copy.wast:4699 |
| assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x05\x84\x80\x80\x80\x00\x01\x01\x01\x01\x07\x8a\x80\x80\x80\x00\x01\x06\x74\x65\x73\x74\x66\x6e\x00\x00\x0a\xa3\x80\x80\x80\x00\x01\x9d\x80\x80\x80\x00\x00\x44\x00\x00\x00\x00\x00\x00\x24\x40\x43\x00\x00\xa0\x41\x44\x00\x00\x00\x00\x00\x00\x3e\x40\xfc\x0a\x00\x00\x0b"); |
| |
| // memory_copy.wast:4706 |
| assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x05\x84\x80\x80\x80\x00\x01\x01\x01\x01\x07\x8a\x80\x80\x80\x00\x01\x06\x74\x65\x73\x74\x66\x6e\x00\x00\x0a\x99\x80\x80\x80\x00\x01\x93\x80\x80\x80\x00\x00\x44\x00\x00\x00\x00\x00\x00\x24\x40\x42\x14\x41\x1e\xfc\x0a\x00\x00\x0b"); |
| |
| // memory_copy.wast:4713 |
| assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x05\x84\x80\x80\x80\x00\x01\x01\x01\x01\x07\x8a\x80\x80\x80\x00\x01\x06\x74\x65\x73\x74\x66\x6e\x00\x00\x0a\x9c\x80\x80\x80\x00\x01\x96\x80\x80\x80\x00\x00\x44\x00\x00\x00\x00\x00\x00\x24\x40\x42\x14\x43\x00\x00\xf0\x41\xfc\x0a\x00\x00\x0b"); |
| |
| // memory_copy.wast:4720 |
| assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x05\x84\x80\x80\x80\x00\x01\x01\x01\x01\x07\x8a\x80\x80\x80\x00\x01\x06\x74\x65\x73\x74\x66\x6e\x00\x00\x0a\x99\x80\x80\x80\x00\x01\x93\x80\x80\x80\x00\x00\x44\x00\x00\x00\x00\x00\x00\x24\x40\x42\x14\x42\x1e\xfc\x0a\x00\x00\x0b"); |
| |
| // memory_copy.wast:4727 |
| assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x05\x84\x80\x80\x80\x00\x01\x01\x01\x01\x07\x8a\x80\x80\x80\x00\x01\x06\x74\x65\x73\x74\x66\x6e\x00\x00\x0a\xa0\x80\x80\x80\x00\x01\x9a\x80\x80\x80\x00\x00\x44\x00\x00\x00\x00\x00\x00\x24\x40\x42\x14\x44\x00\x00\x00\x00\x00\x00\x3e\x40\xfc\x0a\x00\x00\x0b"); |
| |
| // memory_copy.wast:4734 |
| assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x05\x84\x80\x80\x80\x00\x01\x01\x01\x01\x07\x8a\x80\x80\x80\x00\x01\x06\x74\x65\x73\x74\x66\x6e\x00\x00\x0a\xa0\x80\x80\x80\x00\x01\x9a\x80\x80\x80\x00\x00\x44\x00\x00\x00\x00\x00\x00\x24\x40\x44\x00\x00\x00\x00\x00\x00\x34\x40\x41\x1e\xfc\x0a\x00\x00\x0b"); |
| |
| // memory_copy.wast:4741 |
| assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x05\x84\x80\x80\x80\x00\x01\x01\x01\x01\x07\x8a\x80\x80\x80\x00\x01\x06\x74\x65\x73\x74\x66\x6e\x00\x00\x0a\xa3\x80\x80\x80\x00\x01\x9d\x80\x80\x80\x00\x00\x44\x00\x00\x00\x00\x00\x00\x24\x40\x44\x00\x00\x00\x00\x00\x00\x34\x40\x43\x00\x00\xf0\x41\xfc\x0a\x00\x00\x0b"); |
| |
| // memory_copy.wast:4748 |
| assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x05\x84\x80\x80\x80\x00\x01\x01\x01\x01\x07\x8a\x80\x80\x80\x00\x01\x06\x74\x65\x73\x74\x66\x6e\x00\x00\x0a\xa0\x80\x80\x80\x00\x01\x9a\x80\x80\x80\x00\x00\x44\x00\x00\x00\x00\x00\x00\x24\x40\x44\x00\x00\x00\x00\x00\x00\x34\x40\x42\x1e\xfc\x0a\x00\x00\x0b"); |
| |
| // memory_copy.wast:4755 |
| assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x05\x84\x80\x80\x80\x00\x01\x01\x01\x01\x07\x8a\x80\x80\x80\x00\x01\x06\x74\x65\x73\x74\x66\x6e\x00\x00\x0a\xa7\x80\x80\x80\x00\x01\xa1\x80\x80\x80\x00\x00\x44\x00\x00\x00\x00\x00\x00\x24\x40\x44\x00\x00\x00\x00\x00\x00\x34\x40\x44\x00\x00\x00\x00\x00\x00\x3e\x40\xfc\x0a\x00\x00\x0b"); |
| |
| // memory_copy.wast:4763 |
| let $20 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8b\x80\x80\x80\x00\x02\x60\x00\x00\x60\x03\x7f\x7f\x7f\x01\x7f\x03\x83\x80\x80\x80\x00\x02\x00\x01\x05\x84\x80\x80\x80\x00\x01\x01\x01\x01\x07\x95\x80\x80\x80\x00\x02\x04\x74\x65\x73\x74\x00\x00\x0a\x63\x68\x65\x63\x6b\x52\x61\x6e\x67\x65\x00\x01\x0a\xc8\x80\x80\x80\x00\x02\x96\x80\x80\x80\x00\x00\x41\x0a\x41\xd5\x00\x41\x0a\xfc\x0b\x00\x41\x09\x41\x0a\x41\x05\xfc\x0a\x00\x00\x0b\xa7\x80\x80\x80\x00\x00\x03\x40\x20\x00\x20\x01\x46\x04\x40\x41\x7f\x0f\x0b\x20\x00\x2d\x00\x00\x20\x02\x46\x04\x40\x20\x00\x41\x01\x6a\x21\x00\x0c\x01\x0b\x0b\x20\x00\x0f\x0b"); |
| |
| // memory_copy.wast:4780 |
| run(() => call($20, "test", [])); |
| |
| // memory_copy.wast:4782 |
| assert_return(() => call($20, "checkRange", [0, 9, 0]), -1); |
| |
| // memory_copy.wast:4784 |
| assert_return(() => call($20, "checkRange", [9, 20, 85]), -1); |
| |
| // memory_copy.wast:4786 |
| assert_return(() => call($20, "checkRange", [20, 65_536, 0]), -1); |
| |
| // memory_copy.wast:4789 |
| let $21 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8b\x80\x80\x80\x00\x02\x60\x00\x00\x60\x03\x7f\x7f\x7f\x01\x7f\x03\x83\x80\x80\x80\x00\x02\x00\x01\x05\x84\x80\x80\x80\x00\x01\x01\x01\x01\x07\x95\x80\x80\x80\x00\x02\x04\x74\x65\x73\x74\x00\x00\x0a\x63\x68\x65\x63\x6b\x52\x61\x6e\x67\x65\x00\x01\x0a\xc8\x80\x80\x80\x00\x02\x96\x80\x80\x80\x00\x00\x41\x0a\x41\xd5\x00\x41\x0a\xfc\x0b\x00\x41\x10\x41\x0f\x41\x05\xfc\x0a\x00\x00\x0b\xa7\x80\x80\x80\x00\x00\x03\x40\x20\x00\x20\x01\x46\x04\x40\x41\x7f\x0f\x0b\x20\x00\x2d\x00\x00\x20\x02\x46\x04\x40\x20\x00\x41\x01\x6a\x21\x00\x0c\x01\x0b\x0b\x20\x00\x0f\x0b"); |
| |
| // memory_copy.wast:4806 |
| run(() => call($21, "test", [])); |
| |
| // memory_copy.wast:4808 |
| assert_return(() => call($21, "checkRange", [0, 10, 0]), -1); |
| |
| // memory_copy.wast:4810 |
| assert_return(() => call($21, "checkRange", [10, 21, 85]), -1); |
| |
| // memory_copy.wast:4812 |
| assert_return(() => call($21, "checkRange", [21, 65_536, 0]), -1); |
| |
| // memory_copy.wast:4815 |
| let $22 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x05\x84\x80\x80\x80\x00\x01\x01\x01\x01\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x00\x0a\x97\x80\x80\x80\x00\x01\x91\x80\x80\x80\x00\x00\x41\x80\xfe\x03\x41\x80\x80\x02\x41\x81\x02\xfc\x0a\x00\x00\x0b"); |
| |
| // memory_copy.wast:4819 |
| assert_trap(() => call($22, "test", [])); |
| |
| // memory_copy.wast:4821 |
| let $23 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x05\x84\x80\x80\x80\x00\x01\x01\x01\x01\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x00\x0a\x96\x80\x80\x80\x00\x01\x90\x80\x80\x80\x00\x00\x41\x80\x7e\x41\x80\x80\x01\x41\x81\x02\xfc\x0a\x00\x00\x0b"); |
| |
| // memory_copy.wast:4825 |
| assert_trap(() => call($23, "test", [])); |
| |
| // memory_copy.wast:4827 |
| let $24 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x05\x84\x80\x80\x80\x00\x01\x01\x01\x01\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x00\x0a\x97\x80\x80\x80\x00\x01\x91\x80\x80\x80\x00\x00\x41\x80\x80\x02\x41\x80\xfe\x03\x41\x81\x02\xfc\x0a\x00\x00\x0b"); |
| |
| // memory_copy.wast:4831 |
| assert_trap(() => call($24, "test", [])); |
| |
| // memory_copy.wast:4833 |
| let $25 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x05\x84\x80\x80\x80\x00\x01\x01\x01\x01\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x00\x0a\x96\x80\x80\x80\x00\x01\x90\x80\x80\x80\x00\x00\x41\x80\x80\x01\x41\x80\x7e\x41\x81\x02\xfc\x0a\x00\x00\x0b"); |
| |
| // memory_copy.wast:4837 |
| assert_trap(() => call($25, "test", [])); |
| |
| // memory_copy.wast:4839 |
| let $26 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8b\x80\x80\x80\x00\x02\x60\x00\x00\x60\x03\x7f\x7f\x7f\x01\x7f\x03\x83\x80\x80\x80\x00\x02\x00\x01\x05\x84\x80\x80\x80\x00\x01\x01\x01\x01\x07\x95\x80\x80\x80\x00\x02\x04\x74\x65\x73\x74\x00\x00\x0a\x63\x68\x65\x63\x6b\x52\x61\x6e\x67\x65\x00\x01\x0a\xdc\x80\x80\x80\x00\x02\xaa\x80\x80\x80\x00\x00\x41\x00\x41\xd5\x00\x41\x80\x80\x02\xfc\x0b\x00\x41\x80\x80\x02\x41\xaa\x01\x41\x80\x80\x02\xfc\x0b\x00\x41\x80\xa0\x02\x41\x80\xe0\x01\x41\x00\xfc\x0a\x00\x00\x0b\xa7\x80\x80\x80\x00\x00\x03\x40\x20\x00\x20\x01\x46\x04\x40\x41\x7f\x0f\x0b\x20\x00\x2d\x00\x00\x20\x02\x46\x04\x40\x20\x00\x41\x01\x6a\x21\x00\x0c\x01\x0b\x0b\x20\x00\x0f\x0b"); |
| |
| // memory_copy.wast:4857 |
| run(() => call($26, "test", [])); |
| |
| // memory_copy.wast:4859 |
| assert_return(() => call($26, "checkRange", [0, 32_768, 85]), -1); |
| |
| // memory_copy.wast:4861 |
| assert_return(() => call($26, "checkRange", [32_768, 65_536, 170]), -1); |
| |
| // memory_copy.wast:4863 |
| let $27 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x05\x84\x80\x80\x80\x00\x01\x01\x01\x01\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x00\x0a\x96\x80\x80\x80\x00\x01\x90\x80\x80\x80\x00\x00\x41\x80\x80\x04\x41\x80\xe0\x01\x41\x00\xfc\x0a\x00\x00\x0b"); |
| |
| // memory_copy.wast:4867 |
| run(() => call($27, "test", [])); |
| |
| // memory_copy.wast:4869 |
| let $28 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x05\x84\x80\x80\x80\x00\x01\x01\x01\x01\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x00\x0a\x96\x80\x80\x80\x00\x01\x90\x80\x80\x80\x00\x00\x41\x80\x80\x08\x41\x80\xe0\x01\x41\x00\xfc\x0a\x00\x00\x0b"); |
| |
| // memory_copy.wast:4873 |
| assert_trap(() => call($28, "test", [])); |
| |
| // memory_copy.wast:4875 |
| let $29 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x05\x84\x80\x80\x80\x00\x01\x01\x01\x01\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x00\x0a\x96\x80\x80\x80\x00\x01\x90\x80\x80\x80\x00\x00\x41\x80\xa0\x02\x41\x80\x80\x04\x41\x00\xfc\x0a\x00\x00\x0b"); |
| |
| // memory_copy.wast:4879 |
| run(() => call($29, "test", [])); |
| |
| // memory_copy.wast:4881 |
| let $30 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x05\x84\x80\x80\x80\x00\x01\x01\x01\x01\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x00\x0a\x96\x80\x80\x80\x00\x01\x90\x80\x80\x80\x00\x00\x41\x80\xa0\x02\x41\x80\x80\x08\x41\x00\xfc\x0a\x00\x00\x0b"); |
| |
| // memory_copy.wast:4885 |
| assert_trap(() => call($30, "test", [])); |
| |
| // memory_copy.wast:4887 |
| let $31 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x05\x84\x80\x80\x80\x00\x01\x01\x01\x01\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x00\x0a\x96\x80\x80\x80\x00\x01\x90\x80\x80\x80\x00\x00\x41\x80\x80\x04\x41\x80\x80\x04\x41\x00\xfc\x0a\x00\x00\x0b"); |
| |
| // memory_copy.wast:4891 |
| run(() => call($31, "test", [])); |
| |
| // memory_copy.wast:4893 |
| let $32 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x05\x84\x80\x80\x80\x00\x01\x01\x01\x01\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x00\x0a\x96\x80\x80\x80\x00\x01\x90\x80\x80\x80\x00\x00\x41\x80\x80\x08\x41\x80\x80\x08\x41\x00\xfc\x0a\x00\x00\x0b"); |
| |
| // memory_copy.wast:4897 |
| assert_trap(() => call($32, "test", [])); |
| |
| // memory_copy.wast:4899 |
| let $33 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8b\x80\x80\x80\x00\x02\x60\x00\x00\x60\x03\x7f\x7f\x7f\x01\x7f\x03\x83\x80\x80\x80\x00\x02\x00\x01\x05\x84\x80\x80\x80\x00\x01\x01\x01\x01\x07\x95\x80\x80\x80\x00\x02\x04\x74\x65\x73\x74\x00\x00\x0a\x63\x68\x65\x63\x6b\x52\x61\x6e\x67\x65\x00\x01\x0a\xbe\x95\x80\x80\x00\x02\x8c\x95\x80\x80\x00\x00\x41\xe7\x8a\x01\x41\x01\x41\xc0\x0a\xfc\x0b\x00\x41\xe9\xb0\x02\x41\x02\x41\x9f\x08\xfc\x0b\x00\x41\xd1\xb8\x03\x41\x03\x41\xdc\x07\xfc\x0b\x00\x41\xca\xa8\x02\x41\x04\x41\xc2\x02\xfc\x0b\x00\x41\xa9\x3e\x41\x05\x41\xca\x0f\xfc\x0b\x00\x41\xba\xb1\x01\x41\x06\x41\xdc\x17\xfc\x0b\x00\x41\xf2\x83\x01\x41\x07\x41\xc4\x12\xfc\x0b\x00\x41\xe3\xd3\x02\x41\x08\x41\xc3\x06\xfc\x0b\x00\x41\xfc\x00\x41\x09\x41\xf1\x0a\xfc\x0b\x00\x41\xd4\x10\x41\x0a\x41\xc6\x15\xfc\x0b\x00\x41\x9b\xc6\x00\x41\x0b\x41\x9a\x18\xfc\x0b\x00\x41\xe7\x9b\x03\x41\x0c\x41\xe5\x05\xfc\x0b\x00\x41\xf6\x1e\x41\x0d\x41\x87\x16\xfc\x0b\x00\x41\xb3\x84\x03\x41\x0e\x41\x80\x0a\xfc\x0b\x00\x41\xc9\x89\x03\x41\x0f\x41\xba\x0b\xfc\x0b\x00\x41\x8d\xa0\x01\x41\x10\x41\xd6\x18\xfc\x0b\x00\x41\xb1\xf4\x02\x41\x11\x41\xa0\x04\xfc\x0b\x00\x41\xa3\xe1\x00\x41\x12\x41\xed\x14\xfc\x0b\x00\x41\xa5\xc2\x01\x41\x13\x41\xdb\x14\xfc\x0b\x00\x41\x85\xe2\x02\x41\x14\x41\xa2\x0c\xfc\x0b\x00\x41\xd8\xd0\x02\x41\x15\x41\x9b\x0d\xfc\x0b\x00\x41\xde\x88\x02\x41\x16\x41\x86\x05\xfc\x0b\x00\x41\xab\xfb\x02\x41\x17\x41\xc2\x0e\xfc\x0b\x00\x41\xcd\xa1\x03\x41\x18\x41\xe1\x14\xfc\x0b\x00\x41\x9b\xed\x01\x41\x19\x41\xd5\x07\xfc\x0b\x00\x41\xd4\xc8\x00\x41\x1a\x41\x8f\x0e\xfc\x0b\x00\x41\x8e\x88\x03\x41\x1b\x41\xe7\x03\xfc\x0b\x00\x41\xa1\xea\x03\x41\x1c\x41\x92\x04\xfc\x0b\x00\x41\xdc\x9b\x02\x41\x1d\x41\xaf\x07\xfc\x0b\x00\x41\xf0\x34\x41\x1e\x41\xfd\x02\xfc\x0b\x00\x41\xbe\x90\x03\x41\x1f\x41\x91\x18\xfc\x0b\x00\x41\xc1\x84\x03\x41\x20\x41\x92\x05\xfc\x0b\x00\x41\xfc\xdb\x02\x41\x21\x41\xa6\x0d\xfc\x0b\x00\x41\xbe\x84\x02\x41\x22\x41\xc4\x08\xfc\x0b\x00\x41\xfe\x8c\x03\x41\x23\x41\x82\x0b\xfc\x0b\x00\x41\xea\xf3\x02\x41\x24\x41\x9c\x11\xfc\x0b\x00\x41\xeb\xa6\x03\x41\x25\x41\xda\x12\xfc\x0b\x00\x41\x8f\xaf\x03\x41\x26\x41\xfa\x01\xfc\x0b\x00\x41\xdc\xb0\x01\x41\x27\x41\xb1\x10\xfc\x0b\x00\x41\xec\x85\x01\x41\x28\x41\xc0\x19\xfc\x0b\x00\x41\xbb\xa8\x03\x41\x29\x41\xe3\x19\xfc\x0b\x00\x41\xb2\xb4\x02\x41\x2a\x41\xec\x15\xfc\x0b\x00\x41\xbc\x9a\x02\x41\x2b\x41\x96\x10\xfc\x0b\x00\x41\xec\x93\x02\x41\x2c\x41\xcb\x15\xfc\x0b\x00\x41\xdb\xff\x01\x41\x2d\x41\xb8\x02\xfc\x0b\x00\x41\x82\xf2\x03\x41\x2e\x41\xc0\x01\xfc\x0b\x00\x41\xfe\xf1\x01\x41\x2f\x41\xd4\x04\xfc\x0b\x00\x41\xfb\x81\x01\x41\x30\x41\xf5\x03\xfc\x0b\x00\x41\xaa\xbd\x03\x41\x31\x41\xae\x05\xfc\x0b\x00\x41\xfb\x8b\x02\x41\x32\x41\x81\x03\xfc\x0b\x00\x41\xd1\xdb\x03\x41\x33\x41\x87\x07\xfc\x0b\x00\x41\x85\xe0\x03\x41\x34\x41\xd6\x12\xfc\x0b\x00\x41\xfc\xee\x02\x41\x35\x41\xa1\x0b\xfc\x0b\x00\x41\xf5\xca\x01\x41\x36\x41\xda\x18\xfc\x0b\x00\x41\xbe\x2b\x41\x37\x41\xd7\x10\xfc\x0b\x00\x41\x89\x99\x02\x41\x38\x41\x87\x04\xfc\x0b\x00\x41\xdc\xde\x02\x41\x39\x41\xd0\x19\xfc\x0b\x00\x41\xa8\xed\x02\x41\x3a\x41\x8e\x0d\xfc\x0b\x00\x41\x8f\xec\x02\x41\x3b\x41\xe0\x18\xfc\x0b\x00\x41\xb1\xaf\x01\x41\x3c\x41\xa1\x0b\xfc\x0b\x00\x41\xf1\xc9\x03\x41\x3d\x41\x97\x05\xfc\x0b\x00\x41\x85\xfc\x01\x41\x3e\x41\x87\x0d\xfc\x0b\x00\x41\xf7\x17\x41\x3f\x41\xd1\x05\xfc\x0b\x00\x41\xe9\x89\x02\x41\xc0\x00\x41\xd4\x00\xfc\x0b\x00\x41\xba\x84\x02\x41\xc1\x00\x41\xed\x0f\xfc\x0b\x00\x41\xca\x9f\x02\x41\xc2\x00\x41\x1d\xfc\x0b\x00\x41\xcb\x95\x01\x41\xc3\x00\x41\xda\x17\xfc\x0b\x00\x41\xc8\xe2\x00\x41\xc4\x00\x41\x93\x08\xfc\x0b\x00\x41\xe4\x8e\x01\x41\xc5\x00\x41\xfc\x19\xfc\x0b\x00\x41\x9f\x24\x41\xc6\x00\x41\xc3\x08\xfc\x0b\x00\x41\x9e\xfe\x00\x41\xc7\x00\x41\xcd\x0f\xfc\x0b\x00\x41\x9c\x8e\x01\x41\xc8\x00\x41\xd3\x11\xfc\x0b\x00\x41\xe4\x8a\x03\x41\xc9\x00\x41\xf5\x18\xfc\x0b\x00\x41\x94\xd6\x00\x41\xca\x00\x41\xb0\x0f\xfc\x0b\x00\x41\xda\xfc\x00\x41\xcb\x00\x41\xaf\x0b\xfc\x0b\x00\x41\xde\xe2\x02\x41\xcc\x00\x41\x99\x09\xfc\x0b\x00\x41\xf9\xa6\x03\x41\xcd\x00\x41\xa0\x0c\xfc\x0b\x00\x41\xbb\x82\x02\x41\xce\x00\x41\xea\x0c\xfc\x0b\x00\x41\xe4\xdc\x03\x41\xcf\x00\x41\xd4\x19\xfc\x0b\x00\x41\x91\x94\x03\x41\xd0\x00\x41\xdf\x01\xfc\x0b\x00\x41\x89\x22\x41\xd1\x00\x41\xfb\x10\xfc\x0b\x00\x41\xaa\xc1\x03\x41\xd2\x00\x41\xaa\x0a\xfc\x0b\x00\x41\xac\xb3\x03\x41\xd3\x00\x41\xd8\x14\xfc\x0b\x00\x41\x9b\xbc\x01\x41\xd4\x00\x41\x95\x08\xfc\x0b\x00\x41\xaf\xd1\x02\x41\xd5\x00\x41\x99\x18\xfc\x0b\x00\x41\xb3\xfc\x01\x41\xd6\x00\x41\xec\x15\xfc\x0b\x00\x41\xe3\x1d\x41\xd7\x00\x41\xda\x0f\xfc\x0b\x00\x41\xc8\xac\x03\x41\xd8\x00\x41\x00\xfc\x0b\x00\x41\x95\x86\x03\x41\xd9\x00\x41\x95\x10\xfc\x0b\x00\x41\xbb\x9f\x01\x41\xda\x00\x41\xd0\x16\xfc\x0b\x00\x41\xa2\x88\x02\x41\xdb\x00\x41\xc0\x01\xfc\x0b\x00\x41\xba\xc9\x00\x41\xdc\x00\x41\x93\x11\xfc\x0b\x00\x41\xfd\xe0\x00\x41\xdd\x00\x41\x18\xfc\x0b\x00\x41\x8b\xee\x00\x41\xde\x00\x41\xc1\x04\xfc\x0b\x00\x41\x9a\xd8\x02\x41\xdf\x00\x41\xa9\x10\xfc\x0b\x00\x41\xff\x9e\x02\x41\xe0\x00\x41\xec\x1a\xfc\x0b\x00\x41\xf8\xb5\x01\x41\xe1\x00\x41\xcd\x15\xfc\x0b\x00\x41\xf8\x31\x41\xe2\x00\x41\xbe\x06\xfc\x0b\x00\x41\x9b\x84\x02\x41\xe3\x00\x41\x92\x0f\xfc\x0b\x00\x41\xb5\xab\x01\x41\xe4\x00\x41\xbe\x15\xfc\x0b\x00\x41\xce\xce\x03\x41\xe8\xa7\x03\x41\xb2\x10\xfc\x0a\x00\x00\x41\xb2\xec\x03\x41\xb8\xb2\x02\x41\xe6\x01\xfc\x0a\x00\x00\x41\xf9\x94\x03\x41\xcd\xb8\x01\x41\xfc\x11\xfc\x0a\x00\x00\x41\xb4\x34\x41\xbc\xbb\x01\x41\xff\x04\xfc\x0a\x00\x00\x41\xce\x36\x41\xf7\x84\x02\x41\xc9\x08\xfc\x0a\x00\x00\x41\xcb\x97\x01\x41\xec\xd0\x00\x41\xfd\x18\xfc\x0a\x00\x00\x41\xac\xd5\x01\x41\x86\xa9\x03\x41\xe4\x00\xfc\x0a\x00\x00\x41\xd5\xd4\x01\x41\xa2\xd5\x02\x41\xb5\x0d\xfc\x0a\x00\x00\x41\xf0\xd8\x03\x41\xb5\xc3\x00\x41\xf7\x00\xfc\x0a\x00\x00\x41\xbb\x2e\x41\x84\x12\x41\x92\x05\xfc\x0a\x00\x00\x41\xb3\x25\x41\xaf\x93\x03\x41\xdd\x11\xfc\x0a\x00\x00\x41\xc9\xe2\x00\x41\xfd\x95\x01\x41\xc1\x06\xfc\x0a\x00\x00\x41\xce\xdc\x00\x41\xa9\xeb\x02\x41\xe4\x19\xfc\x0a\x00\x00\x41\xf0\xd8\x00\x41\xd4\xdf\x02\x41\xe9\x11\xfc\x0a\x00\x00\x41\x8a\x8b\x02\x41\xa9\x34\x41\x8c\x14\xfc\x0a\x00\x00\x41\xc8\x26\x41\x9a\x0d\x41\xb0\x0a\xfc\x0a\x00\x00\x41\xbc\xed\x03\x41\xd5\x3b\x41\x86\x0d\xfc\x0a\x00\x00\x41\x98\xdc\x02\x41\xa8\x8f\x01\x41\x21\xfc\x0a\x00\x00\x41\x8e\xd7\x02\x41\xcc\xae\x01\x41\x93\x0b\xfc\x0a\x00\x00\x41\xad\xec\x02\x41\x9b\x85\x03\x41\x9a\x0b\xfc\x0a\x00\x00\x41\xc4\xf1\x03\x41\xb3\xc4\x00\x41\xc2\x06\xfc\x0a\x00\x00\x41\xcd\x85\x02\x41\xa3\x9d\x01\x41\xf5\x19\xfc\x0a\x00\x00\x41\xff\xbc\x02\x41\xad\xa8\x03\x41\x81\x19\xfc\x0a\x00\x00\x41\xd4\xc9\x01\x41\xf6\xce\x03\x41\x94\x13\xfc\x0a\x00\x00\x41\xde\x99\x01\x41\xb2\xbc\x03\x41\xda\x02\xfc\x0a\x00\x00\x41\xec\xfb\x00\x41\xca\x98\x02\x41\xfe\x12\xfc\x0a\x00\x00\x41\xb0\xdc\x00\x41\xf6\x95\x02\x41\xac\x02\xfc\x0a\x00\x00\x41\xa3\xd0\x03\x41\x85\xed\x00\x41\xd1\x18\xfc\x0a\x00\x00\x41\xfb\x8b\x02\x41\xb2\xd9\x03\x41\x81\x0a\xfc\x0a\x00\x00\x41\x84\xc6\x00\x41\xf4\xdf\x00\x41\xaf\x07\xfc\x0a\x00\x00\x41\x8b\x16\x41\xb9\xd1\x00\x41\xdf\x0e\xfc\x0a\x00\x00\x41\xba\xd1\x02\x41\x86\xd7\x02\x41\xe2\x05\xfc\x0a\x00\x00\x41\xbe\xec\x03\x41\x85\x94\x01\x41\xfa\x00\xfc\x0a\x00\x00\x41\xec\xbb\x01\x41\xd9\xdd\x02\x41\xdb\x0d\xfc\x0a\x00\x00\x41\xd0\xb0\x01\x41\xa3\xf3\x00\x41\xbe\x05\xfc\x0a\x00\x00\x41\x94\xd8\x00\x41\xd3\xcf\x01\x41\xa6\x0e\xfc\x0a\x00\x00\x41\xb4\xb4\x01\x41\xf7\x9f\x01\x41\xa8\x08\xfc\x0a\x00\x00\x41\xa0\xbf\x03\x41\xf2\xab\x03\x41\xc7\x14\xfc\x0a\x00\x00\x41\x94\xc7\x01\x41\x81\x08\x41\xa9\x18\xfc\x0a\x00\x00\x41\xb4\x83\x03\x41\xbc\xd9\x02\x41\xcf\x07\xfc\x0a\x00\x00\x41\xf8\xdc\x01\x41\xfa\xc5\x02\x41\xa0\x12\xfc\x0a\x00\x00\x41\xe9\xde\x03\x41\xe6\x01\x41\xb8\x16\xfc\x0a\x00\x00\x41\xd0\xaf\x01\x41\x9a\x9a\x03\x41\x95\x11\xfc\x0a\x00\x00\x41\xe9\xbc\x02\x41\xea\xca\x00\x41\xa6\x0f\xfc\x0a\x00\x00\x41\xcc\xe2\x01\x41\xfe\xa2\x01\x41\x8a\x11\xfc\x0a\x00\x00\x41\xa5\x9e\x03\x41\xb3\xd7\x02\x41\x8d\x08\xfc\x0a\x00\x00\x41\x84\xc7\x01\x41\xd3\x96\x02\x41\xf2\x0c\xfc\x0a\x00\x00\x41\x94\xc9\x03\x41\xfb\xe5\x02\x41\xc2\x0f\xfc\x0a\x00\x00\x41\x99\xab\x02\x41\x90\x2d\x41\xa3\x0f\xfc\x0a\x00\x00\x41\xd7\xde\x01\x41\xc4\xb0\x03\x41\xc0\x12\xfc\x0a\x00\x00\x41\x9b\xe9\x03\x41\xbc\x8d\x01\x41\xcc\x0a\xfc\x0a\x00\x00\x41\xe5\x87\x03\x41\xa5\xec\x00\x41\xfe\x02\xfc\x0a\x00\x00\x41\x88\x84\x01\x41\xf5\x9b\x02\x41\xec\x0e\xfc\x0a\x00\x00\x41\xe2\xf7\x02\x41\xde\xd8\x00\x41\xf7\x15\xfc\x0a\x00\x00\x41\xe0\xde\x01\x41\xaa\xbb\x02\x41\xc3\x02\xfc\x0a\x00\x00\x41\xb2\x95\x02\x41\xd0\xd9\x01\x41\x86\x0d\xfc\x0a\x00\x00\x41\xfa\xeb\x03\x41\xd4\xa0\x03\x41\xbd\x0a\xfc\x0a\x00\x00\x41\xb5\xee\x00\x41\xe8\xe9\x02\x41\x84\x05\xfc\x0a\x00\x00\x41\xe6\xe2\x01\x41\x82\x95\x01\x41\xf0\x03\xfc\x0a\x00\x00\x41\x98\xdf\x02\x41\xd9\xf3\x02\x41\xe0\x15\xfc\x0a\x00\x00\x41\x87\xb5\x02\x41\xf5\xdc\x02\x41\xc6\x0a\xfc\x0a\x00\x00\x41\xf0\xd0\x00\x41\xda\xe4\x01\x41\xc3\x0b\xfc\x0a\x00\x00\x41\xbf\xee\x02\x41\xe2\xe8\x02\x41\xbb\x0b\xfc\x0a\x00\x00\x41\xa9\x26\x41\xc4\xe0\x01\x41\xe7\x0e\xfc\x0a\x00\x00\x41\xfc\xa8\x02\x41\xa5\xbf\x03\x41\xd7\x0d\xfc\x0a\x00\x00\x41\xce\xce\x01\x41\xd7\xd4\x01\x41\xe7\x08\xfc\x0a\x00\x00\x41\xd3\xcb\x03\x41\xd1\xc0\x01\x41\xa7\x08\xfc\x0a\x00\x00\x41\xac\xdf\x03\x41\x86\xaf\x02\x41\xfe\x05\xfc\x0a\x00\x00\x41\x80\xd9\x02\x41\xec\x11\x41\xf0\x0b\xfc\x0a\x00\x00\x41\xe4\xff\x01\x41\x85\xf1\x02\x41\xc6\x17\xfc\x0a\x00\x00\x41\x8c\xd7\x00\x41\x8c\xa6\x01\x41\xf3\x07\xfc\x0a\x00\x00\x41\xf1\x3b\x41\xfc\xf6\x01\x41\xda\x17\xfc\x0a\x00\x00\x41\xfc\x8c\x01\x41\xbb\xe5\x00\x41\xf8\x19\xfc\x0a\x00\x00\x41\xda\xbf\x03\x41\xe1\xb4\x03\x41\xb4\x02\xfc\x0a\x00\x00\x41\xe3\xc0\x01\x41\xaf\x83\x01\x41\x83\x09\xfc\x0a\x00\x00\x41\xbc\x9b\x01\x41\x83\xcf\x00\x41\xd2\x05\xfc\x0a\x00\x00\x41\xe9\x16\x41\xaf\x2e\x41\xc2\x12\xfc\x0a\x00\x00\x41\xff\xfb\x01\x41\xaf\x87\x03\x41\xee\x16\xfc\x0a\x00\x00\x41\x96\xf6\x00\x41\x93\x87\x01\x41\xaf\x14\xfc\x0a\x00\x00\x41\x87\xe4\x02\x41\x9f\xde\x01\x41\xfd\x0f\xfc\x0a\x00\x00\x41\xed\xae\x03\x41\x91\x9a\x02\x41\xa4\x14\xfc\x0a\x00\x00\x41\xad\xde\x01\x41\x8d\xa7\x03\x41\x90\x09\xfc\x0a\x00\x00\x41\xcf\xf6\x02\x41\x89\xa1\x03\x41\xc1\x18\xfc\x0a\x00\x00\x41\xb6\xef\x01\x41\xe3\xe0\x02\x41\xd9\x14\xfc\x0a\x00\x00\x41\xc1\x27\x41\xc7\x21\x41\x34\xfc\x0a\x00\x00\x41\xa4\x34\x41\x83\xbd\x01\x41\xb9\x03\xfc\x0a\x00\x00\x41\xd8\x81\x02\x41\xed\xd3\x01\x41\xf5\x1a\xfc\x0a\x00\x00\x41\x92\xfe\x01\x41\xec\xcf\x03\x41\xe1\x15\xfc\x0a\x00\x00\x41\xb9\x8c\x02\x41\x82\xc6\x00\x41\xe6\x12\xfc\x0a\x00\x00\x41\xe5\x8b\x01\x41\x8a\xaa\x03\x41\xb5\x1a\xfc\x0a\x00\x00\x41\x9d\xb1\x01\x41\xf7\xd8\x02\x41\x88\x01\xfc\x0a\x00\x00\x41\xd1\xcd\x03\x41\xa5\x37\x41\x95\x08\xfc\x0a\x00\x00\x41\xc1\xcf\x02\x41\xf4\xad\x03\x41\xd5\x12\xfc\x0a\x00\x00\x41\x95\xdd\x02\x41\xaa\x9d\x01\x41\xed\x06\xfc\x0a\x00\x00\x41\xca\x9f\x02\x41\xec\xc4\x01\x41\xf7\x1a\xfc\x0a\x00\x00\x41\xae\xe5\x02\x41\x90\xf9\x01\x41\xd6\x06\xfc\x0a\x00\x00\x41\xac\xbd\x01\x41\xfa\xf8\x01\x41\xe1\x0a\xfc\x0a\x00\x00\x41\xf2\x87\x02\x41\xb4\x05\x41\xba\x0c\xfc\x0a\x00\x00\x41\xca\xd9\x03\x41\x99\x91\x01\x41\xab\x17\xfc\x0a\x00\x00\x41\xc2\x89\x03\x41\xb7\xc2\x02\x41\xfe\x0a\xfc\x0a\x00\x00\x0b\xa7\x80\x80\x80\x00\x00\x03\x40\x20\x00\x20\x01\x46\x04\x40\x41\x7f\x0f\x0b\x20\x00\x2d\x00\x00\x20\x02\x46\x04\x40\x20\x00\x41\x01\x6a\x21\x00\x0c\x01\x0b\x0b\x20\x00\x0f\x0b"); |
| |
| // memory_copy.wast:5115 |
| run(() => call($33, "test", [])); |
| |
| // memory_copy.wast:5117 |
| assert_return(() => call($33, "checkRange", [0, 124, 0]), -1); |
| |
| // memory_copy.wast:5119 |
| assert_return(() => call($33, "checkRange", [124, 1_517, 9]), -1); |
| |
| // memory_copy.wast:5121 |
| assert_return(() => call($33, "checkRange", [1_517, 2_132, 0]), -1); |
| |
| // memory_copy.wast:5123 |
| assert_return(() => call($33, "checkRange", [2_132, 2_827, 10]), -1); |
| |
| // memory_copy.wast:5125 |
| assert_return(() => call($33, "checkRange", [2_827, 2_921, 92]), -1); |
| |
| // memory_copy.wast:5127 |
| assert_return(() => call($33, "checkRange", [2_921, 3_538, 83]), -1); |
| |
| // memory_copy.wast:5129 |
| assert_return(() => call($33, "checkRange", [3_538, 3_786, 77]), -1); |
| |
| // memory_copy.wast:5131 |
| assert_return(() => call($33, "checkRange", [3_786, 4_042, 97]), -1); |
| |
| // memory_copy.wast:5133 |
| assert_return(() => call($33, "checkRange", [4_042, 4_651, 99]), -1); |
| |
| // memory_copy.wast:5135 |
| assert_return(() => call($33, "checkRange", [4_651, 5_057, 0]), -1); |
| |
| // memory_copy.wast:5137 |
| assert_return(() => call($33, "checkRange", [5_057, 5_109, 99]), -1); |
| |
| // memory_copy.wast:5139 |
| assert_return(() => call($33, "checkRange", [5_109, 5_291, 0]), -1); |
| |
| // memory_copy.wast:5141 |
| assert_return(() => call($33, "checkRange", [5_291, 5_524, 72]), -1); |
| |
| // memory_copy.wast:5143 |
| assert_return(() => call($33, "checkRange", [5_524, 5_691, 92]), -1); |
| |
| // memory_copy.wast:5145 |
| assert_return(() => call($33, "checkRange", [5_691, 6_552, 83]), -1); |
| |
| // memory_copy.wast:5147 |
| assert_return(() => call($33, "checkRange", [6_552, 7_133, 77]), -1); |
| |
| // memory_copy.wast:5149 |
| assert_return(() => call($33, "checkRange", [7_133, 7_665, 99]), -1); |
| |
| // memory_copy.wast:5151 |
| assert_return(() => call($33, "checkRange", [7_665, 8_314, 0]), -1); |
| |
| // memory_copy.wast:5153 |
| assert_return(() => call($33, "checkRange", [8_314, 8_360, 62]), -1); |
| |
| // memory_copy.wast:5155 |
| assert_return(() => call($33, "checkRange", [8_360, 8_793, 86]), -1); |
| |
| // memory_copy.wast:5157 |
| assert_return(() => call($33, "checkRange", [8_793, 8_979, 83]), -1); |
| |
| // memory_copy.wast:5159 |
| assert_return(() => call($33, "checkRange", [8_979, 9_373, 79]), -1); |
| |
| // memory_copy.wast:5161 |
| assert_return(() => call($33, "checkRange", [9_373, 9_518, 95]), -1); |
| |
| // memory_copy.wast:5163 |
| assert_return(() => call($33, "checkRange", [9_518, 9_934, 59]), -1); |
| |
| // memory_copy.wast:5165 |
| assert_return(() => call($33, "checkRange", [9_934, 10_087, 77]), -1); |
| |
| // memory_copy.wast:5167 |
| assert_return(() => call($33, "checkRange", [10_087, 10_206, 5]), -1); |
| |
| // memory_copy.wast:5169 |
| assert_return(() => call($33, "checkRange", [10_206, 10_230, 77]), -1); |
| |
| // memory_copy.wast:5171 |
| assert_return(() => call($33, "checkRange", [10_230, 10_249, 41]), -1); |
| |
| // memory_copy.wast:5173 |
| assert_return(() => call($33, "checkRange", [10_249, 11_148, 83]), -1); |
| |
| // memory_copy.wast:5175 |
| assert_return(() => call($33, "checkRange", [11_148, 11_356, 74]), -1); |
| |
| // memory_copy.wast:5177 |
| assert_return(() => call($33, "checkRange", [11_356, 11_380, 93]), -1); |
| |
| // memory_copy.wast:5179 |
| assert_return(() => call($33, "checkRange", [11_380, 11_939, 74]), -1); |
| |
| // memory_copy.wast:5181 |
| assert_return(() => call($33, "checkRange", [11_939, 12_159, 68]), -1); |
| |
| // memory_copy.wast:5183 |
| assert_return(() => call($33, "checkRange", [12_159, 12_575, 83]), -1); |
| |
| // memory_copy.wast:5185 |
| assert_return(() => call($33, "checkRange", [12_575, 12_969, 79]), -1); |
| |
| // memory_copy.wast:5187 |
| assert_return(() => call($33, "checkRange", [12_969, 13_114, 95]), -1); |
| |
| // memory_copy.wast:5189 |
| assert_return(() => call($33, "checkRange", [13_114, 14_133, 59]), -1); |
| |
| // memory_copy.wast:5191 |
| assert_return(() => call($33, "checkRange", [14_133, 14_404, 76]), -1); |
| |
| // memory_copy.wast:5193 |
| assert_return(() => call($33, "checkRange", [14_404, 14_428, 57]), -1); |
| |
| // memory_copy.wast:5195 |
| assert_return(() => call($33, "checkRange", [14_428, 14_458, 59]), -1); |
| |
| // memory_copy.wast:5197 |
| assert_return(() => call($33, "checkRange", [14_458, 14_580, 32]), -1); |
| |
| // memory_copy.wast:5199 |
| assert_return(() => call($33, "checkRange", [14_580, 14_777, 89]), -1); |
| |
| // memory_copy.wast:5201 |
| assert_return(() => call($33, "checkRange", [14_777, 15_124, 59]), -1); |
| |
| // memory_copy.wast:5203 |
| assert_return(() => call($33, "checkRange", [15_124, 15_126, 36]), -1); |
| |
| // memory_copy.wast:5205 |
| assert_return(() => call($33, "checkRange", [15_126, 15_192, 100]), -1); |
| |
| // memory_copy.wast:5207 |
| assert_return(() => call($33, "checkRange", [15_192, 15_871, 96]), -1); |
| |
| // memory_copy.wast:5209 |
| assert_return(() => call($33, "checkRange", [15_871, 15_998, 95]), -1); |
| |
| // memory_copy.wast:5211 |
| assert_return(() => call($33, "checkRange", [15_998, 17_017, 59]), -1); |
| |
| // memory_copy.wast:5213 |
| assert_return(() => call($33, "checkRange", [17_017, 17_288, 76]), -1); |
| |
| // memory_copy.wast:5215 |
| assert_return(() => call($33, "checkRange", [17_288, 17_312, 57]), -1); |
| |
| // memory_copy.wast:5217 |
| assert_return(() => call($33, "checkRange", [17_312, 17_342, 59]), -1); |
| |
| // memory_copy.wast:5219 |
| assert_return(() => call($33, "checkRange", [17_342, 17_464, 32]), -1); |
| |
| // memory_copy.wast:5221 |
| assert_return(() => call($33, "checkRange", [17_464, 17_661, 89]), -1); |
| |
| // memory_copy.wast:5223 |
| assert_return(() => call($33, "checkRange", [17_661, 17_727, 59]), -1); |
| |
| // memory_copy.wast:5225 |
| assert_return(() => call($33, "checkRange", [17_727, 17_733, 5]), -1); |
| |
| // memory_copy.wast:5227 |
| assert_return(() => call($33, "checkRange", [17_733, 17_893, 96]), -1); |
| |
| // memory_copy.wast:5229 |
| assert_return(() => call($33, "checkRange", [17_893, 18_553, 77]), -1); |
| |
| // memory_copy.wast:5231 |
| assert_return(() => call($33, "checkRange", [18_553, 18_744, 42]), -1); |
| |
| // memory_copy.wast:5233 |
| assert_return(() => call($33, "checkRange", [18_744, 18_801, 76]), -1); |
| |
| // memory_copy.wast:5235 |
| assert_return(() => call($33, "checkRange", [18_801, 18_825, 57]), -1); |
| |
| // memory_copy.wast:5237 |
| assert_return(() => call($33, "checkRange", [18_825, 18_876, 59]), -1); |
| |
| // memory_copy.wast:5239 |
| assert_return(() => call($33, "checkRange", [18_876, 18_885, 77]), -1); |
| |
| // memory_copy.wast:5241 |
| assert_return(() => call($33, "checkRange", [18_885, 18_904, 41]), -1); |
| |
| // memory_copy.wast:5243 |
| assert_return(() => call($33, "checkRange", [18_904, 19_567, 83]), -1); |
| |
| // memory_copy.wast:5245 |
| assert_return(() => call($33, "checkRange", [19_567, 20_403, 96]), -1); |
| |
| // memory_copy.wast:5247 |
| assert_return(() => call($33, "checkRange", [20_403, 21_274, 77]), -1); |
| |
| // memory_copy.wast:5249 |
| assert_return(() => call($33, "checkRange", [21_274, 21_364, 100]), -1); |
| |
| // memory_copy.wast:5251 |
| assert_return(() => call($33, "checkRange", [21_364, 21_468, 74]), -1); |
| |
| // memory_copy.wast:5253 |
| assert_return(() => call($33, "checkRange", [21_468, 21_492, 93]), -1); |
| |
| // memory_copy.wast:5255 |
| assert_return(() => call($33, "checkRange", [21_492, 22_051, 74]), -1); |
| |
| // memory_copy.wast:5257 |
| assert_return(() => call($33, "checkRange", [22_051, 22_480, 68]), -1); |
| |
| // memory_copy.wast:5259 |
| assert_return(() => call($33, "checkRange", [22_480, 22_685, 100]), -1); |
| |
| // memory_copy.wast:5261 |
| assert_return(() => call($33, "checkRange", [22_685, 22_694, 68]), -1); |
| |
| // memory_copy.wast:5263 |
| assert_return(() => call($33, "checkRange", [22_694, 22_821, 10]), -1); |
| |
| // memory_copy.wast:5265 |
| assert_return(() => call($33, "checkRange", [22_821, 22_869, 100]), -1); |
| |
| // memory_copy.wast:5267 |
| assert_return(() => call($33, "checkRange", [22_869, 24_107, 97]), -1); |
| |
| // memory_copy.wast:5269 |
| assert_return(() => call($33, "checkRange", [24_107, 24_111, 37]), -1); |
| |
| // memory_copy.wast:5271 |
| assert_return(() => call($33, "checkRange", [24_111, 24_236, 77]), -1); |
| |
| // memory_copy.wast:5273 |
| assert_return(() => call($33, "checkRange", [24_236, 24_348, 72]), -1); |
| |
| // memory_copy.wast:5275 |
| assert_return(() => call($33, "checkRange", [24_348, 24_515, 92]), -1); |
| |
| // memory_copy.wast:5277 |
| assert_return(() => call($33, "checkRange", [24_515, 24_900, 83]), -1); |
| |
| // memory_copy.wast:5279 |
| assert_return(() => call($33, "checkRange", [24_900, 25_136, 95]), -1); |
| |
| // memory_copy.wast:5281 |
| assert_return(() => call($33, "checkRange", [25_136, 25_182, 85]), -1); |
| |
| // memory_copy.wast:5283 |
| assert_return(() => call($33, "checkRange", [25_182, 25_426, 68]), -1); |
| |
| // memory_copy.wast:5285 |
| assert_return(() => call($33, "checkRange", [25_426, 25_613, 89]), -1); |
| |
| // memory_copy.wast:5287 |
| assert_return(() => call($33, "checkRange", [25_613, 25_830, 96]), -1); |
| |
| // memory_copy.wast:5289 |
| assert_return(() => call($33, "checkRange", [25_830, 26_446, 100]), -1); |
| |
| // memory_copy.wast:5291 |
| assert_return(() => call($33, "checkRange", [26_446, 26_517, 10]), -1); |
| |
| // memory_copy.wast:5293 |
| assert_return(() => call($33, "checkRange", [26_517, 27_468, 92]), -1); |
| |
| // memory_copy.wast:5295 |
| assert_return(() => call($33, "checkRange", [27_468, 27_503, 95]), -1); |
| |
| // memory_copy.wast:5297 |
| assert_return(() => call($33, "checkRange", [27_503, 27_573, 77]), -1); |
| |
| // memory_copy.wast:5299 |
| assert_return(() => call($33, "checkRange", [27_573, 28_245, 92]), -1); |
| |
| // memory_copy.wast:5301 |
| assert_return(() => call($33, "checkRange", [28_245, 28_280, 95]), -1); |
| |
| // memory_copy.wast:5303 |
| assert_return(() => call($33, "checkRange", [28_280, 29_502, 77]), -1); |
| |
| // memory_copy.wast:5305 |
| assert_return(() => call($33, "checkRange", [29_502, 29_629, 42]), -1); |
| |
| // memory_copy.wast:5307 |
| assert_return(() => call($33, "checkRange", [29_629, 30_387, 83]), -1); |
| |
| // memory_copy.wast:5309 |
| assert_return(() => call($33, "checkRange", [30_387, 30_646, 77]), -1); |
| |
| // memory_copy.wast:5311 |
| assert_return(() => call($33, "checkRange", [30_646, 31_066, 92]), -1); |
| |
| // memory_copy.wast:5313 |
| assert_return(() => call($33, "checkRange", [31_066, 31_131, 77]), -1); |
| |
| // memory_copy.wast:5315 |
| assert_return(() => call($33, "checkRange", [31_131, 31_322, 42]), -1); |
| |
| // memory_copy.wast:5317 |
| assert_return(() => call($33, "checkRange", [31_322, 31_379, 76]), -1); |
| |
| // memory_copy.wast:5319 |
| assert_return(() => call($33, "checkRange", [31_379, 31_403, 57]), -1); |
| |
| // memory_copy.wast:5321 |
| assert_return(() => call($33, "checkRange", [31_403, 31_454, 59]), -1); |
| |
| // memory_copy.wast:5323 |
| assert_return(() => call($33, "checkRange", [31_454, 31_463, 77]), -1); |
| |
| // memory_copy.wast:5325 |
| assert_return(() => call($33, "checkRange", [31_463, 31_482, 41]), -1); |
| |
| // memory_copy.wast:5327 |
| assert_return(() => call($33, "checkRange", [31_482, 31_649, 83]), -1); |
| |
| // memory_copy.wast:5329 |
| assert_return(() => call($33, "checkRange", [31_649, 31_978, 72]), -1); |
| |
| // memory_copy.wast:5331 |
| assert_return(() => call($33, "checkRange", [31_978, 32_145, 92]), -1); |
| |
| // memory_copy.wast:5333 |
| assert_return(() => call($33, "checkRange", [32_145, 32_530, 83]), -1); |
| |
| // memory_copy.wast:5335 |
| assert_return(() => call($33, "checkRange", [32_530, 32_766, 95]), -1); |
| |
| // memory_copy.wast:5337 |
| assert_return(() => call($33, "checkRange", [32_766, 32_812, 85]), -1); |
| |
| // memory_copy.wast:5339 |
| assert_return(() => call($33, "checkRange", [32_812, 33_056, 68]), -1); |
| |
| // memory_copy.wast:5341 |
| assert_return(() => call($33, "checkRange", [33_056, 33_660, 89]), -1); |
| |
| // memory_copy.wast:5343 |
| assert_return(() => call($33, "checkRange", [33_660, 33_752, 59]), -1); |
| |
| // memory_copy.wast:5345 |
| assert_return(() => call($33, "checkRange", [33_752, 33_775, 36]), -1); |
| |
| // memory_copy.wast:5347 |
| assert_return(() => call($33, "checkRange", [33_775, 33_778, 32]), -1); |
| |
| // memory_copy.wast:5349 |
| assert_return(() => call($33, "checkRange", [33_778, 34_603, 9]), -1); |
| |
| // memory_copy.wast:5351 |
| assert_return(() => call($33, "checkRange", [34_603, 35_218, 0]), -1); |
| |
| // memory_copy.wast:5353 |
| assert_return(() => call($33, "checkRange", [35_218, 35_372, 10]), -1); |
| |
| // memory_copy.wast:5355 |
| assert_return(() => call($33, "checkRange", [35_372, 35_486, 77]), -1); |
| |
| // memory_copy.wast:5357 |
| assert_return(() => call($33, "checkRange", [35_486, 35_605, 5]), -1); |
| |
| // memory_copy.wast:5359 |
| assert_return(() => call($33, "checkRange", [35_605, 35_629, 77]), -1); |
| |
| // memory_copy.wast:5361 |
| assert_return(() => call($33, "checkRange", [35_629, 35_648, 41]), -1); |
| |
| // memory_copy.wast:5363 |
| assert_return(() => call($33, "checkRange", [35_648, 36_547, 83]), -1); |
| |
| // memory_copy.wast:5365 |
| assert_return(() => call($33, "checkRange", [36_547, 36_755, 74]), -1); |
| |
| // memory_copy.wast:5367 |
| assert_return(() => call($33, "checkRange", [36_755, 36_767, 93]), -1); |
| |
| // memory_copy.wast:5369 |
| assert_return(() => call($33, "checkRange", [36_767, 36_810, 83]), -1); |
| |
| // memory_copy.wast:5371 |
| assert_return(() => call($33, "checkRange", [36_810, 36_839, 100]), -1); |
| |
| // memory_copy.wast:5373 |
| assert_return(() => call($33, "checkRange", [36_839, 37_444, 96]), -1); |
| |
| // memory_copy.wast:5375 |
| assert_return(() => call($33, "checkRange", [37_444, 38_060, 100]), -1); |
| |
| // memory_copy.wast:5377 |
| assert_return(() => call($33, "checkRange", [38_060, 38_131, 10]), -1); |
| |
| // memory_copy.wast:5379 |
| assert_return(() => call($33, "checkRange", [38_131, 39_082, 92]), -1); |
| |
| // memory_copy.wast:5381 |
| assert_return(() => call($33, "checkRange", [39_082, 39_117, 95]), -1); |
| |
| // memory_copy.wast:5383 |
| assert_return(() => call($33, "checkRange", [39_117, 39_187, 77]), -1); |
| |
| // memory_copy.wast:5385 |
| assert_return(() => call($33, "checkRange", [39_187, 39_859, 92]), -1); |
| |
| // memory_copy.wast:5387 |
| assert_return(() => call($33, "checkRange", [39_859, 39_894, 95]), -1); |
| |
| // memory_copy.wast:5389 |
| assert_return(() => call($33, "checkRange", [39_894, 40_257, 77]), -1); |
| |
| // memory_copy.wast:5391 |
| assert_return(() => call($33, "checkRange", [40_257, 40_344, 89]), -1); |
| |
| // memory_copy.wast:5393 |
| assert_return(() => call($33, "checkRange", [40_344, 40_371, 59]), -1); |
| |
| // memory_copy.wast:5395 |
| assert_return(() => call($33, "checkRange", [40_371, 40_804, 77]), -1); |
| |
| // memory_copy.wast:5397 |
| assert_return(() => call($33, "checkRange", [40_804, 40_909, 5]), -1); |
| |
| // memory_copy.wast:5399 |
| assert_return(() => call($33, "checkRange", [40_909, 42_259, 92]), -1); |
| |
| // memory_copy.wast:5401 |
| assert_return(() => call($33, "checkRange", [42_259, 42_511, 77]), -1); |
| |
| // memory_copy.wast:5403 |
| assert_return(() => call($33, "checkRange", [42_511, 42_945, 83]), -1); |
| |
| // memory_copy.wast:5405 |
| assert_return(() => call($33, "checkRange", [42_945, 43_115, 77]), -1); |
| |
| // memory_copy.wast:5407 |
| assert_return(() => call($33, "checkRange", [43_115, 43_306, 42]), -1); |
| |
| // memory_copy.wast:5409 |
| assert_return(() => call($33, "checkRange", [43_306, 43_363, 76]), -1); |
| |
| // memory_copy.wast:5411 |
| assert_return(() => call($33, "checkRange", [43_363, 43_387, 57]), -1); |
| |
| // memory_copy.wast:5413 |
| assert_return(() => call($33, "checkRange", [43_387, 43_438, 59]), -1); |
| |
| // memory_copy.wast:5415 |
| assert_return(() => call($33, "checkRange", [43_438, 43_447, 77]), -1); |
| |
| // memory_copy.wast:5417 |
| assert_return(() => call($33, "checkRange", [43_447, 43_466, 41]), -1); |
| |
| // memory_copy.wast:5419 |
| assert_return(() => call($33, "checkRange", [43_466, 44_129, 83]), -1); |
| |
| // memory_copy.wast:5421 |
| assert_return(() => call($33, "checkRange", [44_129, 44_958, 96]), -1); |
| |
| // memory_copy.wast:5423 |
| assert_return(() => call($33, "checkRange", [44_958, 45_570, 77]), -1); |
| |
| // memory_copy.wast:5425 |
| assert_return(() => call($33, "checkRange", [45_570, 45_575, 92]), -1); |
| |
| // memory_copy.wast:5427 |
| assert_return(() => call($33, "checkRange", [45_575, 45_640, 77]), -1); |
| |
| // memory_copy.wast:5429 |
| assert_return(() => call($33, "checkRange", [45_640, 45_742, 42]), -1); |
| |
| // memory_copy.wast:5431 |
| assert_return(() => call($33, "checkRange", [45_742, 45_832, 72]), -1); |
| |
| // memory_copy.wast:5433 |
| assert_return(() => call($33, "checkRange", [45_832, 45_999, 92]), -1); |
| |
| // memory_copy.wast:5435 |
| assert_return(() => call($33, "checkRange", [45_999, 46_384, 83]), -1); |
| |
| // memory_copy.wast:5437 |
| assert_return(() => call($33, "checkRange", [46_384, 46_596, 95]), -1); |
| |
| // memory_copy.wast:5439 |
| assert_return(() => call($33, "checkRange", [46_596, 46_654, 92]), -1); |
| |
| // memory_copy.wast:5441 |
| assert_return(() => call($33, "checkRange", [46_654, 47_515, 83]), -1); |
| |
| // memory_copy.wast:5443 |
| assert_return(() => call($33, "checkRange", [47_515, 47_620, 77]), -1); |
| |
| // memory_copy.wast:5445 |
| assert_return(() => call($33, "checkRange", [47_620, 47_817, 79]), -1); |
| |
| // memory_copy.wast:5447 |
| assert_return(() => call($33, "checkRange", [47_817, 47_951, 95]), -1); |
| |
| // memory_copy.wast:5449 |
| assert_return(() => call($33, "checkRange", [47_951, 48_632, 100]), -1); |
| |
| // memory_copy.wast:5451 |
| assert_return(() => call($33, "checkRange", [48_632, 48_699, 97]), -1); |
| |
| // memory_copy.wast:5453 |
| assert_return(() => call($33, "checkRange", [48_699, 48_703, 37]), -1); |
| |
| // memory_copy.wast:5455 |
| assert_return(() => call($33, "checkRange", [48_703, 49_764, 77]), -1); |
| |
| // memory_copy.wast:5457 |
| assert_return(() => call($33, "checkRange", [49_764, 49_955, 42]), -1); |
| |
| // memory_copy.wast:5459 |
| assert_return(() => call($33, "checkRange", [49_955, 50_012, 76]), -1); |
| |
| // memory_copy.wast:5461 |
| assert_return(() => call($33, "checkRange", [50_012, 50_036, 57]), -1); |
| |
| // memory_copy.wast:5463 |
| assert_return(() => call($33, "checkRange", [50_036, 50_087, 59]), -1); |
| |
| // memory_copy.wast:5465 |
| assert_return(() => call($33, "checkRange", [50_087, 50_096, 77]), -1); |
| |
| // memory_copy.wast:5467 |
| assert_return(() => call($33, "checkRange", [50_096, 50_115, 41]), -1); |
| |
| // memory_copy.wast:5469 |
| assert_return(() => call($33, "checkRange", [50_115, 50_370, 83]), -1); |
| |
| // memory_copy.wast:5471 |
| assert_return(() => call($33, "checkRange", [50_370, 51_358, 92]), -1); |
| |
| // memory_copy.wast:5473 |
| assert_return(() => call($33, "checkRange", [51_358, 51_610, 77]), -1); |
| |
| // memory_copy.wast:5475 |
| assert_return(() => call($33, "checkRange", [51_610, 51_776, 83]), -1); |
| |
| // memory_copy.wast:5477 |
| assert_return(() => call($33, "checkRange", [51_776, 51_833, 89]), -1); |
| |
| // memory_copy.wast:5479 |
| assert_return(() => call($33, "checkRange", [51_833, 52_895, 100]), -1); |
| |
| // memory_copy.wast:5481 |
| assert_return(() => call($33, "checkRange", [52_895, 53_029, 97]), -1); |
| |
| // memory_copy.wast:5483 |
| assert_return(() => call($33, "checkRange", [53_029, 53_244, 68]), -1); |
| |
| // memory_copy.wast:5485 |
| assert_return(() => call($33, "checkRange", [53_244, 54_066, 100]), -1); |
| |
| // memory_copy.wast:5487 |
| assert_return(() => call($33, "checkRange", [54_066, 54_133, 97]), -1); |
| |
| // memory_copy.wast:5489 |
| assert_return(() => call($33, "checkRange", [54_133, 54_137, 37]), -1); |
| |
| // memory_copy.wast:5491 |
| assert_return(() => call($33, "checkRange", [54_137, 55_198, 77]), -1); |
| |
| // memory_copy.wast:5493 |
| assert_return(() => call($33, "checkRange", [55_198, 55_389, 42]), -1); |
| |
| // memory_copy.wast:5495 |
| assert_return(() => call($33, "checkRange", [55_389, 55_446, 76]), -1); |
| |
| // memory_copy.wast:5497 |
| assert_return(() => call($33, "checkRange", [55_446, 55_470, 57]), -1); |
| |
| // memory_copy.wast:5499 |
| assert_return(() => call($33, "checkRange", [55_470, 55_521, 59]), -1); |
| |
| // memory_copy.wast:5501 |
| assert_return(() => call($33, "checkRange", [55_521, 55_530, 77]), -1); |
| |
| // memory_copy.wast:5503 |
| assert_return(() => call($33, "checkRange", [55_530, 55_549, 41]), -1); |
| |
| // memory_copy.wast:5505 |
| assert_return(() => call($33, "checkRange", [55_549, 56_212, 83]), -1); |
| |
| // memory_copy.wast:5507 |
| assert_return(() => call($33, "checkRange", [56_212, 57_048, 96]), -1); |
| |
| // memory_copy.wast:5509 |
| assert_return(() => call($33, "checkRange", [57_048, 58_183, 77]), -1); |
| |
| // memory_copy.wast:5511 |
| assert_return(() => call($33, "checkRange", [58_183, 58_202, 41]), -1); |
| |
| // memory_copy.wast:5513 |
| assert_return(() => call($33, "checkRange", [58_202, 58_516, 83]), -1); |
| |
| // memory_copy.wast:5515 |
| assert_return(() => call($33, "checkRange", [58_516, 58_835, 95]), -1); |
| |
| // memory_copy.wast:5517 |
| assert_return(() => call($33, "checkRange", [58_835, 58_855, 77]), -1); |
| |
| // memory_copy.wast:5519 |
| assert_return(() => call($33, "checkRange", [58_855, 59_089, 95]), -1); |
| |
| // memory_copy.wast:5521 |
| assert_return(() => call($33, "checkRange", [59_089, 59_145, 77]), -1); |
| |
| // memory_copy.wast:5523 |
| assert_return(() => call($33, "checkRange", [59_145, 59_677, 99]), -1); |
| |
| // memory_copy.wast:5525 |
| assert_return(() => call($33, "checkRange", [59_677, 60_134, 0]), -1); |
| |
| // memory_copy.wast:5527 |
| assert_return(() => call($33, "checkRange", [60_134, 60_502, 89]), -1); |
| |
| // memory_copy.wast:5529 |
| assert_return(() => call($33, "checkRange", [60_502, 60_594, 59]), -1); |
| |
| // memory_copy.wast:5531 |
| assert_return(() => call($33, "checkRange", [60_594, 60_617, 36]), -1); |
| |
| // memory_copy.wast:5533 |
| assert_return(() => call($33, "checkRange", [60_617, 60_618, 32]), -1); |
| |
| // memory_copy.wast:5535 |
| assert_return(() => call($33, "checkRange", [60_618, 60_777, 42]), -1); |
| |
| // memory_copy.wast:5537 |
| assert_return(() => call($33, "checkRange", [60_777, 60_834, 76]), -1); |
| |
| // memory_copy.wast:5539 |
| assert_return(() => call($33, "checkRange", [60_834, 60_858, 57]), -1); |
| |
| // memory_copy.wast:5541 |
| assert_return(() => call($33, "checkRange", [60_858, 60_909, 59]), -1); |
| |
| // memory_copy.wast:5543 |
| assert_return(() => call($33, "checkRange", [60_909, 60_918, 77]), -1); |
| |
| // memory_copy.wast:5545 |
| assert_return(() => call($33, "checkRange", [60_918, 60_937, 41]), -1); |
| |
| // memory_copy.wast:5547 |
| assert_return(() => call($33, "checkRange", [60_937, 61_600, 83]), -1); |
| |
| // memory_copy.wast:5549 |
| assert_return(() => call($33, "checkRange", [61_600, 62_436, 96]), -1); |
| |
| // memory_copy.wast:5551 |
| assert_return(() => call($33, "checkRange", [62_436, 63_307, 77]), -1); |
| |
| // memory_copy.wast:5553 |
| assert_return(() => call($33, "checkRange", [63_307, 63_397, 100]), -1); |
| |
| // memory_copy.wast:5555 |
| assert_return(() => call($33, "checkRange", [63_397, 63_501, 74]), -1); |
| |
| // memory_copy.wast:5557 |
| assert_return(() => call($33, "checkRange", [63_501, 63_525, 93]), -1); |
| |
| // memory_copy.wast:5559 |
| assert_return(() => call($33, "checkRange", [63_525, 63_605, 74]), -1); |
| |
| // memory_copy.wast:5561 |
| assert_return(() => call($33, "checkRange", [63_605, 63_704, 100]), -1); |
| |
| // memory_copy.wast:5563 |
| assert_return(() => call($33, "checkRange", [63_704, 63_771, 97]), -1); |
| |
| // memory_copy.wast:5565 |
| assert_return(() => call($33, "checkRange", [63_771, 63_775, 37]), -1); |
| |
| // memory_copy.wast:5567 |
| assert_return(() => call($33, "checkRange", [63_775, 64_311, 77]), -1); |
| |
| // memory_copy.wast:5569 |
| assert_return(() => call($33, "checkRange", [64_311, 64_331, 26]), -1); |
| |
| // memory_copy.wast:5571 |
| assert_return(() => call($33, "checkRange", [64_331, 64_518, 92]), -1); |
| |
| // memory_copy.wast:5573 |
| assert_return(() => call($33, "checkRange", [64_518, 64_827, 11]), -1); |
| |
| // memory_copy.wast:5575 |
| assert_return(() => call($33, "checkRange", [64_827, 64_834, 26]), -1); |
| |
| // memory_copy.wast:5577 |
| assert_return(() => call($33, "checkRange", [64_834, 65_536, 0]), -1); |
