jevhooks.js1 2 var bufferView; 3 var base64ReverseLookup = new Uint8Array(123/*'z'+1*/); 4 for (var i = 25; i >= 0; --i) { 5 base64ReverseLookup[48+i] = 52+i; // '0-9' 6 base64ReverseLookup[65+i] = i; // 'A-Z' 7 base64ReverseLookup[97+i] = 26+i; // 'a-z' 8 } 9 base64ReverseLookup[43] = 62; // '+' 10 base64ReverseLookup[47] = 63; // '/' 11 /** @noinline Inlining this function would mean expanding the base64 string 4x times in the source code, which Closure seems to be happy to do. */ 12 function base64DecodeToExistingUint8Array(uint8Array, offset, b64) { 13 var b1, b2, i = 0, j = offset, bLength = b64.length, end = offset + (bLength*3>>2) - (b64[bLength-2] == '=') - (b64[bLength-1] == '='); 14 for (; i < bLength; i += 4) { 15 b1 = base64ReverseLookup[b64.charCodeAt(i+1)]; 16 b2 = base64ReverseLookup[b64.charCodeAt(i+2)]; 17 uint8Array[j++] = base64ReverseLookup[b64.charCodeAt(i)] << 2 | b1 >> 4; 18 if (j < end) uint8Array[j++] = b1 << 4 | b2 >> 2; 19 if (j < end) uint8Array[j++] = b2 << 6 | base64ReverseLookup[b64.charCodeAt(i+3)]; 20 } 21 return uint8Array; 22 } 23function initActiveSegments(imports) { 24 base64DecodeToExistingUint8Array(bufferView, 1048576, "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"); 25 base64DecodeToExistingUint8Array(bufferView, 1052456, "AQAAAAc="); 26 base64DecodeToExistingUint8Array(bufferView, 1052472, "AQAAAAgAAAB1bGw="); 27 base64DecodeToExistingUint8Array(bufferView, 1052492, "AQAAAAk="); 28 base64DecodeToExistingUint8Array(bufferView, 1052508, "AQAAAAoAAAB9ImZhbHNldHJ1ZW51bGxbeyw6XS1vLXMtLXNldC0tcHJlLS1vdXRwdXQAADsKEAAeAAAANgAAAA0AAAB3aHkAOwoQAB4AAAA4AAAAFwAAAAJwbGFpbmx5IHJlYWQtb25seW9ubHkgQmFzaCBjb21tYW5kcyBhcmUganVkZ2VkAAsAAAAEAAAABAAAAAwAAABjYWxsZWQgYFJlc3VsdDo6dW53cmFwKClgIG9uIGFuIGBFcnJgIHZhbHVlcnVlYWxzZWludGVybmFsIGVycm9yOiBlbnRlcmVkIHVucmVhY2hhYmxlIGNvZGUAAK8HEABdAAAAogQAACIAAACvBxAAXQAAAJgEAAAmAAAAOwAAAHwAAAAmAAAAPAAAAD4AAAAkAAAAYAAAACgAAAApAAAAewAAAH0AAAAqAAAAPwAAAH4AAAAhAAAAIwAAAFwAAAAnAAAAIgAAAAoAAAANAAAAPS9zdHJ1Y3QgUm91dGVkAOAEEABrAAAAawQAACQAAAAAAQECAQIBAgIBAAICAgICAgICAgICAgICAgICAgICAgJ1dXV1dXV1dWJ0bnVmcnV1dXV1dXV1dXV1dXV1dXV1dQAAIg=="); 29 base64DecodeToExistingUint8Array(bufferView, 1053025, "XA=="); 30 base64DecodeToExistingUint8Array(bufferView, 1053189, "MDEyMzQ1Njc4OWFiY2RlZgAAALAJEABfAAAAAAIAABMAAACwCRAAXwAAAAkCAAA+AAAAsAkQAF8AAAAFAgAAMwAAALAJEABfAAAADwIAADoAAAA3BxAAdwAAAPAAAABNAAAAYXNzZXJ0aW9uIGZhaWxlZDogZWRnZS5oZWlnaHQgPT0gc2VsZi5ub2RlLmhlaWdodCAtIDEAAAA3BxAAdwAAAAMEAAAJAAAANwcQAHcAAAATBQAAJAAAALsGEAB7AAAAWAIAADAAAADgBBAAawAAAFYGAAAUAAAA4AQQAGsAAABFBgAAFAAAAGFzc2VydGlvbiBmYWlsZWQ6IHNyYy5sZW4oKSA9PSBkc3QubGVuKCk3BxAAdwAAAFQHAAAFAAAAbnVsbKICEAB8AAAA0QEAAC4AAAC7BhAAewAAABYCAAAvAAAAYXNzZXJ0aW9uIGZhaWxlZDogc2VsZi5pc19jaGFyX2JvdW5kYXJ5KG5ld19sZW4psAkQAF8AAACzAQAAGgAAALAJEABfAAAApgEAAEUAAACwCRAAXwAAAKsBAAA9AAAAuwYQAHsAAAChAAAAJAAAADcHEAB3AAAA0AQAACMAAABhc3NlcnRpb24gZmFpbGVkOiBpZHggPCBDQVBBQ0lUWTcHEAB3AAAAngIAAAkAAABhc3NlcnRpb24gZmFpbGVkOiBlZGdlLmhlaWdodCA9PSBzZWxmLmhlaWdodCAtIDE3BxAAdwAAALYCAAAJAAAANwcQAHcAAAC6AgAACQAAALsGEAB7AAAAxgAAACc="); 31 base64DecodeToExistingUint8Array(bufferView, 1053798, "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"); 32 base64DecodeToExistingUint8Array(bufferView, 1058032, "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"); 33 base64DecodeToExistingUint8Array(bufferView, 1059920, "AQAAADQAAABhIGZvcm1hdHRpbmcgdHJhaXQgaW1wbGVtZW50YXRpb24gcmV0dXJuZWQgYW4gZXJyb3Igd2hlbiB0aGUgdW5kZXJseWluZyBzdHJlYW0gZGlkIG5vdAAAggMQAEgAAACRAgAADgAAAEVycm9yAgICAgICAgICAgI="); 34 base64DecodeToExistingUint8Array(bufferView, 1060077, "AgIAAAAAAAI="); 35 base64DecodeToExistingUint8Array(bufferView, 1060132, "Ag=="); 36 base64DecodeToExistingUint8Array(bufferView, 1060170, "AQ=="); 37 base64DecodeToExistingUint8Array(bufferView, 1060197, "AQ=="); 38 base64DecodeToExistingUint8Array(bufferView, 1060294, "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"); 39 base64DecodeToExistingUint8Array(bufferView, 1064289, "AgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAwMDAwMDAwMDAwMDAwMDAwQEBAQE"); 40 base64DecodeToExistingUint8Array(bufferView, 1064351, "YXR0ZW1wdCB0byBkaXZpZGUgYnkgemVybz0AAAA+AAAAPwAAAGFzc2VydGlvbiBmYWlsZWQ6ICFidWYuaXNfZW1wdHkoKQAAAFgJEABXAAAAtwAAAAUAAABhc3NlcnRpb24gZmFpbGVkOiBidWZbMF0gPiBiJzAnAFgJEABXAAAAuAAAAAUAAABYCRAAVwAAALkAAAAFAAAAeAMAADAFIAAOB2ABSRIgA50WoCgWH6AtKiSgN3QrYD30LOA9jaQgPiymoESk1yBFbvqgS9D9YEw3B6FOmiPhW5AvYYVWNEGG+0OhhkdG4YYAYSGHAGhBhzlqgYdAbaGH1oyBivCv4YwjsYGN/LJhjgC8oY8AzMGPtM4BkabWYZHM12GZjNqhmQDf4ZmQ4oGa0OTBnXHsgZ4A8EGi2fZBq1j6Ya4AAOKx4KaCtB64orSuzuK04esitV7uYrUA+KK1HvrCtQAA47VLEwO2ejQjtv7/Y7b+/5S2AAMAAIMEIACRBWAAXROgABIXIB8MIGAf7yxgKyow4CtvpqAsAqggLR77IC4A/mA2nv+gNv0BITcBCmE3JA0hOKsOoTkvGCE68x4hS0A0oVMeYeFU8GphVU9v4VWdvGFWAM9hV2XRoVcA2iFYAOChWa7iIVvs5OFc0OhhXSAA7l7wAX9fTwMAABwGYABfEaAAtBfgAAsgIAFkMaABAP5gAqC8oQJz0aEDAADuAwAQLgQAEF8EAAYAAJAIYAAOGGABCyDgAf/+IAK9ECEDMDShA6C8IQRz0WEEAQCuBIAA/wTfRRo9A88a5sH7zP4AAAAAysaaxxf+cKvc+9T+AAAAAE/cvL78sXf/9vvc/gAAAAAM1mtB75FWvhH85P4AAAAAPPx/kK0f0I0s/Oz+AAAAAIOaVTEoXFHTRvz0/gAAAAC1yaatj6xxnWH8/P4AAAAAy4vuI3cinOp7/AT/AAAAAG1TeECRScyulvwM/wAAAABXzrZdeRI8grH8FP8AAAAAN1b7TTaUEMLL/Bz/AAAAAE+YSDhv6paQ5vwk/wAAAADHOoIly4V01wD9LP8AAAAA9Je/l83PhqAb/TT/AAAAAOWsKheYCjTvNf08/wAAAACOsjUq+2c4slD9RP8AAAAAOz/G0t/UyIRr/Uz/AAAAALrN0xonRN3Fhf1U/wAAAACWySW7zp9rk6D9XP8AAAAAhKVifSRsrNu6/WT/AAAAAPbaXw1YZquj1f1s/wAAAAAm8cPek/ji8+/9dP8AAAAAuID/qqittbUK/nz/AAAAAItKfGwFX2KHJf6E/wAAAABTMME0YP+8yT/+jP8AAAAAVSa6kYyFTpZa/pT/AAAAAL1+KXAkd/nfdP6c/wAAAACPuOW4n73fpo/+pP8AAAAAlH10iM9fqfip/qz/AAAAAM+bqI+TcES5xP60/wAAAABrFQ+/+PAIit/+vP8AAAAAtjExZVUlsM35/sT/AAAAAKx/e9DG4j+ZFP/M/wAAAAAGOysqxBBc5C7/1P8AAAAA05JzaZkkJKpJ/9z/AAAAAA7KAIPytYf9Y//k/wAAAADrGhGSZAjlvH7/7P8AAAAAzIhQbwnMvIyZ//T/AAAAACxlGeJYF7fRs//8/w=="); 41 base64DecodeToExistingUint8Array(bufferView, 1065574, "QJzO/wQ="); 42 base64DecodeToExistingUint8Array(bufferView, 1065588, "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"); 43 base64DecodeToExistingUint8Array(bufferView, 1068098, "AQD/DwAAuD0Q"); 44} 45 46 var scratchBuffer = new ArrayBuffer(16); 47 var i32ScratchView = new Int32Array(scratchBuffer); 48 var f32ScratchView = new Float32Array(scratchBuffer); 49 var f64ScratchView = new Float64Array(scratchBuffer); 50 51 function wasm2js_scratch_load_i32(index) { 52 return i32ScratchView[index]; 53 } 54 55 function wasm2js_scratch_store_f64(value) { 56 f64ScratchView[0] = value; 57 } 58 function wasm2js_trap() { throw new Error('abort'); } 59 60 function wasm2js_memory_copy(dest, source, size) { 61 // TODO: traps on invalid things 62 bufferView.copyWithin(dest, source, source + size); 63 } 64 65 function wasm2js_memory_fill(dest, value, size) { 66 dest = dest >>> 0; 67 size = size >>> 0; 68 if (dest + size > bufferView.length) throw "trap: invalid memory.fill"; 69 bufferView.fill(value, dest, dest + size); 70 } 71 72function asmFunc(imports) { 73 var buffer = new ArrayBuffer(1114112); 74 var HEAP8 = new Int8Array(buffer); 75 var HEAP16 = new Int16Array(buffer); 76 var HEAP32 = new Int32Array(buffer); 77 var HEAPU8 = new Uint8Array(buffer); 78 var HEAPU16 = new Uint16Array(buffer); 79 var HEAPU32 = new Uint32Array(buffer); 80 var HEAPF32 = new Float32Array(buffer); 81 var HEAPF64 = new Float64Array(buffer); 82 var Math_imul = Math.imul; 83 var Math_fround = Math.fround; 84 var Math_abs = Math.abs; 85 var Math_clz32 = Math.clz32; 86 var Math_min = Math.min; 87 var Math_max = Math.max; 88 var Math_floor = Math.floor; 89 var Math_ceil = Math.ceil; 90 var Math_trunc = Math.trunc; 91 var Math_sqrt = Math.sqrt; 92 var global$0 = 1048576; 93 var i64toi32_i32$HIGH_BITS = 0; 94 function $0($0_1, $1_1) { 95 var $2_1 = 0; 96 $2_1 = global$0 - 16 | 0; 97 global$0 = $2_1; 98 block : { 99 if (HEAP32[$0_1 + 12 >> 2]) { 100 $1_1 = $0_1; 101 break block; 102 } 103 $72($2_1 + 8 | 0, $1_1 + 12 | 0); 104 $1_1 = $55($0_1, HEAP32[$2_1 + 8 >> 2], HEAP32[$2_1 + 12 >> 2]); 105 $99($0_1, 20); 106 } 107 global$0 = $2_1 + 16 | 0; 108 return $1_1; 109 } 110 111 function $1($0_1, $1_1) { 112 var $2_1 = 0, $3_1 = 0, $4_1 = 0, $5_1 = 0, $6_1 = 0, $7_1 = 0, $8_1 = 0, $9_1 = 0, $10_1 = 0, $11_1 = 0, $12_1 = 0, $13_1 = 0; 113 $3_1 = HEAPU8[$1_1 + 29 | 0]; 114 $5_1 = HEAP32[$1_1 + 24 >> 2]; 115 $4_1 = HEAP32[$1_1 + 16 >> 2]; 116 $8_1 = HEAP32[$1_1 + 4 >> 2]; 117 $11_1 = HEAPU8[$1_1 + 28 | 0]; 118 $9_1 = HEAP32[$1_1 + 20 >> 2]; 119 $12_1 = HEAP32[$1_1 + 8 >> 2]; 120 $2_1 = HEAP32[$1_1 >> 2]; 121 block : { 122 while (1) { 123 $7_1 = $2_1; 124 if ($3_1 & 1) { 125 break block 126 } 127 block6 : { 128 if (($4_1 | 0) != ($9_1 | 0)) { 129 while (1) { 130 $6_1 = $5_1; 131 $6_1 = $5_1; 132 $2_1 = $4_1; 133 $5_1 = HEAP8[$2_1 | 0]; 134 block1 : { 135 if (($5_1 | 0) >= 0) { 136 $3_1 = $5_1 & 255; 137 $4_1 = $2_1 + 1 | 0; 138 break block1; 139 } 140 $3_1 = HEAPU8[$2_1 + 1 | 0] & 63; 141 $4_1 = $5_1 & 31; 142 if ($5_1 >>> 0 <= 4294967263) { 143 $3_1 = $3_1 | $4_1 << 6; 144 $4_1 = $2_1 + 2 | 0; 145 break block1; 146 } 147 $3_1 = HEAPU8[$2_1 + 2 | 0] & 63 | $3_1 << 6; 148 if ($5_1 >>> 0 < 4294967280) { 149 $3_1 = $4_1 << 12 | $3_1; 150 $4_1 = $2_1 + 3 | 0; 151 break block1; 152 } 153 $3_1 = $4_1 << 18 & 1835008 | (HEAPU8[$2_1 + 3 | 0] & 63 | $3_1 << 6); 154 $4_1 = $2_1 + 4 | 0; 155 } 156 $5_1 = $6_1 + ($4_1 - $2_1 | 0) | 0; 157 block3 : { 158 $2_1 = $3_1 - 9 | 0; 159 block2 : { 160 if (1 << $2_1 & 8388639 ? $2_1 >>> 0 <= 23 : 0) { 161 break block2 162 } 163 if ($3_1 >>> 0 < 133) { 164 break block3 165 } 166 block5 : { 167 block4 : { 168 $2_1 = $3_1 >>> 8 | 0; 169 if ($2_1 >>> 0 <= 31) { 170 if (!$2_1) { 171 break block4 172 } 173 if (($2_1 | 0) != 22 | ($3_1 | 0) != 5760) { 174 break block3 175 } 176 break block2; 177 } 178 if (($2_1 | 0) == 32) { 179 break block5 180 } 181 if (($2_1 | 0) != 48 | ($3_1 | 0) != 12288) { 182 break block3 183 } 184 break block2; 185 } 186 if (HEAP8[($3_1 & 255) + 1060037 | 0] & 1) { 187 break block2 188 } 189 break block3; 190 } 191 if (!(HEAPU8[($3_1 & 255) + 1060037 | 0] & 2)) { 192 break block3 193 } 194 } 195 HEAP32[$1_1 + 24 >> 2] = $5_1; 196 HEAP32[$1_1 + 16 >> 2] = $4_1; 197 HEAP32[$1_1 >> 2] = $5_1; 198 $3_1 = 0; 199 $2_1 = $5_1; 200 break block6; 201 } 202 if (($4_1 | 0) != ($9_1 | 0)) { 203 continue 204 } 205 break; 206 }; 207 HEAP32[$1_1 + 24 >> 2] = $5_1; 208 HEAP32[$1_1 + 16 >> 2] = $4_1; 209 } 210 $3_1 = 1; 211 HEAP8[$1_1 + 29 | 0] = 1; 212 if ($11_1 & 1) { 213 $2_1 = $7_1; 214 $6_1 = $8_1; 215 break block6; 216 } 217 $6_1 = $8_1; 218 $2_1 = $7_1; 219 if (($8_1 | 0) == ($2_1 | 0)) { 220 break block 221 } 222 } 223 $10_1 = $6_1 - $7_1 | 0; 224 if (!$10_1) { 225 continue 226 } 227 break; 228 }; 229 $13_1 = $7_1 + $12_1 | 0; 230 } 231 HEAP32[$0_1 + 4 >> 2] = $10_1; 232 HEAP32[$0_1 >> 2] = $13_1; 233 } 234 235 function $2($0_1) { 236 if (HEAP32[$0_1 >> 2] != -1) { 237 $46($0_1) 238 } 239 } 240 241 function $3($0_1) { 242 $0_1 = $0_1 | 0; 243 var $1_1 = 0; 244 block2 : { 245 block1 : { 246 block : { 247 $0_1 = HEAP32[$0_1 >> 2]; 248 switch (HEAP32[$0_1 >> 2]) { 249 case 0: 250 break block; 251 case 1: 252 break block1; 253 default: 254 break block2; 255 }; 256 } 257 $1_1 = HEAP32[$0_1 + 8 >> 2]; 258 if (!$1_1) { 259 break block2 260 } 261 $99(HEAP32[$0_1 + 4 >> 2], $1_1); 262 break block2; 263 } 264 if (HEAPU8[$0_1 + 4 | 0] != 3) { 265 break block2 266 } 267 $1_1 = HEAP32[$0_1 + 8 >> 2]; 268 FUNCTION_TABLE[HEAP32[$1_1 + 12 >> 2]]($1_1); 269 } 270 $99($0_1, 20); 271 } 272 273 function $4($0_1) { 274 var $1_1 = 0, $2_1 = 0; 275 block2 : { 276 switch (HEAPU8[$0_1 | 0]) { 277 default: 278 $44($0_1 + 4 | 0); 279 case 0: 280 case 1: 281 case 2: 282 return; 283 case 3: 284 $46($0_1 + 4 | 0); 285 return; 286 case 4: 287 break block2; 288 }; 289 } 290 $2_1 = $0_1 + 4 | 0; 291 $0_1 = $2_1; 292 $1_1 = HEAP32[$0_1 + 8 >> 2]; 293 if ($1_1) { 294 $0_1 = HEAP32[$0_1 + 4 >> 2]; 295 while (1) { 296 $37($0_1); 297 $0_1 = $0_1 + 24 | 0; 298 $1_1 = $1_1 - 1 | 0; 299 if ($1_1) { 300 continue 301 } 302 break; 303 }; 304 } 305 $45($2_1, 8, 24); 306 } 307 308 function $5($0_1, $1_1, $2_1, $3_1) { 309 var $4_1 = 0, $5_1 = 0, $6_1 = 0, $7_1 = 0, $8_1 = 0, $9_1 = 0; 310 $7_1 = HEAP32[$1_1 >> 2]; 311 $60($7_1, 1052517, 1); 312 HEAP8[$0_1 | 0] = 255; 313 $8_1 = $0_1; 314 $4_1 = global$0 - 16 | 0; 315 global$0 = $4_1; 316 $5_1 = HEAP32[$1_1 >> 2]; 317 block : { 318 if (!$3_1) { 319 break block 320 } 321 while (1) { 322 $0_1 = $3_1; 323 $1_1 = 0; 324 block1 : { 325 while (1) { 326 $9_1 = $1_1 + $2_1 | 0; 327 $3_1 = HEAPU8[$9_1 | 0]; 328 $6_1 = HEAPU8[$3_1 + 1052933 | 0]; 329 if ($6_1) { 330 break block1 331 } 332 $1_1 = $1_1 + 1 | 0; 333 if (($1_1 | 0) != ($0_1 | 0)) { 334 continue 335 } 336 break; 337 }; 338 $3_1 = $0_1; 339 break block; 340 } 341 if ($1_1) { 342 $60($5_1, $2_1, $1_1) 343 } 344 block2 : { 345 if (($6_1 | 0) == 117) { 346 $2_1 = 808482140; 347 HEAP8[$4_1 + 8 | 0] = $2_1; 348 HEAP8[$4_1 + 9 | 0] = $2_1 >>> 8; 349 HEAP8[$4_1 + 10 | 0] = $2_1 >>> 16; 350 HEAP8[$4_1 + 11 | 0] = $2_1 >>> 24; 351 HEAP8[$4_1 + 13 | 0] = HEAPU8[($3_1 & 15) + 1053189 | 0]; 352 HEAP8[$4_1 + 12 | 0] = HEAPU8[($3_1 >>> 4 | 0) + 1053189 | 0]; 353 $60($5_1, $4_1 + 8 | 0, 6); 354 break block2; 355 } 356 HEAP8[$4_1 + 15 | 0] = $6_1; 357 HEAP8[$4_1 + 14 | 0] = 92; 358 $60($5_1, $4_1 + 14 | 0, 2); 359 } 360 $3_1 = $0_1 + ($1_1 ^ -1) | 0; 361 $2_1 = $9_1 + 1 | 0; 362 if (($1_1 | 0) != ($0_1 - 1 | 0)) { 363 continue 364 } 365 break; 366 }; 367 } 368 if ($3_1) { 369 $60($5_1, $2_1, $3_1) 370 } 371 HEAP8[$8_1 | 0] = 255; 372 global$0 = $4_1 + 16 | 0; 373 if (HEAPU8[$8_1 | 0] == 255) { 374 $60($7_1, 1052517, 1) 375 } 376 } 377 378 function $6($0_1, $1_1) { 379 var $2_1 = 0, $3_1 = 0, $4_1 = 0, $5_1 = 0; 380 $3_1 = global$0 - 16 | 0; 381 global$0 = $3_1; 382 block3 : { 383 block4 : { 384 block1 : { 385 switch (HEAPU8[$1_1 | 0] - 1 | 0) { 386 default: 387 $5_1 = 6; 388 $35($3_1 + 4 | 0, 6, 1, 1); 389 $4_1 = HEAP32[$3_1 + 8 >> 2]; 390 if (HEAP32[$3_1 + 4 >> 2] == 1) { 391 break block3 392 } 393 $1_1 = HEAP32[$3_1 + 12 >> 2]; 394 $2_1 = 1051692; 395 $2_1 = HEAPU8[$2_1 | 0] | HEAPU8[$2_1 + 1 | 0] << 8; 396 HEAP8[$1_1 + 4 | 0] = $2_1; 397 HEAP8[$1_1 + 5 | 0] = $2_1 >>> 8; 398 $2_1 = 1051688; 399 $2_1 = HEAPU8[$2_1 | 0] | HEAPU8[$2_1 + 1 | 0] << 8 | (HEAPU8[$2_1 + 2 | 0] << 16 | HEAPU8[$2_1 + 3 | 0] << 24); 400 HEAP8[$1_1 | 0] = $2_1; 401 HEAP8[$1_1 + 1 | 0] = $2_1 >>> 8; 402 HEAP8[$1_1 + 2 | 0] = $2_1 >>> 16; 403 HEAP8[$1_1 + 3 | 0] = $2_1 >>> 24; 404 break block4; 405 case 0: 406 $5_1 = 7; 407 $35($3_1 + 4 | 0, 7, 1, 1); 408 $4_1 = HEAP32[$3_1 + 8 >> 2]; 409 if (HEAP32[$3_1 + 4 >> 2] == 1) { 410 break block3 411 } 412 $1_1 = HEAP32[$3_1 + 12 >> 2]; 413 $2_1 = 1051697; 414 $2_1 = HEAPU8[$2_1 | 0] | HEAPU8[$2_1 + 1 | 0] << 8 | (HEAPU8[$2_1 + 2 | 0] << 16 | HEAPU8[$2_1 + 3 | 0] << 24); 415 HEAP8[$1_1 + 3 | 0] = $2_1; 416 HEAP8[$1_1 + 4 | 0] = $2_1 >>> 8; 417 HEAP8[$1_1 + 5 | 0] = $2_1 >>> 16; 418 HEAP8[$1_1 + 6 | 0] = $2_1 >>> 24; 419 $2_1 = 1051694; 420 $2_1 = HEAPU8[$2_1 | 0] | HEAPU8[$2_1 + 1 | 0] << 8 | (HEAPU8[$2_1 + 2 | 0] << 16 | HEAPU8[$2_1 + 3 | 0] << 24); 421 HEAP8[$1_1 | 0] = $2_1; 422 HEAP8[$1_1 + 1 | 0] = $2_1 >>> 8; 423 HEAP8[$1_1 + 2 | 0] = $2_1 >>> 16; 424 HEAP8[$1_1 + 3 | 0] = $2_1 >>> 24; 425 break block4; 426 case 1: 427 break block1; 428 }; 429 } 430 $5_1 = 6; 431 $35($3_1 + 4 | 0, 6, 1, 1); 432 $4_1 = HEAP32[$3_1 + 8 >> 2]; 433 if (HEAP32[$3_1 + 4 >> 2] == 1) { 434 break block3 435 } 436 $1_1 = HEAP32[$3_1 + 12 >> 2]; 437 $2_1 = 1051705; 438 $2_1 = HEAPU8[$2_1 | 0] | HEAPU8[$2_1 + 1 | 0] << 8; 439 HEAP8[$1_1 + 4 | 0] = $2_1; 440 HEAP8[$1_1 + 5 | 0] = $2_1 >>> 8; 441 $2_1 = 1051701; 442 $2_1 = HEAPU8[$2_1 | 0] | HEAPU8[$2_1 + 1 | 0] << 8 | (HEAPU8[$2_1 + 2 | 0] << 16 | HEAPU8[$2_1 + 3 | 0] << 24); 443 HEAP8[$1_1 | 0] = $2_1; 444 HEAP8[$1_1 + 1 | 0] = $2_1 >>> 8; 445 HEAP8[$1_1 + 2 | 0] = $2_1 >>> 16; 446 HEAP8[$1_1 + 3 | 0] = $2_1 >>> 24; 447 } 448 HEAP32[$0_1 + 12 >> 2] = $5_1; 449 HEAP32[$0_1 + 8 >> 2] = $1_1; 450 HEAP32[$0_1 + 4 >> 2] = $4_1; 451 HEAP8[$0_1 | 0] = 3; 452 global$0 = $3_1 + 16 | 0; 453 return; 454 } 455 $120($4_1, HEAP32[$3_1 + 12 >> 2]); 456 wasm2js_trap(); 457 } 458 459 function $7($0_1, $1_1) { 460 var $2_1 = 0, $3_1 = 0, $4_1 = 0, $5_1 = 0, $6_1 = 0, $7_1 = 0, $8_1 = 0, $9_1 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; 461 $2_1 = global$0 - 48 | 0; 462 global$0 = $2_1; 463 block1 : { 464 block : { 465 $5_1 = HEAP32[$1_1 >> 2]; 466 $3_1 = HEAP32[$5_1 + 20 >> 2]; 467 $7_1 = HEAP32[$5_1 + 16 >> 2]; 468 if ($3_1 >>> 0 < $7_1 >>> 0) { 469 $8_1 = $5_1 + 12 | 0; 470 $9_1 = HEAP32[$5_1 + 12 >> 2]; 471 while (1) { 472 $4_1 = HEAPU8[$3_1 + $9_1 | 0]; 473 $6_1 = $4_1 - 9 | 0; 474 if ($6_1 >>> 0 > 23 | !(1 << $6_1 & 8388627)) { 475 break block 476 } 477 $3_1 = $3_1 + 1 | 0; 478 HEAP32[$5_1 + 20 >> 2] = $3_1; 479 if (($3_1 | 0) != ($7_1 | 0)) { 480 continue 481 } 482 break; 483 }; 484 } 485 HEAP32[$2_1 + 36 >> 2] = 2; 486 $71($2_1 + 24 | 0, $5_1 + 12 | 0); 487 (wasm2js_i32$0 = $0_1, wasm2js_i32$1 = $55($2_1 + 36 | 0, HEAP32[$2_1 + 24 >> 2], HEAP32[$2_1 + 28 >> 2])), HEAP32[wasm2js_i32$0 + 4 >> 2] = wasm2js_i32$1; 488 $4_1 = 1; 489 break block1; 490 } 491 if (($4_1 | 0) == 93) { 492 $4_1 = 0; 493 HEAP8[$0_1 + 1 | 0] = 0; 494 break block1; 495 } 496 block3 : { 497 block2 : { 498 if (!HEAPU8[$1_1 + 4 | 0]) { 499 if (($4_1 | 0) != 44) { 500 break block2 501 } 502 $4_1 = 1; 503 $3_1 = $3_1 + 1 | 0; 504 HEAP32[$5_1 + 20 >> 2] = $3_1; 505 if ($3_1 >>> 0 < $7_1 >>> 0) { 506 while (1) { 507 $1_1 = HEAPU8[$3_1 + $9_1 | 0]; 508 $6_1 = $1_1 - 9 | 0; 509 if ($6_1 >>> 0 > 23 | !(1 << $6_1 & 8388627)) { 510 break block3 511 } 512 $3_1 = $3_1 + 1 | 0; 513 HEAP32[$5_1 + 20 >> 2] = $3_1; 514 if (($3_1 | 0) != ($7_1 | 0)) { 515 continue 516 } 517 break; 518 } 519 } 520 HEAP32[$2_1 + 36 >> 2] = 5; 521 $71($2_1, $8_1); 522 (wasm2js_i32$0 = $0_1, wasm2js_i32$1 = $55($2_1 + 36 | 0, HEAP32[$2_1 >> 2], HEAP32[$2_1 + 4 >> 2])), HEAP32[wasm2js_i32$0 + 4 >> 2] = wasm2js_i32$1; 523 break block1; 524 } 525 HEAP8[$0_1 + 1 | 0] = 1; 526 $4_1 = 0; 527 HEAP8[$1_1 + 4 | 0] = 0; 528 break block1; 529 } 530 HEAP32[$2_1 + 36 >> 2] = 7; 531 $71($2_1 + 16 | 0, $8_1); 532 (wasm2js_i32$0 = $0_1, wasm2js_i32$1 = $55($2_1 + 36 | 0, HEAP32[$2_1 + 16 >> 2], HEAP32[$2_1 + 20 >> 2])), HEAP32[wasm2js_i32$0 + 4 >> 2] = wasm2js_i32$1; 533 $4_1 = 1; 534 break block1; 535 } 536 if (($1_1 | 0) == 93) { 537 HEAP32[$2_1 + 36 >> 2] = 21; 538 $71($2_1 + 8 | 0, $8_1); 539 (wasm2js_i32$0 = $0_1, wasm2js_i32$1 = $55($2_1 + 36 | 0, HEAP32[$2_1 + 8 >> 2], HEAP32[$2_1 + 12 >> 2])), HEAP32[wasm2js_i32$0 + 4 >> 2] = wasm2js_i32$1; 540 break block1; 541 } 542 HEAP8[$0_1 + 1 | 0] = 1; 543 $4_1 = 0; 544 } 545 HEAP8[$0_1 | 0] = $4_1; 546 global$0 = $2_1 + 48 | 0; 547 } 548 549 function $8($0_1, $1_1) { 550 var $2_1 = 0, $3_1 = 0, $4_1 = 0, $5_1 = 0, $6_1 = 0, $7_1 = 0, $8_1 = 0, $9_1 = 0, $10_1 = 0, $11_1 = 0, $12_1 = 0.0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; 551 $4_1 = global$0 + -64 | 0; 552 global$0 = $4_1; 553 block7 : { 554 block6 : { 555 block15 : { 556 block1 : { 557 switch (HEAPU8[$0_1 | 0] - 1 | 0) { 558 default: 559 $60(HEAP32[$1_1 >> 2], 1052527, 4); 560 break block6; 561 case 0: 562 $0_1 = HEAPU8[$0_1 + 1 | 0]; 563 $60(HEAP32[$1_1 >> 2], $0_1 ? 1052523 : 1052518, $0_1 ? 4 : 5); 564 break block6; 565 case 2: 566 $5($4_1 + 56 | 0, $1_1, HEAP32[$0_1 + 8 >> 2], HEAP32[$0_1 + 12 >> 2]); 567 $0_1 = 0; 568 if (HEAPU8[$4_1 + 56 | 0] == 255) { 569 break block7 570 } 571 $9_1 = HEAP32[$4_1 + 60 >> 2]; 572 HEAP32[$4_1 + 16 >> 2] = HEAP32[$4_1 + 56 >> 2]; 573 HEAP32[$4_1 + 20 >> 2] = $9_1; 574 $0_1 = $57($4_1 + 16 | 0); 575 break block7; 576 case 3: 577 $3_1 = global$0 - 16 | 0; 578 global$0 = $3_1; 579 $2_1 = $0_1 + 4 | 0; 580 $0_1 = HEAP32[$2_1 + 4 >> 2]; 581 HEAP32[$3_1 + 8 >> 2] = $0_1; 582 $2_1 = HEAP32[$2_1 + 8 >> 2]; 583 $7_1 = Math_imul($2_1, 24); 584 $5_1 = $7_1 + $0_1 | 0; 585 HEAP32[$3_1 + 12 >> 2] = $5_1; 586 HEAP32[$3_1 >> 2] = 1; 587 $6_1 = $3_1 + 8 | 0; 588 HEAP32[$3_1 + 4 >> 2] = (HEAP32[$6_1 + 4 >> 2] - HEAP32[$6_1 >> 2] >>> 0) / 24; 589 $9_1 = HEAP32[$3_1 >> 2]; 590 $8_1 = HEAP32[$3_1 + 4 >> 2]; 591 $10_1 = HEAP32[$1_1 >> 2]; 592 $60($10_1, 1052531, 1); 593 $6_1 = !$8_1 & $9_1; 594 if ($6_1) { 595 $60($10_1, 1052535, 1) 596 } 597 block8 : { 598 block9 : { 599 if ($2_1) { 600 $2_1 = !$6_1; 601 while (1) { 602 if (!($2_1 & 1)) { 603 $60(HEAP32[$1_1 >> 2], 1052533, 1) 604 } 605 $2_1 = $8($0_1, $1_1); 606 if ($2_1) { 607 break block8 608 } 609 $0_1 = $0_1 + 24 | 0; 610 $2_1 = 0; 611 $7_1 = $7_1 - 24 | 0; 612 if ($7_1) { 613 continue 614 } 615 break; 616 }; 617 HEAP32[$3_1 + 8 >> 2] = $5_1; 618 break block9; 619 } 620 HEAP32[$3_1 + 8 >> 2] = $0_1; 621 $2_1 = 0; 622 if ($6_1) { 623 break block8 624 } 625 } 626 $60(HEAP32[$1_1 >> 2], 1052535, 1); 627 } 628 global$0 = $3_1 + 16 | 0; 629 $0_1 = $2_1; 630 break block7; 631 case 4: 632 $2_1 = HEAP32[$0_1 + 12 >> 2]; 633 $3_1 = HEAP32[$1_1 >> 2]; 634 $60($3_1, 1052532, 1); 635 if ($2_1) { 636 $5_1 = 1 637 } else { 638 $60($3_1, 1052516, 1); 639 $5_1 = 0; 640 } 641 HEAP8[$4_1 + 60 | 0] = $5_1; 642 HEAP32[$4_1 + 56 >> 2] = $1_1; 643 $1_1 = HEAP32[$0_1 + 8 >> 2]; 644 $0_1 = HEAP32[$0_1 + 4 >> 2]; 645 HEAP32[$4_1 + 48 >> 2] = $0_1 ? $2_1 : 0; 646 HEAP32[$4_1 + 44 >> 2] = $1_1; 647 HEAP32[$4_1 + 40 >> 2] = $0_1; 648 HEAP32[$4_1 + 36 >> 2] = 0; 649 $2_1 = ($0_1 | 0) != 0; 650 HEAP32[$4_1 + 32 >> 2] = $2_1; 651 HEAP32[$4_1 + 28 >> 2] = $1_1; 652 HEAP32[$4_1 + 24 >> 2] = $0_1; 653 HEAP32[$4_1 + 20 >> 2] = 0; 654 HEAP32[$4_1 + 16 >> 2] = $2_1; 655 while (1) { 656 $5_1 = $4_1 + 8 | 0; 657 $1_1 = 0; 658 block14 : { 659 block10 : { 660 block12 : { 661 $0_1 = $4_1 + 16 | 0; 662 $2_1 = HEAP32[$0_1 + 32 >> 2]; 663 if ($2_1) { 664 HEAP32[$0_1 + 32 >> 2] = $2_1 - 1; 665 $3_1 = $65($0_1); 666 if (!$3_1) { 667 break block10 668 } 669 $6_1 = HEAP32[$3_1 + 4 >> 2]; 670 $7_1 = HEAP32[$3_1 + 8 >> 2]; 671 $1_1 = HEAP32[$3_1 >> 2]; 672 block11 : { 673 if ($7_1 >>> 0 < HEAPU16[$1_1 + 402 >> 1]) { 674 $0_1 = $1_1; 675 break block11; 676 } 677 while (1) { 678 $0_1 = HEAP32[$1_1 + 264 >> 2]; 679 if (!$0_1) { 680 break block12 681 } 682 $6_1 = $6_1 + 1 | 0; 683 $7_1 = HEAPU16[$1_1 + 400 >> 1]; 684 $1_1 = $0_1; 685 if (HEAPU16[$0_1 + 402 >> 1] <= $7_1 >>> 0) { 686 continue 687 } 688 break; 689 }; 690 } 691 block13 : { 692 if (!$6_1) { 693 $2_1 = $0_1; 694 $1_1 = $7_1 + 1 | 0; 695 break block13; 696 } 697 $1_1 = (($7_1 << 2) + $0_1 | 0) + 412 | 0; 698 while (1) { 699 $2_1 = HEAP32[$1_1 >> 2]; 700 $1_1 = $2_1 + 408 | 0; 701 $6_1 = $6_1 - 1 | 0; 702 if ($6_1) { 703 continue 704 } 705 break; 706 }; 707 $1_1 = 0; 708 } 709 HEAP32[$3_1 + 8 >> 2] = $1_1; 710 HEAP32[$3_1 + 4 >> 2] = 0; 711 HEAP32[$3_1 >> 2] = $2_1; 712 $1_1 = Math_imul($7_1, 24) + $0_1 | 0; 713 $0_1 = (Math_imul($7_1, 12) + $0_1 | 0) + 268 | 0; 714 } else { 715 $0_1 = 0 716 } 717 HEAP32[$5_1 + 4 >> 2] = $1_1; 718 HEAP32[$5_1 >> 2] = $0_1; 719 break block14; 720 } 721 $151(1053500); 722 wasm2js_trap(); 723 } 724 $151(1053612); 725 wasm2js_trap(); 726 } 727 $2_1 = HEAP32[$4_1 + 8 >> 2]; 728 if (!$2_1) { 729 break block15 730 } 731 $7_1 = HEAP32[$4_1 + 12 >> 2]; 732 $1_1 = global$0 - 16 | 0; 733 global$0 = $1_1; 734 $3_1 = $4_1 + 56 | 0; 735 $0_1 = HEAP32[$3_1 >> 2]; 736 if (HEAPU8[$3_1 + 4 | 0] != 1) { 737 $60(HEAP32[$0_1 >> 2], 1052533, 1) 738 } 739 HEAP8[$3_1 + 4 | 0] = 2; 740 $5($1_1, $0_1, HEAP32[$2_1 + 4 >> 2], HEAP32[$2_1 + 8 >> 2]); 741 block16 : { 742 if (HEAPU8[$1_1 | 0] != 255) { 743 $0_1 = HEAP32[$1_1 + 4 >> 2]; 744 HEAP32[$1_1 + 8 >> 2] = HEAP32[$1_1 >> 2]; 745 HEAP32[$1_1 + 12 >> 2] = $0_1; 746 $0_1 = $57($1_1 + 8 | 0); 747 break block16; 748 } 749 $60(HEAP32[$0_1 >> 2], 1052534, 1); 750 $0_1 = $8($7_1, $0_1); 751 } 752 global$0 = $1_1 + 16 | 0; 753 if (!$0_1) { 754 continue 755 } 756 break; 757 }; 758 break block7; 759 case 1: 760 break block1; 761 }; 762 } 763 $2_1 = global$0 + -64 | 0; 764 global$0 = $2_1; 765 block20 : { 766 block18 : { 767 block17 : { 768 block19 : { 769 $0_1 = $0_1 + 8 | 0; 770 switch (HEAP32[$0_1 >> 2] - 1 | 0) { 771 case 0: 772 break block17; 773 case 1: 774 break block18; 775 default: 776 break block19; 777 }; 778 } 779 $5_1 = $0_1; 780 $11_1 = HEAP32[$0_1 + 8 >> 2]; 781 $0_1 = global$0 - 16 | 0; 782 global$0 = $0_1; 783 $3_1 = $2_1 + 24 | 0; 784 $82($0_1 + 8 | 0, $3_1, $83($11_1, HEAP32[$5_1 + 12 >> 2], $3_1)); 785 $3_1 = HEAP32[$0_1 + 12 >> 2]; 786 HEAP32[$2_1 >> 2] = HEAP32[$0_1 + 8 >> 2]; 787 HEAP32[$2_1 + 4 >> 2] = $3_1; 788 global$0 = $0_1 + 16 | 0; 789 $60(HEAP32[$1_1 >> 2], HEAP32[$2_1 >> 2], HEAP32[$2_1 + 4 >> 2]); 790 break block20; 791 } 792 $7_1 = $2_1 + 8 | 0; 793 $3_1 = global$0 - 16 | 0; 794 global$0 = $3_1; 795 $11_1 = HEAP32[$0_1 + 8 >> 2]; 796 $10_1 = HEAP32[$0_1 + 12 >> 2]; 797 $0_1 = $10_1; 798 $5_1 = $11_1; 799 $8_1 = 63; 800 $6_1 = 31; 801 if (($8_1 & 63) >>> 0 >= 32) { 802 $9_1 = $0_1 >> 31; 803 $8_1 = $0_1 >> $6_1; 804 } else { 805 $9_1 = $0_1 >> $6_1; 806 $8_1 = ((1 << $6_1) - 1 & $0_1) << 32 - $6_1 | $5_1 >>> $6_1; 807 } 808 $0_1 = $9_1; 809 $5_1 = $0_1 ^ $10_1; 810 $9_1 = $8_1 ^ $11_1; 811 $6_1 = $2_1 + 24 | 0; 812 $0_1 = $83($9_1 - $8_1 | 0, $5_1 - (($8_1 >>> 0 > $9_1 >>> 0) + $0_1 | 0) | 0, $6_1); 813 $5_1 = $11_1; 814 $8_1 = 0; 815 block22 : { 816 block21 : { 817 $9_1 = 0; 818 if (($10_1 | 0) < ($9_1 | 0)) { 819 $5_1 = 1 820 } else { 821 $5_1 = $5_1 >>> 0 < $8_1 >>> 0 & ($9_1 | 0) >= ($10_1 | 0) 822 } 823 if ($5_1) { 824 $0_1 = $0_1 - 1 | 0; 825 if ($0_1 >>> 0 > 19) { 826 break block21 827 } 828 HEAP8[$0_1 + $6_1 | 0] = 45; 829 } 830 $82($3_1 + 8 | 0, $6_1, $0_1); 831 $0_1 = HEAP32[$3_1 + 12 >> 2]; 832 HEAP32[$7_1 >> 2] = HEAP32[$3_1 + 8 >> 2]; 833 HEAP32[$7_1 + 4 >> 2] = $0_1; 834 global$0 = $3_1 + 16 | 0; 835 break block22; 836 } 837 $137($0_1, 20, 1058120); 838 wasm2js_trap(); 839 } 840 $60(HEAP32[$1_1 >> 2], HEAP32[$2_1 + 8 >> 2], HEAP32[$2_1 + 12 >> 2]); 841 break block20; 842 } 843 $12_1 = HEAPF64[$0_1 + 8 >> 3]; 844 wasm2js_scratch_store_f64(+$12_1); 845 $5_1 = wasm2js_scratch_load_i32(1) | 0; 846 $8_1 = wasm2js_scratch_load_i32(0) | 0; 847 $9_1 = 1; 848 $0_1 = 1; 849 if (($9_1 & 63) >>> 0 >= 32) { 850 $10_1 = $8_1 << $0_1; 851 $5_1 = 0; 852 } else { 853 $10_1 = (1 << $0_1) - 1 & $8_1 >>> 32 - $0_1 | $5_1 << $0_1; 854 $5_1 = $8_1 << $0_1; 855 } 856 $8_1 = -2097153; 857 if (($8_1 | 0) == ($10_1 | 0) | $8_1 >>> 0 > $10_1 >>> 0) { 858 $3_1 = $2_1 + 16 | 0; 859 $0_1 = $2_1 + 24 | 0; 860 (wasm2js_i32$0 = $3_1, wasm2js_i32$1 = $84($12_1, $0_1) - $0_1 | 0), HEAP32[wasm2js_i32$0 + 4 >> 2] = wasm2js_i32$1; 861 HEAP32[$3_1 >> 2] = $0_1; 862 $60(HEAP32[$1_1 >> 2], HEAP32[$2_1 + 16 >> 2], HEAP32[$2_1 + 20 >> 2]); 863 break block20; 864 } 865 $60(HEAP32[$1_1 >> 2], 1052527, 4); 866 } 867 global$0 = $2_1 - -64 | 0; 868 $0_1 = 0; 869 break block7; 870 } 871 if (!HEAPU8[$4_1 + 60 | 0]) { 872 break block6 873 } 874 $60(HEAP32[HEAP32[$4_1 + 56 >> 2] >> 2], 1052516, 1); 875 } 876 $0_1 = 0; 877 } 878 global$0 = $4_1 - -64 | 0; 879 return $0_1; 880 } 881 882 function $9($0_1, $1_1) { 883 var $2_1 = 0, $3_1 = 0, $4_1 = 0, $5_1 = 0, $6_1 = 0, $7_1 = 0, $8_1 = 0, $9_1 = 0, $10_1 = 0, $11_1 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; 884 $5_1 = global$0 + -64 | 0; 885 global$0 = $5_1; 886 $2_1 = HEAP32[$1_1 + 20 >> 2]; 887 $3_1 = HEAP32[$1_1 + 16 >> 2]; 888 block45 : { 889 block5 : { 890 if ($2_1 >>> 0 < $3_1 >>> 0) { 891 $8_1 = $1_1 + 12 | 0; 892 $6_1 = HEAP32[$1_1 + 12 >> 2]; 893 while (1) { 894 block1 : { 895 block4 : { 896 block2 : { 897 $4_1 = HEAPU8[$2_1 + $6_1 | 0]; 898 block : { 899 if ($4_1 >>> 0 <= 12) { 900 if ($4_1 - 9 >>> 0 >= 2) { 901 break block 902 } 903 break block1; 904 } 905 block3 : { 906 switch ($4_1 - 32 | 0) { 907 case 1: 908 break block; 909 case 0: 910 break block1; 911 case 2: 912 break block2; 913 default: 914 break block3; 915 }; 916 } 917 if (($4_1 | 0) == 13) { 918 break block1 919 } 920 if (($4_1 | 0) == 123) { 921 break block4 922 } 923 } 924 HEAP32[$5_1 + 52 >> 2] = 10; 925 $71($5_1 + 8 | 0, $8_1); 926 $1_1 = $55($5_1 + 52 | 0, HEAP32[$5_1 + 8 >> 2], HEAP32[$5_1 + 12 >> 2]); 927 break block5; 928 } 929 $8_1 = global$0 - 16 | 0; 930 global$0 = $8_1; 931 $4_1 = $8_1 + 8 | 0; 932 $2_1 = global$0 - 32 | 0; 933 global$0 = $2_1; 934 block7 : { 935 block6 : { 936 $3_1 = HEAP32[$1_1 + 20 >> 2]; 937 $6_1 = HEAP32[$1_1 + 16 >> 2]; 938 if ($3_1 >>> 0 < $6_1 >>> 0) { 939 $7_1 = $1_1 + 12 | 0; 940 $9_1 = HEAP32[$1_1 + 12 >> 2]; 941 while (1) { 942 $10_1 = HEAPU8[$3_1 + $9_1 | 0]; 943 $11_1 = $10_1 - 9 | 0; 944 if ($11_1 >>> 0 > 23 | !(1 << $11_1 & 8388627)) { 945 break block6 946 } 947 $3_1 = $3_1 + 1 | 0; 948 HEAP32[$1_1 + 20 >> 2] = $3_1; 949 if (($3_1 | 0) != ($6_1 | 0)) { 950 continue 951 } 952 break; 953 }; 954 } 955 HEAP32[$2_1 + 16 >> 2] = 5; 956 $71($2_1, $1_1 + 12 | 0); 957 $3_1 = $55($2_1 + 16 | 0, HEAP32[$2_1 >> 2], HEAP32[$2_1 + 4 >> 2]); 958 HEAP8[$4_1 | 0] = 1; 959 HEAP32[$4_1 + 4 >> 2] = $3_1; 960 break block7; 961 } 962 if (($10_1 | 0) != 34) { 963 $3_1 = $0($12($1_1, $2_1 + 31 | 0, 1052464), $1_1); 964 HEAP8[$4_1 | 0] = 1; 965 HEAP32[$4_1 + 4 >> 2] = $3_1; 966 break block7; 967 } 968 HEAP32[$1_1 + 8 >> 2] = 0; 969 HEAP32[$1_1 + 20 >> 2] = $3_1 + 1; 970 $73($2_1 + 16 | 0, $7_1, $1_1); 971 $3_1 = HEAP32[$2_1 + 20 >> 2]; 972 if (HEAP32[$2_1 + 16 >> 2] != 2) { 973 $10($2_1 + 8 | 0, $3_1, HEAP32[$2_1 + 24 >> 2]); 974 block8 : { 975 if (HEAPU8[$2_1 + 8 | 0] == 1) { 976 (wasm2js_i32$0 = $4_1, wasm2js_i32$1 = $0(HEAP32[$2_1 + 12 >> 2], $1_1)), HEAP32[wasm2js_i32$0 + 4 >> 2] = wasm2js_i32$1; 977 $3_1 = 1; 978 break block8; 979 } 980 HEAP8[$4_1 + 1 | 0] = HEAPU8[$2_1 + 9 | 0]; 981 $3_1 = 0; 982 } 983 HEAP8[$4_1 | 0] = $3_1; 984 break block7; 985 } 986 HEAP8[$4_1 | 0] = 1; 987 HEAP32[$4_1 + 4 >> 2] = $3_1; 988 } 989 global$0 = $2_1 + 32 | 0; 990 block43 : { 991 block44 : { 992 block41 : { 993 block40 : { 994 block39 : { 995 block38 : { 996 block37 : { 997 block36 : { 998 block35 : { 999 block34 : { 1000 block33 : { 1001 block32 : { 1002 block31 : { 1003 block30 : { 1004 block29 : { 1005 block28 : { 1006 block27 : { 1007 block26 : { 1008 block25 : { 1009 block24 : { 1010 block23 : { 1011 block22 : { 1012 block21 : { 1013 block20 : { 1014 block19 : { 1015 block18 : { 1016 block17 : { 1017 block16 : { 1018 block15 : { 1019 block14 : { 1020 block13 : { 1021 block12 : { 1022 block11 : { 1023 block10 : { 1024 block9 : { 1025 block42 : { 1026 $2_1 = HEAPU8[$8_1 + 8 | 0]; 1027 switch (($2_1 ? -1 : HEAPU8[$8_1 + 9 | 0]) & 255) { 1028 case 1: 1029 break block10; 1030 case 2: 1031 break block11; 1032 case 3: 1033 break block12; 1034 case 4: 1035 break block13; 1036 case 5: 1037 break block14; 1038 case 6: 1039 break block15; 1040 case 7: 1041 break block16; 1042 case 8: 1043 break block17; 1044 case 9: 1045 break block18; 1046 case 10: 1047 break block19; 1048 case 11: 1049 break block20; 1050 case 12: 1051 break block21; 1052 case 13: 1053 break block22; 1054 case 14: 1055 break block23; 1056 case 15: 1057 break block24; 1058 case 16: 1059 break block25; 1060 case 17: 1061 break block26; 1062 case 18: 1063 break block27; 1064 case 19: 1065 break block28; 1066 case 20: 1067 break block29; 1068 case 21: 1069 break block30; 1070 case 22: 1071 break block31; 1072 case 23: 1073 break block32; 1074 case 24: 1075 break block33; 1076 case 25: 1077 break block34; 1078 case 26: 1079 break block35; 1080 case 27: 1081 break block36; 1082 case 28: 1083 break block37; 1084 case 29: 1085 break block38; 1086 case 30: 1087 break block39; 1088 case 31: 1089 break block40; 1090 case 32: 1091 break block41; 1092 case 0: 1093 break block9; 1094 default: 1095 break block42; 1096 }; 1097 } 1098 HEAP32[$0_1 + 4 >> 2] = $2_1 ? HEAP32[$8_1 + 12 >> 2] : $1_1; 1099 $1_1 = 1; 1100 break block43; 1101 } 1102 HEAP8[$0_1 + 1 | 0] = 0; 1103 $1_1 = 0; 1104 break block43; 1105 } 1106 HEAP8[$0_1 + 1 | 0] = 1; 1107 break block44; 1108 } 1109 HEAP8[$0_1 + 1 | 0] = 2; 1110 break block44; 1111 } 1112 HEAP8[$0_1 + 1 | 0] = 3; 1113 break block44; 1114 } 1115 HEAP8[$0_1 + 1 | 0] = 4; 1116 break block44; 1117 } 1118 HEAP8[$0_1 + 1 | 0] = 5; 1119 break block44; 1120 } 1121 HEAP8[$0_1 + 1 | 0] = 6; 1122 break block44; 1123 } 1124 HEAP8[$0_1 + 1 | 0] = 7; 1125 break block44; 1126 } 1127 HEAP8[$0_1 + 1 | 0] = 8; 1128 break block44; 1129 } 1130 HEAP8[$0_1 + 1 | 0] = 9; 1131 break block44; 1132 } 1133 HEAP8[$0_1 + 1 | 0] = 10; 1134 break block44; 1135 } 1136 HEAP8[$0_1 + 1 | 0] = 11; 1137 break block44; 1138 } 1139 HEAP8[$0_1 + 1 | 0] = 12; 1140 break block44; 1141 } 1142 HEAP8[$0_1 + 1 | 0] = 13; 1143 break block44; 1144 } 1145 HEAP8[$0_1 + 1 | 0] = 14; 1146 break block44; 1147 } 1148 HEAP8[$0_1 + 1 | 0] = 15; 1149 break block44; 1150 } 1151 HEAP8[$0_1 + 1 | 0] = 16; 1152 break block44; 1153 } 1154 HEAP8[$0_1 + 1 | 0] = 17; 1155 break block44; 1156 } 1157 HEAP8[$0_1 + 1 | 0] = 18; 1158 break block44; 1159 } 1160 HEAP8[$0_1 + 1 | 0] = 19; 1161 break block44; 1162 } 1163 HEAP8[$0_1 + 1 | 0] = 20; 1164 break block44; 1165 } 1166 HEAP8[$0_1 + 1 | 0] = 21; 1167 break block44; 1168 } 1169 HEAP8[$0_1 + 1 | 0] = 22; 1170 break block44; 1171 } 1172 HEAP8[$0_1 + 1 | 0] = 23; 1173 break block44; 1174 } 1175 HEAP8[$0_1 + 1 | 0] = 24; 1176 break block44; 1177 } 1178 HEAP8[$0_1 + 1 | 0] = 25; 1179 break block44; 1180 } 1181 HEAP8[$0_1 + 1 | 0] = 26; 1182 break block44; 1183 } 1184 HEAP8[$0_1 + 1 | 0] = 27; 1185 break block44; 1186 } 1187 HEAP8[$0_1 + 1 | 0] = 28; 1188 break block44; 1189 } 1190 HEAP8[$0_1 + 1 | 0] = 29; 1191 break block44; 1192 } 1193 HEAP8[$0_1 + 1 | 0] = 30; 1194 break block44; 1195 } 1196 HEAP8[$0_1 + 1 | 0] = 31; 1197 break block44; 1198 } 1199 HEAP8[$0_1 + 1 | 0] = 32; 1200 } 1201 $1_1 = 0; 1202 } 1203 HEAP8[$0_1 | 0] = $1_1; 1204 global$0 = $8_1 + 16 | 0; 1205 break block45; 1206 } 1207 $4_1 = HEAPU8[$1_1 + 24 | 0] - 1 | 0; 1208 HEAP8[$1_1 + 24 | 0] = $4_1; 1209 block93 : { 1210 if ($4_1 & 255) { 1211 HEAP32[$1_1 + 20 >> 2] = $2_1 + 1; 1212 $6_1 = global$0 - 16 | 0; 1213 global$0 = $6_1; 1214 $4_1 = $6_1 + 8 | 0; 1215 $2_1 = global$0 - 48 | 0; 1216 global$0 = $2_1; 1217 $3_1 = HEAP32[$1_1 + 20 >> 2]; 1218 $10_1 = HEAP32[$1_1 + 16 >> 2]; 1219 block51 : { 1220 if ($3_1 >>> 0 < $10_1 >>> 0) { 1221 $9_1 = $1_1 + 12 | 0; 1222 $11_1 = HEAP32[$1_1 + 12 >> 2]; 1223 while (1) { 1224 block47 : { 1225 block54 : { 1226 block53 : { 1227 block52 : { 1228 block50 : { 1229 block48 : { 1230 $7_1 = HEAPU8[$3_1 + $11_1 | 0]; 1231 block46 : { 1232 if ($7_1 >>> 0 <= 12) { 1233 if ($7_1 - 9 >>> 0 >= 2) { 1234 break block46 1235 } 1236 break block47; 1237 } 1238 block49 : { 1239 switch ($7_1 - 32 | 0) { 1240 case 1: 1241 break block46; 1242 case 0: 1243 break block47; 1244 case 2: 1245 break block48; 1246 default: 1247 break block49; 1248 }; 1249 } 1250 if (($7_1 | 0) == 13) { 1251 break block47 1252 } 1253 if (($7_1 | 0) == 125) { 1254 break block50 1255 } 1256 } 1257 HEAP32[$2_1 + 36 >> 2] = 17; 1258 $71($2_1, $9_1); 1259 $3_1 = $55($2_1 + 36 | 0, HEAP32[$2_1 >> 2], HEAP32[$2_1 + 4 >> 2]); 1260 HEAP8[$4_1 | 0] = 255; 1261 HEAP32[$4_1 + 4 >> 2] = $3_1; 1262 break block51; 1263 } 1264 HEAP32[$1_1 + 8 >> 2] = 0; 1265 HEAP32[$1_1 + 20 >> 2] = $3_1 + 1; 1266 $73($2_1 + 36 | 0, $9_1, $1_1); 1267 $3_1 = HEAP32[$2_1 + 40 >> 2]; 1268 if (HEAP32[$2_1 + 36 >> 2] != 2) { 1269 break block52 1270 } 1271 HEAP32[$2_1 + 32 >> 2] = $3_1; 1272 break block53; 1273 } 1274 HEAP32[$2_1 + 36 >> 2] = 10; 1275 $71($2_1 + 16 | 0, $9_1); 1276 $3_1 = $55($2_1 + 36 | 0, HEAP32[$2_1 + 16 >> 2], HEAP32[$2_1 + 20 >> 2]); 1277 HEAP8[$4_1 | 0] = 255; 1278 HEAP32[$4_1 + 4 >> 2] = $3_1; 1279 break block51; 1280 } 1281 $10($2_1 + 28 | 0, $3_1, HEAP32[$2_1 + 44 >> 2]); 1282 if (!HEAPU8[$2_1 + 28 | 0]) { 1283 break block54 1284 } 1285 } 1286 $3_1 = $0(HEAP32[$2_1 + 32 >> 2], $1_1); 1287 HEAP8[$4_1 | 0] = 255; 1288 HEAP32[$4_1 + 4 >> 2] = $3_1; 1289 break block51; 1290 } 1291 $3_1 = HEAPU8[$2_1 + 29 | 0]; 1292 $7_1 = $17($1_1); 1293 if ($7_1) { 1294 HEAP8[$4_1 | 0] = 255; 1295 HEAP32[$4_1 + 4 >> 2] = $7_1; 1296 break block51; 1297 } 1298 HEAP32[$4_1 + 4 >> 2] = $1_1; 1299 HEAP8[$4_1 | 0] = $3_1; 1300 break block51; 1301 } 1302 $3_1 = $3_1 + 1 | 0; 1303 HEAP32[$1_1 + 20 >> 2] = $3_1; 1304 if (($3_1 | 0) != ($10_1 | 0)) { 1305 continue 1306 } 1307 break; 1308 }; 1309 } 1310 HEAP32[$2_1 + 36 >> 2] = 3; 1311 $71($2_1 + 8 | 0, $1_1 + 12 | 0); 1312 $3_1 = $55($2_1 + 36 | 0, HEAP32[$2_1 + 8 >> 2], HEAP32[$2_1 + 12 >> 2]); 1313 HEAP8[$4_1 | 0] = 255; 1314 HEAP32[$4_1 + 4 >> 2] = $3_1; 1315 } 1316 global$0 = $2_1 + 48 | 0; 1317 $2_1 = HEAP32[$6_1 + 12 >> 2]; 1318 block89 : { 1319 block90 : { 1320 block91 : { 1321 block92 : { 1322 block87 : { 1323 switch (HEAPU8[$6_1 + 8 | 0]) { 1324 default: 1325 HEAP32[$0_1 + 4 >> 2] = $2_1; 1326 $4_1 = 1; 1327 break block89; 1328 case 0: 1329 $2_1 = $11($2_1); 1330 if (!$2_1) { 1331 break block90 1332 } 1333 break block91; 1334 case 1: 1335 $2_1 = $11($2_1); 1336 if ($2_1) { 1337 break block91 1338 } 1339 HEAP8[$0_1 + 1 | 0] = 1; 1340 break block92; 1341 case 2: 1342 $2_1 = $11($2_1); 1343 if ($2_1) { 1344 break block91 1345 } 1346 HEAP8[$0_1 + 1 | 0] = 2; 1347 break block92; 1348 case 3: 1349 $2_1 = $11($2_1); 1350 if ($2_1) { 1351 break block91 1352 } 1353 HEAP8[$0_1 + 1 | 0] = 3; 1354 break block92; 1355 case 4: 1356 $2_1 = $11($2_1); 1357 if ($2_1) { 1358 break block91 1359 } 1360 HEAP8[$0_1 + 1 | 0] = 4; 1361 break block92; 1362 case 5: 1363 $2_1 = $11($2_1); 1364 if ($2_1) { 1365 break block91 1366 } 1367 HEAP8[$0_1 + 1 | 0] = 5; 1368 break block92; 1369 case 6: 1370 $2_1 = $11($2_1); 1371 if ($2_1) { 1372 break block91 1373 } 1374 HEAP8[$0_1 + 1 | 0] = 6; 1375 break block92; 1376 case 7: 1377 $2_1 = $11($2_1); 1378 if ($2_1) { 1379 break block91 1380 } 1381 HEAP8[$0_1 + 1 | 0] = 7; 1382 break block92; 1383 case 8: 1384 $2_1 = $11($2_1); 1385 if ($2_1) { 1386 break block91 1387 } 1388 HEAP8[$0_1 + 1 | 0] = 8; 1389 break block92; 1390 case 9: 1391 $2_1 = $11($2_1); 1392 if ($2_1) { 1393 break block91 1394 } 1395 HEAP8[$0_1 + 1 | 0] = 9; 1396 break block92; 1397 case 10: 1398 $2_1 = $11($2_1); 1399 if ($2_1) { 1400 break block91 1401 } 1402 HEAP8[$0_1 + 1 | 0] = 10; 1403 break block92; 1404 case 11: 1405 $2_1 = $11($2_1); 1406 if ($2_1) { 1407 break block91 1408 } 1409 HEAP8[$0_1 + 1 | 0] = 11; 1410 break block92; 1411 case 12: 1412 $2_1 = $11($2_1); 1413 if ($2_1) { 1414 break block91 1415 } 1416 HEAP8[$0_1 + 1 | 0] = 12; 1417 break block92; 1418 case 13: 1419 $2_1 = $11($2_1); 1420 if ($2_1) { 1421 break block91 1422 } 1423 HEAP8[$0_1 + 1 | 0] = 13; 1424 break block92; 1425 case 14: 1426 $2_1 = $11($2_1); 1427 if ($2_1) { 1428 break block91 1429 } 1430 HEAP8[$0_1 + 1 | 0] = 14; 1431 break block92; 1432 case 15: 1433 $2_1 = $11($2_1); 1434 if ($2_1) { 1435 break block91 1436 } 1437 HEAP8[$0_1 + 1 | 0] = 15; 1438 break block92; 1439 case 16: 1440 $2_1 = $11($2_1); 1441 if ($2_1) { 1442 break block91 1443 } 1444 HEAP8[$0_1 + 1 | 0] = 16; 1445 break block92; 1446 case 17: 1447 $2_1 = $11($2_1); 1448 if ($2_1) { 1449 break block91 1450 } 1451 HEAP8[$0_1 + 1 | 0] = 17; 1452 break block92; 1453 case 18: 1454 $2_1 = $11($2_1); 1455 if ($2_1) { 1456 break block91 1457 } 1458 HEAP8[$0_1 + 1 | 0] = 18; 1459 break block92; 1460 case 19: 1461 $2_1 = $11($2_1); 1462 if ($2_1) { 1463 break block91 1464 } 1465 HEAP8[$0_1 + 1 | 0] = 19; 1466 break block92; 1467 case 20: 1468 $2_1 = $11($2_1); 1469 if ($2_1) { 1470 break block91 1471 } 1472 HEAP8[$0_1 + 1 | 0] = 20; 1473 break block92; 1474 case 21: 1475 $2_1 = $11($2_1); 1476 if ($2_1) { 1477 break block91 1478 } 1479 HEAP8[$0_1 + 1 | 0] = 21; 1480 break block92; 1481 case 22: 1482 $2_1 = $11($2_1); 1483 if ($2_1) { 1484 break block91 1485 } 1486 HEAP8[$0_1 + 1 | 0] = 22; 1487 break block92; 1488 case 23: 1489 $2_1 = $11($2_1); 1490 if ($2_1) { 1491 break block91 1492 } 1493 HEAP8[$0_1 + 1 | 0] = 23; 1494 break block92; 1495 case 24: 1496 $2_1 = $11($2_1); 1497 if ($2_1) { 1498 break block91 1499 } 1500 HEAP8[$0_1 + 1 | 0] = 24; 1501 break block92; 1502 case 25: 1503 $2_1 = $11($2_1); 1504 if ($2_1) { 1505 break block91 1506 } 1507 HEAP8[$0_1 + 1 | 0] = 25; 1508 break block92; 1509 case 26: 1510 $2_1 = $11($2_1); 1511 if ($2_1) { 1512 break block91 1513 } 1514 HEAP8[$0_1 + 1 | 0] = 26; 1515 break block92; 1516 case 27: 1517 $2_1 = $11($2_1); 1518 if ($2_1) { 1519 break block91 1520 } 1521 HEAP8[$0_1 + 1 | 0] = 27; 1522 break block92; 1523 case 28: 1524 $2_1 = $11($2_1); 1525 if ($2_1) { 1526 break block91 1527 } 1528 HEAP8[$0_1 + 1 | 0] = 28; 1529 break block92; 1530 case 29: 1531 $2_1 = $11($2_1); 1532 if ($2_1) { 1533 break block91 1534 } 1535 HEAP8[$0_1 + 1 | 0] = 29; 1536 break block92; 1537 case 30: 1538 $2_1 = $11($2_1); 1539 if ($2_1) { 1540 break block91 1541 } 1542 HEAP8[$0_1 + 1 | 0] = 30; 1543 break block92; 1544 case 31: 1545 $2_1 = $11($2_1); 1546 if ($2_1) { 1547 break block91 1548 } 1549 HEAP8[$0_1 + 1 | 0] = 31; 1550 break block92; 1551 case 32: 1552 break block87; 1553 }; 1554 } 1555 $2_1 = $11($2_1); 1556 if ($2_1) { 1557 break block91 1558 } 1559 HEAP8[$0_1 + 1 | 0] = 32; 1560 } 1561 $4_1 = 0; 1562 break block89; 1563 } 1564 HEAP32[$0_1 + 4 >> 2] = $2_1; 1565 $4_1 = 1; 1566 break block89; 1567 } 1568 HEAP8[$0_1 + 1 | 0] = 0; 1569 $4_1 = 0; 1570 } 1571 HEAP8[$0_1 | 0] = $4_1; 1572 global$0 = $6_1 + 16 | 0; 1573 HEAP8[$1_1 + 24 | 0] = HEAPU8[$1_1 + 24 | 0] + 1; 1574 if (HEAPU8[$0_1 | 0]) { 1575 break block45 1576 } 1577 $2_1 = HEAP32[$1_1 + 20 >> 2]; 1578 $4_1 = HEAP32[$1_1 + 16 >> 2]; 1579 if ($2_1 >>> 0 < $4_1 >>> 0) { 1580 $3_1 = HEAP32[$8_1 >> 2]; 1581 while (1) { 1582 $6_1 = HEAPU8[$2_1 + $3_1 | 0]; 1583 $7_1 = $6_1 - 9 | 0; 1584 if ($7_1 >>> 0 > 23 | !(1 << $7_1 & 8388627)) { 1585 break block93 1586 } 1587 $2_1 = $2_1 + 1 | 0; 1588 HEAP32[$1_1 + 20 >> 2] = $2_1; 1589 if (($2_1 | 0) != ($4_1 | 0)) { 1590 continue 1591 } 1592 break; 1593 }; 1594 } 1595 HEAP32[$5_1 + 52 >> 2] = 3; 1596 $72($5_1 + 40 | 0, $8_1); 1597 $1_1 = $55($5_1 + 52 | 0, HEAP32[$5_1 + 40 >> 2], HEAP32[$5_1 + 44 >> 2]); 1598 HEAP8[$0_1 | 0] = 1; 1599 HEAP32[$0_1 + 4 >> 2] = $1_1; 1600 break block45; 1601 } 1602 HEAP32[$5_1 + 52 >> 2] = 24; 1603 $71($5_1 + 24 | 0, $8_1); 1604 $1_1 = $55($5_1 + 52 | 0, HEAP32[$5_1 + 24 >> 2], HEAP32[$5_1 + 28 >> 2]); 1605 HEAP8[$0_1 | 0] = 1; 1606 HEAP32[$0_1 + 4 >> 2] = $1_1; 1607 break block45; 1608 } 1609 if (($6_1 | 0) == 125) { 1610 HEAP8[$0_1 | 0] = 0; 1611 HEAP32[$1_1 + 20 >> 2] = $2_1 + 1; 1612 break block45; 1613 } 1614 HEAP32[$5_1 + 52 >> 2] = 10; 1615 $72($5_1 + 32 | 0, $8_1); 1616 $1_1 = $55($5_1 + 52 | 0, HEAP32[$5_1 + 32 >> 2], HEAP32[$5_1 + 36 >> 2]); 1617 HEAP8[$0_1 | 0] = 1; 1618 HEAP32[$0_1 + 4 >> 2] = $1_1; 1619 break block45; 1620 } 1621 $2_1 = $2_1 + 1 | 0; 1622 HEAP32[$1_1 + 20 >> 2] = $2_1; 1623 if (($2_1 | 0) != ($3_1 | 0)) { 1624 continue 1625 } 1626 break; 1627 }; 1628 } 1629 HEAP32[$5_1 + 52 >> 2] = 5; 1630 $71($5_1 + 16 | 0, $1_1 + 12 | 0); 1631 $1_1 = $55($5_1 + 52 | 0, HEAP32[$5_1 + 16 >> 2], HEAP32[$5_1 + 20 >> 2]); 1632 } 1633 HEAP8[$0_1 | 0] = 1; 1634 HEAP32[$0_1 + 4 >> 2] = $1_1; 1635 } 1636 global$0 = $5_1 - -64 | 0; 1637 } 1638 1639 function $10($0_1, $1_1, $2_1) { 1640 var $3_1 = 0, $4_1 = 0, $5_1 = 0, $6_1 = 0, $7_1 = 0; 1641 $7_1 = $0_1; 1642 block33 : { 1643 block16 : { 1644 block13 : { 1645 block18 : { 1646 block27 : { 1647 block20 : { 1648 block14 : { 1649 block32 : { 1650 block22 : { 1651 block30 : { 1652 block24 : { 1653 block28 : { 1654 block26 : { 1655 block31 : { 1656 block2 : { 1657 block12 : { 1658 block29 : { 1659 block25 : { 1660 block17 : { 1661 block7 : { 1662 block23 : { 1663 block11 : { 1664 block10 : { 1665 block21 : { 1666 block19 : { 1667 block1 : { 1668 block15 : { 1669 block8 : { 1670 switch ($2_1 - 4 | 0) { 1671 case 12: 1672 $4_1 = $1_1 + 8 | 0; 1673 $3_1 = $4_1; 1674 if ((HEAPU8[$1_1 | 0] | HEAPU8[$1_1 + 1 | 0] << 8 | (HEAPU8[$1_1 + 2 | 0] << 16 | HEAPU8[$1_1 + 3 | 0] << 24)) ^ 1836213584 | (HEAPU8[$3_1 | 0] | HEAPU8[$3_1 + 1 | 0] << 8 | (HEAPU8[$3_1 + 2 | 0] << 16 | HEAPU8[$3_1 + 3 | 0] << 24)) ^ 1698983535 | ((HEAPU8[$1_1 + 4 | 0] | HEAPU8[$1_1 + 5 | 0] << 8 | (HEAPU8[$1_1 + 6 | 0] << 16 | HEAPU8[$1_1 + 7 | 0] << 24)) ^ 1769173865 | (HEAPU8[$3_1 + 4 | 0] | HEAPU8[$3_1 + 5 | 0] << 8 | (HEAPU8[$3_1 + 6 | 0] << 16 | HEAPU8[$3_1 + 7 | 0] << 24)) ^ 1684367726)) { 1675 if ((HEAPU8[$1_1 | 0] | HEAPU8[$1_1 + 1 | 0] << 8 | (HEAPU8[$1_1 + 2 | 0] << 16 | HEAPU8[$1_1 + 3 | 0] << 24)) ^ 1919251285 | (HEAPU8[$3_1 | 0] | HEAPU8[$3_1 + 1 | 0] << 8 | (HEAPU8[$3_1 + 2 | 0] << 16 | HEAPU8[$3_1 + 3 | 0] << 24)) ^ 1968403568 | ((HEAPU8[$1_1 + 4 | 0] | HEAPU8[$1_1 + 5 | 0] << 8 | (HEAPU8[$1_1 + 6 | 0] << 16 | HEAPU8[$1_1 + 7 | 0] << 24)) ^ 1836020304 | (HEAPU8[$3_1 + 4 | 0] | HEAPU8[$3_1 + 5 | 0] << 8 | (HEAPU8[$3_1 + 6 | 0] << 16 | HEAPU8[$3_1 + 7 | 0] << 24)) ^ 1953066338)) { 1676 break block2 1677 } 1678 HEAP8[$0_1 + 1 | 0] = 6; 1679 break block13; 1680 } 1681 HEAP8[$0_1 + 1 | 0] = 4; 1682 break block13; 1683 case 8: 1684 $4_1 = $1_1 + 8 | 0; 1685 if (!((HEAPU8[$1_1 | 0] | HEAPU8[$1_1 + 1 | 0] << 8 | (HEAPU8[$1_1 + 2 | 0] << 16 | HEAPU8[$1_1 + 3 | 0] << 24)) ^ 1769238350 | (HEAPU8[$4_1 | 0] | HEAPU8[$4_1 + 1 | 0] << 8 | (HEAPU8[$4_1 + 2 | 0] << 16 | HEAPU8[$4_1 + 3 | 0] << 24)) ^ 1852795252 | (HEAPU8[$1_1 + 4 | 0] | HEAPU8[$1_1 + 5 | 0] << 8 | (HEAPU8[$1_1 + 6 | 0] << 16 | HEAPU8[$1_1 + 7 | 0] << 24)) ^ 1633904998)) { 1686 break block14 1687 } 1688 $3_1 = $4_1; 1689 if ((HEAPU8[$1_1 | 0] | HEAPU8[$1_1 + 1 | 0] << 8 | (HEAPU8[$1_1 + 2 | 0] << 16 | HEAPU8[$1_1 + 3 | 0] << 24)) ^ 1936942419 | (HEAPU8[$3_1 | 0] | HEAPU8[$3_1 + 1 | 0] << 8 | (HEAPU8[$3_1 + 2 | 0] << 16 | HEAPU8[$3_1 + 3 | 0] << 24)) ^ 1953653108 | (HEAPU8[$1_1 + 4 | 0] | HEAPU8[$1_1 + 5 | 0] << 8 | (HEAPU8[$1_1 + 6 | 0] << 16 | HEAPU8[$1_1 + 7 | 0] << 24)) ^ 1399746409) { 1690 break block15 1691 } 1692 HEAP8[$0_1 + 1 | 0] = 8; 1693 break block13; 1694 case 6: 1695 $4_1 = $1_1 + 8 | 0; 1696 if (!((HEAPU8[$1_1 | 0] | HEAPU8[$1_1 + 1 | 0] << 8 | (HEAPU8[$1_1 + 2 | 0] << 16 | HEAPU8[$1_1 + 3 | 0] << 24)) ^ 1415934544 | (HEAPU8[$4_1 | 0] | HEAPU8[$4_1 + 1 | 0] << 8) ^ 25971 | (HEAPU8[$1_1 + 4 | 0] | HEAPU8[$1_1 + 5 | 0] << 8 | (HEAPU8[$1_1 + 6 | 0] << 16 | HEAPU8[$1_1 + 7 | 0] << 24)) ^ 1433169775)) { 1697 break block16 1698 } 1699 $3_1 = $4_1; 1700 if ((HEAPU8[$1_1 | 0] | HEAPU8[$1_1 + 1 | 0] << 8 | (HEAPU8[$1_1 + 2 | 0] << 16 | HEAPU8[$1_1 + 3 | 0] << 24)) ^ 1936942419 | (HEAPU8[$3_1 | 0] | HEAPU8[$3_1 + 1 | 0] << 8) ^ 25710 | (HEAPU8[$1_1 + 4 | 0] | HEAPU8[$1_1 + 5 | 0] << 8 | (HEAPU8[$1_1 + 6 | 0] << 16 | HEAPU8[$1_1 + 7 | 0] << 24)) ^ 1164865385) { 1701 break block17 1702 } 1703 HEAP8[$0_1 + 1 | 0] = 9; 1704 break block13; 1705 case 7: 1706 $3_1 = $1_1 + 3 | 0; 1707 if (!((HEAPU8[$1_1 | 0] | HEAPU8[$1_1 + 1 | 0] << 8 | (HEAPU8[$1_1 + 2 | 0] << 16 | HEAPU8[$1_1 + 3 | 0] << 24)) ^ 1953722192 | (HEAPU8[$3_1 | 0] | HEAPU8[$3_1 + 1 | 0] << 8 | (HEAPU8[$3_1 + 2 | 0] << 16 | HEAPU8[$3_1 + 3 | 0] << 24)) ^ 1869567092 | ((HEAPU8[$1_1 + 4 | 0] | HEAPU8[$1_1 + 5 | 0] << 8 | (HEAPU8[$1_1 + 6 | 0] << 16 | HEAPU8[$1_1 + 7 | 0] << 24)) ^ 1819242324 | (HEAPU8[$3_1 + 4 | 0] | HEAPU8[$3_1 + 5 | 0] << 8 | (HEAPU8[$3_1 + 6 | 0] << 16 | HEAPU8[$3_1 + 7 | 0] << 24)) ^ 1702057324))) { 1708 break block18 1709 } 1710 if ($168($1_1, 1051848, $2_1)) { 1711 break block19 1712 } 1713 HEAP8[$0_1 + 1 | 0] = 11; 1714 break block13; 1715 case 0: 1716 if ((HEAPU8[$1_1 | 0] | HEAPU8[$1_1 + 1 | 0] << 8 | (HEAPU8[$1_1 + 2 | 0] << 16 | HEAPU8[$1_1 + 3 | 0] << 24)) != 1886352467) { 1717 break block2 1718 } 1719 HEAP8[$0_1 + 1 | 0] = 10; 1720 break block13; 1721 case 9: 1722 $4_1 = $1_1 + 5 | 0; 1723 $3_1 = $4_1; 1724 if (!((HEAPU8[$1_1 | 0] | HEAPU8[$1_1 + 1 | 0] << 8 | (HEAPU8[$1_1 + 2 | 0] << 16 | HEAPU8[$1_1 + 3 | 0] << 24)) ^ 1953722192 | (HEAPU8[$3_1 | 0] | HEAPU8[$3_1 + 1 | 0] << 8 | (HEAPU8[$3_1 + 2 | 0] << 16 | HEAPU8[$3_1 + 3 | 0] << 24)) ^ 1114402671 | ((HEAPU8[$1_1 + 4 | 0] | HEAPU8[$1_1 + 5 | 0] << 8 | (HEAPU8[$1_1 + 6 | 0] << 16 | HEAPU8[$1_1 + 7 | 0] << 24)) ^ 1819242324 | (HEAPU8[$3_1 + 4 | 0] | HEAPU8[$3_1 + 5 | 0] << 8 | (HEAPU8[$3_1 + 6 | 0] << 16 | HEAPU8[$3_1 + 7 | 0] << 24)) ^ 1751348321))) { 1725 break block20 1726 } 1727 if ((HEAPU8[$1_1 | 0] | HEAPU8[$1_1 + 1 | 0] << 8 | (HEAPU8[$1_1 + 2 | 0] << 16 | HEAPU8[$1_1 + 3 | 0] << 24)) ^ 1633842515 | (HEAPU8[$3_1 | 0] | HEAPU8[$3_1 + 1 | 0] << 8 | (HEAPU8[$3_1 + 2 | 0] << 16 | HEAPU8[$3_1 + 3 | 0] << 24)) ^ 1400139365 | ((HEAPU8[$3_1 + 4 | 0] | HEAPU8[$3_1 + 5 | 0] << 8 | (HEAPU8[$3_1 + 6 | 0] << 16 | HEAPU8[$3_1 + 7 | 0] << 24)) ^ 1953653108 | (HEAPU8[$1_1 + 4 | 0] | HEAPU8[$1_1 + 5 | 0] << 8 | (HEAPU8[$1_1 + 6 | 0] << 16 | HEAPU8[$1_1 + 7 | 0] << 24)) ^ 1953391975)) { 1728 break block21 1729 } 1730 HEAP8[$0_1 + 1 | 0] = 12; 1731 break block13; 1732 case 1: 1733 break block1; 1734 case 13: 1735 break block10; 1736 case 14: 1737 break block11; 1738 case 15: 1739 break block12; 1740 case 10: 1741 break block7; 1742 case 11: 1743 break block8; 1744 default: 1745 break block2; 1746 }; 1747 } 1748 $3_1 = $1_1 + 7 | 0; 1749 if ((HEAPU8[$1_1 | 0] | HEAPU8[$1_1 + 1 | 0] << 8 | (HEAPU8[$1_1 + 2 | 0] << 16 | HEAPU8[$1_1 + 3 | 0] << 24)) ^ 1953722192 | (HEAPU8[$3_1 | 0] | HEAPU8[$3_1 + 1 | 0] << 8 | (HEAPU8[$3_1 + 2 | 0] << 16 | HEAPU8[$3_1 + 3 | 0] << 24)) ^ 2001955941 | ((HEAPU8[$1_1 + 4 | 0] | HEAPU8[$1_1 + 5 | 0] << 8 | (HEAPU8[$1_1 + 6 | 0] << 16 | HEAPU8[$1_1 + 7 | 0] << 24)) ^ 1701080909 | (HEAPU8[$3_1 + 4 | 0] | HEAPU8[$3_1 + 5 | 0] << 8 | (HEAPU8[$3_1 + 6 | 0] << 16 | HEAPU8[$3_1 + 7 | 0] << 24)) ^ 1751348329)) { 1750 break block2 1751 } 1752 HEAP8[$0_1 + 1 | 0] = 17; 1753 break block13; 1754 } 1755 if (!$168($1_1, 1051872, $2_1)) { 1756 break block22 1757 } 1758 if ($168($1_1, 1051956, $2_1)) { 1759 break block23 1760 } 1761 HEAP8[$0_1 + 1 | 0] = 20; 1762 break block13; 1763 } 1764 if ((HEAPU8[$1_1 | 0] | HEAPU8[$1_1 + 1 | 0] << 8 | (HEAPU8[$1_1 + 2 | 0] << 16 | HEAPU8[$1_1 + 3 | 0] << 24)) ^ 1970562387 | HEAPU8[$1_1 + 4 | 0] ^ 112) { 1765 break block2 1766 } 1767 HEAP8[$0_1 + 1 | 0] = 19; 1768 break block13; 1769 } 1770 if (!$168($1_1, 1051894, $2_1)) { 1771 break block24 1772 } 1773 if ($168($1_1, 1051968, $2_1)) { 1774 break block25 1775 } 1776 HEAP8[$0_1 + 1 | 0] = 21; 1777 break block13; 1778 } 1779 if ($168($1_1, 1051979, $2_1)) { 1780 break block2 1781 } 1782 HEAP8[$0_1 + 1 | 0] = 22; 1783 break block13; 1784 } 1785 $3_1 = $1_1 + 8 | 0; 1786 $4_1 = (HEAPU8[$1_1 | 0] | HEAPU8[$1_1 + 1 | 0] << 8 | (HEAPU8[$1_1 + 2 | 0] << 16 | HEAPU8[$1_1 + 3 | 0] << 24)) ^ 1836213584 | (HEAPU8[$3_1 | 0] | HEAPU8[$3_1 + 1 | 0] << 8 | (HEAPU8[$3_1 + 2 | 0] << 16 | HEAPU8[$3_1 + 3 | 0] << 24)) ^ 1699901039; 1787 $3_1 = (HEAPU8[$1_1 + 4 | 0] | HEAPU8[$1_1 + 5 | 0] << 8 | (HEAPU8[$1_1 + 6 | 0] << 16 | HEAPU8[$1_1 + 7 | 0] << 24)) ^ 1769173865 | (HEAPU8[$3_1 + 4 | 0] | HEAPU8[$3_1 + 5 | 0] << 8 | (HEAPU8[$3_1 + 6 | 0] << 16 | HEAPU8[$3_1 + 7 | 0] << 24)) ^ 1936029041; 1788 if (!($3_1 | (HEAPU8[$1_1 + 16 | 0] ^ 116 | $4_1))) { 1789 break block26 1790 } 1791 if ($168($1_1, 1052003, $2_1)) { 1792 break block2 1793 } 1794 HEAP8[$0_1 + 1 | 0] = 24; 1795 break block13; 1796 } 1797 $3_1 = $1_1 + 8 | 0; 1798 $4_1 = (HEAPU8[$1_1 | 0] | HEAPU8[$1_1 + 1 | 0] << 8 | (HEAPU8[$1_1 + 2 | 0] << 16 | HEAPU8[$1_1 + 3 | 0] << 24)) ^ 1953722192 | (HEAPU8[$3_1 | 0] | HEAPU8[$3_1 + 1 | 0] << 8 | (HEAPU8[$3_1 + 2 | 0] << 16 | HEAPU8[$3_1 + 3 | 0] << 24)) ^ 1181053781; 1799 $3_1 = (HEAPU8[$3_1 + 4 | 0] | HEAPU8[$3_1 + 5 | 0] << 8 | (HEAPU8[$3_1 + 6 | 0] << 16 | HEAPU8[$3_1 + 7 | 0] << 24)) ^ 1970039137 | (HEAPU8[$1_1 + 4 | 0] | HEAPU8[$1_1 + 5 | 0] << 8 | (HEAPU8[$1_1 + 6 | 0] << 16 | HEAPU8[$1_1 + 7 | 0] << 24)) ^ 1819242324; 1800 $5_1 = $1_1 + 16 | 0; 1801 if (!($3_1 | ((HEAPU8[$5_1 | 0] | HEAPU8[$5_1 + 1 | 0] << 8) ^ 25970 | $4_1))) { 1802 break block27 1803 } 1804 if ($168($1_1, 1052032, $2_1)) { 1805 break block2 1806 } 1807 HEAP8[$0_1 + 1 | 0] = 26; 1808 break block13; 1809 } 1810 if ($168($1_1, 1052020, $2_1)) { 1811 break block2 1812 } 1813 HEAP8[$0_1 + 1 | 0] = 25; 1814 break block13; 1815 } 1816 $4_1 = $1_1 + 6 | 0; 1817 $3_1 = $4_1; 1818 if (!((HEAPU8[$1_1 | 0] | HEAPU8[$1_1 + 1 | 0] << 8 | (HEAPU8[$1_1 + 2 | 0] << 16 | HEAPU8[$1_1 + 3 | 0] << 24)) ^ 1298494032 | (HEAPU8[$3_1 | 0] | HEAPU8[$3_1 + 1 | 0] << 8 | (HEAPU8[$3_1 + 2 | 0] << 16 | HEAPU8[$3_1 + 3 | 0] << 24)) ^ 2001955941 | ((HEAPU8[$1_1 + 4 | 0] | HEAPU8[$1_1 + 5 | 0] << 8 | (HEAPU8[$1_1 + 6 | 0] << 16 | HEAPU8[$1_1 + 7 | 0] << 24)) ^ 1818584175 | (HEAPU8[$3_1 + 4 | 0] | HEAPU8[$3_1 + 5 | 0] << 8 | (HEAPU8[$3_1 + 6 | 0] << 16 | HEAPU8[$3_1 + 7 | 0] << 24)) ^ 1751348329))) { 1819 break block28 1820 } 1821 $6_1 = (HEAPU8[$1_1 | 0] | HEAPU8[$1_1 + 1 | 0] << 8 | (HEAPU8[$1_1 + 2 | 0] << 16 | HEAPU8[$1_1 + 3 | 0] << 24)) ^ 1802661719; 1822 $5_1 = (HEAPU8[$1_1 + 4 | 0] | HEAPU8[$1_1 + 5 | 0] << 8 | (HEAPU8[$1_1 + 6 | 0] << 16 | HEAPU8[$1_1 + 7 | 0] << 24)) ^ 1701147252; 1823 if ($6_1 | (HEAPU8[$3_1 | 0] | HEAPU8[$3_1 + 1 | 0] << 8 | (HEAPU8[$3_1 + 2 | 0] << 16 | HEAPU8[$3_1 + 3 | 0] << 24)) ^ 1917019493 | ($5_1 | (HEAPU8[$3_1 + 4 | 0] | HEAPU8[$3_1 + 5 | 0] << 8 | (HEAPU8[$3_1 + 6 | 0] << 16 | HEAPU8[$3_1 + 7 | 0] << 24)) ^ 1702125925)) { 1824 if ($6_1 | (HEAPU8[$3_1 | 0] | HEAPU8[$3_1 + 1 | 0] << 8 | (HEAPU8[$3_1 + 2 | 0] << 16 | HEAPU8[$3_1 + 3 | 0] << 24)) ^ 1699898725 | ($5_1 | (HEAPU8[$3_1 + 4 | 0] | HEAPU8[$3_1 + 5 | 0] << 8 | (HEAPU8[$3_1 + 6 | 0] << 16 | HEAPU8[$3_1 + 7 | 0] << 24)) ^ 1702260589)) { 1825 break block29 1826 } 1827 HEAP8[$0_1 + 1 | 0] = 28; 1828 break block13; 1829 } 1830 HEAP8[$0_1 + 1 | 0] = 27; 1831 break block13; 1832 } 1833 $4_1 = $1_1 + 8 | 0; 1834 if (!((HEAPU8[$1_1 | 0] | HEAPU8[$1_1 + 1 | 0] << 8 | (HEAPU8[$1_1 + 2 | 0] << 16 | HEAPU8[$1_1 + 3 | 0] << 24)) ^ 1130721872 | (HEAPU8[$4_1 | 0] | HEAPU8[$4_1 + 1 | 0] << 8) ^ 29795 | (HEAPU8[$1_1 + 4 | 0] | HEAPU8[$1_1 + 5 | 0] << 8 | (HEAPU8[$1_1 + 6 | 0] << 16 | HEAPU8[$1_1 + 7 | 0] << 24)) ^ 1634757999)) { 1835 break block30 1836 } 1837 $3_1 = $4_1; 1838 if ((HEAPU8[$1_1 | 0] | HEAPU8[$1_1 + 1 | 0] << 8 | (HEAPU8[$1_1 + 2 | 0] << 16 | HEAPU8[$1_1 + 3 | 0] << 24)) ^ 1130657603 | (HEAPU8[$3_1 | 0] | HEAPU8[$3_1 + 1 | 0] << 8) ^ 25701 | (HEAPU8[$1_1 + 4 | 0] | HEAPU8[$1_1 + 5 | 0] << 8 | (HEAPU8[$1_1 + 6 | 0] << 16 | HEAPU8[$1_1 + 7 | 0] << 24)) ^ 1735287144) { 1839 break block2 1840 } 1841 HEAP8[$0_1 + 1 | 0] = 29; 1842 break block13; 1843 } 1844 if (!$168($1_1, 1051992, $2_1)) { 1845 break block31 1846 } 1847 if ($168($1_1, 1052088, $2_1)) { 1848 break block2 1849 } 1850 HEAP8[$0_1 + 1 | 0] = 30; 1851 break block13; 1852 } 1853 if ((HEAPU8[$1_1 | 0] | HEAPU8[$1_1 + 1 | 0] << 8 | (HEAPU8[$1_1 + 2 | 0] << 16 | HEAPU8[$1_1 + 3 | 0] << 24)) ^ 1701996868 | (HEAPU8[$4_1 | 0] | HEAPU8[$3_1 + 1 | 0] << 8 | (HEAPU8[$3_1 + 2 | 0] << 16 | HEAPU8[$3_1 + 3 | 0] << 24)) ^ 1098478191 | ((HEAPU8[$1_1 + 4 | 0] | HEAPU8[$1_1 + 5 | 0] << 8 | (HEAPU8[$1_1 + 6 | 0] << 16 | HEAPU8[$1_1 + 7 | 0] << 24)) ^ 1919906915 | (HEAPU8[$3_1 + 4 | 0] | HEAPU8[$3_1 + 5 | 0] << 8 | (HEAPU8[$3_1 + 6 | 0] << 16 | HEAPU8[$3_1 + 7 | 0] << 24)) ^ 1684366436)) { 1854 $3_1 = $1_1 + 6 | 0; 1855 if ((HEAPU8[$1_1 | 0] | HEAPU8[$1_1 + 1 | 0] << 8 | (HEAPU8[$1_1 + 2 | 0] << 16 | HEAPU8[$1_1 + 3 | 0] << 24)) ^ 1936942413 | (HEAPU8[$3_1 | 0] | HEAPU8[$3_1 + 1 | 0] << 8 | (HEAPU8[$3_1 + 2 | 0] << 16 | HEAPU8[$3_1 + 3 | 0] << 24)) ^ 1936278629 | ((HEAPU8[$3_1 + 4 | 0] | HEAPU8[$3_1 + 5 | 0] << 8 | (HEAPU8[$3_1 + 6 | 0] << 16 | HEAPU8[$3_1 + 7 | 0] << 24)) ^ 2036427888 | (HEAPU8[$1_1 + 4 | 0] | HEAPU8[$1_1 + 5 | 0] << 8 | (HEAPU8[$1_1 + 6 | 0] << 16 | HEAPU8[$1_1 + 7 | 0] << 24)) ^ 1147496289)) { 1856 break block2 1857 } 1858 HEAP8[$0_1 + 1 | 0] = 32; 1859 break block13; 1860 } 1861 HEAP8[$0_1 + 1 | 0] = 31; 1862 break block13; 1863 } 1864 $3_1 = $1_1 + 8 | 0; 1865 $4_1 = (HEAPU8[$1_1 | 0] | HEAPU8[$1_1 + 1 | 0] << 8 | (HEAPU8[$1_1 + 2 | 0] << 16 | HEAPU8[$1_1 + 3 | 0] << 24)) ^ 1919251285 | (HEAPU8[$3_1 | 0] | HEAPU8[$3_1 + 1 | 0] << 8 | (HEAPU8[$3_1 + 2 | 0] << 16 | HEAPU8[$3_1 + 3 | 0] << 24)) ^ 2017817712; 1866 $5_1 = (HEAPU8[$3_1 + 4 | 0] | HEAPU8[$3_1 + 5 | 0] << 8 | (HEAPU8[$3_1 + 6 | 0] << 16 | HEAPU8[$3_1 + 7 | 0] << 24)) ^ 1936613744 | (HEAPU8[$1_1 + 4 | 0] | HEAPU8[$1_1 + 5 | 0] << 8 | (HEAPU8[$1_1 + 6 | 0] << 16 | HEAPU8[$1_1 + 7 | 0] << 24)) ^ 1836020304; 1867 $3_1 = $1_1 + 11 | 0; 1868 if (!((HEAPU8[$3_1 | 0] | HEAPU8[$3_1 + 1 | 0] << 8 | (HEAPU8[$3_1 + 2 | 0] << 16 | HEAPU8[$3_1 + 3 | 0] << 24)) ^ 1851879544 | $4_1 | ((HEAPU8[$3_1 + 4 | 0] | HEAPU8[$3_1 + 5 | 0] << 8 | (HEAPU8[$3_1 + 6 | 0] << 16 | HEAPU8[$3_1 + 7 | 0] << 24)) ^ 1852795251 | $5_1))) { 1869 break block32 1870 } 1871 } 1872 $3_1 = $0_1; 1873 $0_1 = global$0 - 32 | 0; 1874 global$0 = $0_1; 1875 HEAP32[$0_1 + 4 >> 2] = $2_1; 1876 HEAP32[$0_1 >> 2] = $1_1; 1877 HEAP32[$0_1 + 12 >> 2] = 33; 1878 HEAP32[$0_1 + 8 >> 2] = 1052128; 1879 HEAP32[$0_1 + 28 >> 2] = 2; 1880 HEAP32[$0_1 + 20 >> 2] = 1; 1881 HEAP32[$0_1 + 24 >> 2] = $0_1 + 8; 1882 HEAP32[$0_1 + 16 >> 2] = $0_1; 1883 $1_1 = $59(1048975, $0_1 + 16 | 0); 1884 global$0 = $0_1 + 32 | 0; 1885 HEAP32[$3_1 + 4 >> 2] = $1_1; 1886 $0_1 = 1; 1887 break block33; 1888 } 1889 HEAP8[$0_1 + 1 | 0] = 23; 1890 break block13; 1891 } 1892 HEAP8[$0_1 + 1 | 0] = 18; 1893 break block13; 1894 } 1895 HEAP8[$0_1 + 1 | 0] = 16; 1896 break block13; 1897 } 1898 HEAP8[$0_1 + 1 | 0] = 15; 1899 break block13; 1900 } 1901 HEAP8[$0_1 + 1 | 0] = 14; 1902 break block13; 1903 } 1904 HEAP8[$0_1 + 1 | 0] = 13; 1905 break block13; 1906 } 1907 HEAP8[$0_1 + 1 | 0] = 7; 1908 break block13; 1909 } 1910 HEAP8[$0_1 + 1 | 0] = 5; 1911 break block13; 1912 } 1913 HEAP8[$0_1 + 1 | 0] = 3; 1914 break block13; 1915 } 1916 HEAP8[$0_1 + 1 | 0] = 2; 1917 break block13; 1918 } 1919 HEAP8[$0_1 + 1 | 0] = 1; 1920 } 1921 $0_1 = 0; 1922 break block33; 1923 } 1924 HEAP8[$0_1 + 1 | 0] = 0; 1925 $0_1 = 0; 1926 } 1927 HEAP8[$7_1 | 0] = $0_1; 1928 } 1929 1930 function $11($0_1) { 1931 var $1_1 = 0, $2_1 = 0, $3_1 = 0, $4_1 = 0, $5_1 = 0, $6_1 = 0; 1932 $1_1 = global$0 - 32 | 0; 1933 global$0 = $1_1; 1934 block1 : { 1935 block : { 1936 $2_1 = HEAP32[$0_1 + 20 >> 2]; 1937 $3_1 = HEAP32[$0_1 + 16 >> 2]; 1938 if ($2_1 >>> 0 < $3_1 >>> 0) { 1939 $6_1 = HEAP32[$0_1 + 12 >> 2]; 1940 while (1) { 1941 $4_1 = HEAPU8[$2_1 + $6_1 | 0]; 1942 $5_1 = $4_1 - 9 | 0; 1943 if ($5_1 >>> 0 > 23 | !(1 << $5_1 & 8388627)) { 1944 break block 1945 } 1946 $2_1 = $2_1 + 1 | 0; 1947 HEAP32[$0_1 + 20 >> 2] = $2_1; 1948 if (($2_1 | 0) != ($3_1 | 0)) { 1949 continue 1950 } 1951 break; 1952 }; 1953 } 1954 HEAP32[$1_1 + 16 >> 2] = 5; 1955 $71($1_1 + 8 | 0, $0_1 + 12 | 0); 1956 $0_1 = $55($1_1 + 16 | 0, HEAP32[$1_1 + 8 >> 2], HEAP32[$1_1 + 12 >> 2]); 1957 break block1; 1958 } 1959 if (($4_1 | 0) == 110) { 1960 HEAP32[$0_1 + 20 >> 2] = $2_1 + 1; 1961 $0_1 = $13($0_1, 1052480, 3); 1962 break block1; 1963 } 1964 $0_1 = $0($12($0_1, $1_1 + 31 | 0, 1052484), $0_1); 1965 } 1966 global$0 = $1_1 + 32 | 0; 1967 return $0_1; 1968 } 1969 1970 function $12($0_1, $1_1, $2_1) { 1971 var $3_1 = 0, $4_1 = 0, $5_1 = 0; 1972 $3_1 = global$0 - 80 | 0; 1973 global$0 = $3_1; 1974 block5 : { 1975 block3 : { 1976 block10 : { 1977 block9 : { 1978 block6 : { 1979 block8 : { 1980 block : { 1981 block1 : { 1982 block4 : { 1983 block7 : { 1984 $5_1 = HEAP32[$0_1 + 20 >> 2]; 1985 if ($5_1 >>> 0 < HEAPU32[$0_1 + 16 >> 2]) { 1986 $4_1 = HEAPU8[$5_1 + HEAP32[$0_1 + 12 >> 2] | 0]; 1987 block2 : { 1988 if ($4_1 >>> 0 <= 101) { 1989 if (($4_1 | 0) == 34) { 1990 break block 1991 } 1992 if (($4_1 | 0) == 45) { 1993 break block1 1994 } 1995 if (($4_1 | 0) != 91) { 1996 break block2 1997 } 1998 HEAP8[$3_1 + 64 | 0] = 10; 1999 $1_1 = $43($3_1 - -64 | 0, $1_1, $2_1); 2000 break block3; 2001 } 2002 if ($4_1 >>> 0 <= 115) { 2003 if (($4_1 | 0) == 102) { 2004 break block4 2005 } 2006 if (($4_1 | 0) != 110) { 2007 break block2 2008 } 2009 HEAP32[$0_1 + 20 >> 2] = $5_1 + 1; 2010 $4_1 = $13($0_1, 1052480, 3); 2011 if ($4_1) { 2012 break block5 2013 } 2014 HEAP8[$3_1 + 64 | 0] = 7; 2015 $1_1 = $43($3_1 - -64 | 0, $1_1, $2_1); 2016 break block3; 2017 } 2018 if (($4_1 | 0) == 116) { 2019 break block6 2020 } 2021 if (($4_1 | 0) == 123) { 2022 break block7 2023 } 2024 } 2025 if (($4_1 - 48 & 255) >>> 0 < 10) { 2026 break block8 2027 } 2028 } 2029 HEAP32[$3_1 + 64 >> 2] = 10; 2030 $71($3_1 + 8 | 0, $0_1 + 12 | 0); 2031 $1_1 = $55($3_1 - -64 | 0, HEAP32[$3_1 + 8 >> 2], HEAP32[$3_1 + 12 >> 2]); 2032 break block3; 2033 } 2034 HEAP8[$3_1 + 64 | 0] = 11; 2035 $1_1 = $43($3_1 - -64 | 0, $1_1, $2_1); 2036 break block3; 2037 } 2038 HEAP32[$0_1 + 20 >> 2] = $5_1 + 1; 2039 $4_1 = $13($0_1, 1052706, 4); 2040 if ($4_1) { 2041 break block5 2042 } 2043 HEAP16[$3_1 + 64 >> 1] = 0; 2044 $1_1 = $43($3_1 - -64 | 0, $1_1, $2_1); 2045 break block3; 2046 } 2047 HEAP32[$0_1 + 20 >> 2] = $5_1 + 1; 2048 $4_1 = $3_1 + 16 | 0; 2049 $24($4_1, $0_1, 0); 2050 if ((HEAP32[$3_1 + 16 >> 2] & HEAP32[$3_1 + 20 >> 2]) == -1) { 2051 break block9 2052 } 2053 $1_1 = $62($4_1, $1_1, $2_1); 2054 break block3; 2055 } 2056 HEAP32[$0_1 + 8 >> 2] = 0; 2057 HEAP32[$0_1 + 20 >> 2] = $5_1 + 1; 2058 $73($3_1 + 52 | 0, $0_1 + 12 | 0, $0_1); 2059 $4_1 = HEAP32[$3_1 + 56 >> 2]; 2060 if (HEAP32[$3_1 + 52 >> 2] == 2) { 2061 break block5 2062 } 2063 HEAP32[$3_1 + 72 >> 2] = HEAP32[$3_1 + 60 >> 2]; 2064 HEAP32[$3_1 + 68 >> 2] = $4_1; 2065 HEAP8[$3_1 + 64 | 0] = 5; 2066 $1_1 = $43($3_1 - -64 | 0, $1_1, $2_1); 2067 break block3; 2068 } 2069 $24($3_1 + 32 | 0, $0_1, 1); 2070 if ((HEAP32[$3_1 + 32 >> 2] & HEAP32[$3_1 + 36 >> 2]) == -1) { 2071 $4_1 = HEAP32[$3_1 + 40 >> 2]; 2072 break block5; 2073 } 2074 $1_1 = $62($3_1 + 32 | 0, $1_1, $2_1); 2075 break block3; 2076 } 2077 HEAP32[$0_1 + 20 >> 2] = $5_1 + 1; 2078 $4_1 = $13($0_1, 1052703, 3); 2079 if (!$4_1) { 2080 break block10 2081 } 2082 break block5; 2083 } 2084 $4_1 = HEAP32[$3_1 + 24 >> 2]; 2085 break block5; 2086 } 2087 HEAP16[$3_1 + 64 >> 1] = 256; 2088 $1_1 = $43($3_1 - -64 | 0, $1_1, $2_1); 2089 } 2090 $4_1 = $0($1_1, $0_1); 2091 } 2092 global$0 = $3_1 + 80 | 0; 2093 return $4_1; 2094 } 2095 2096 function $13($0_1, $1_1, $2_1) { 2097 var $3_1 = 0, $4_1 = 0, $5_1 = 0, $6_1 = 0, $7_1 = 0, $8_1 = 0, $9_1 = 0; 2098 $3_1 = global$0 - 32 | 0; 2099 global$0 = $3_1; 2100 block : { 2101 if (!$2_1) { 2102 break block 2103 } 2104 $4_1 = HEAP32[$0_1 + 20 >> 2]; 2105 $5_1 = HEAP32[$0_1 + 16 >> 2]; 2106 $8_1 = $4_1 >>> 0 > $5_1 >>> 0 ? $4_1 : $5_1; 2107 $6_1 = $0_1 + 12 | 0; 2108 $9_1 = HEAP32[$0_1 + 12 >> 2]; 2109 block1 : { 2110 while (1) { 2111 if (($4_1 | 0) == ($8_1 | 0)) { 2112 break block1 2113 } 2114 $5_1 = $4_1 + 1 | 0; 2115 HEAP32[$0_1 + 20 >> 2] = $5_1; 2116 if (HEAPU8[$4_1 + $9_1 | 0] == HEAPU8[$1_1 | 0]) { 2117 $1_1 = $1_1 + 1 | 0; 2118 $4_1 = $5_1; 2119 $2_1 = $2_1 - 1 | 0; 2120 if (!$2_1) { 2121 break block 2122 } 2123 continue; 2124 } 2125 break; 2126 }; 2127 HEAP32[$3_1 + 20 >> 2] = 9; 2128 $72($3_1 + 8 | 0, $6_1); 2129 $7_1 = $55($3_1 + 20 | 0, HEAP32[$3_1 + 8 >> 2], HEAP32[$3_1 + 12 >> 2]); 2130 break block; 2131 } 2132 HEAP32[$3_1 + 20 >> 2] = 5; 2133 $72($3_1, $6_1); 2134 $7_1 = $55($3_1 + 20 | 0, HEAP32[$3_1 >> 2], HEAP32[$3_1 + 4 >> 2]); 2135 } 2136 global$0 = $3_1 + 32 | 0; 2137 return $7_1; 2138 } 2139 2140 function $14($0_1, $1_1) { 2141 var $2_1 = 0; 2142 $2_1 = global$0 - 16 | 0; 2143 global$0 = $2_1; 2144 $7($2_1 + 4 | 0, $1_1); 2145 block : { 2146 if (HEAPU8[$2_1 + 4 | 0] == 1) { 2147 HEAP32[$0_1 + 4 >> 2] = HEAP32[$2_1 + 8 >> 2]; 2148 HEAP32[$0_1 >> 2] = -3; 2149 break block; 2150 } 2151 if (!HEAPU8[$2_1 + 5 | 0]) { 2152 HEAP32[$0_1 >> 2] = -2; 2153 break block; 2154 } 2155 $19($2_1 + 4 | 0, HEAP32[$1_1 >> 2]); 2156 if (HEAP32[$2_1 + 4 >> 2] != -2) { 2157 HEAP32[$0_1 + 8 >> 2] = HEAP32[$2_1 + 12 >> 2]; 2158 $1_1 = HEAP32[$2_1 + 8 >> 2]; 2159 HEAP32[$0_1 >> 2] = HEAP32[$2_1 + 4 >> 2]; 2160 HEAP32[$0_1 + 4 >> 2] = $1_1; 2161 break block; 2162 } 2163 HEAP32[$0_1 + 4 >> 2] = HEAP32[$2_1 + 8 >> 2]; 2164 HEAP32[$0_1 >> 2] = -3; 2165 } 2166 global$0 = $2_1 + 16 | 0; 2167 } 2168 2169 function $15($0_1) { 2170 var $1_1 = 0; 2171 $1_1 = global$0 - 32 | 0; 2172 global$0 = $1_1; 2173 HEAP32[$1_1 + 12 >> 2] = 1052432; 2174 HEAP32[$1_1 + 8 >> 2] = 1052424; 2175 HEAP32[$1_1 + 4 >> 2] = $0_1; 2176 HEAP32[$1_1 + 28 >> 2] = 3; 2177 HEAP32[$1_1 + 20 >> 2] = 4; 2178 HEAP32[$1_1 + 24 >> 2] = $1_1 + 8; 2179 HEAP32[$1_1 + 16 >> 2] = $1_1 + 4; 2180 $0_1 = $59(1049009, $1_1 + 16 | 0); 2181 global$0 = $1_1 + 32 | 0; 2182 return $0_1; 2183 } 2184 2185 function $16($0_1, $1_1) { 2186 var $2_1 = 0, $3_1 = 0, $4_1 = 0, $5_1 = 0, $6_1 = 0, $7_1 = 0, $8_1 = 0, $9_1 = 0, $10_1 = 0, $11_1 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; 2187 $4_1 = global$0 - 32 | 0; 2188 global$0 = $4_1; 2189 $5_1 = $4_1 + 20 | 0; 2190 $2_1 = global$0 + -64 | 0; 2191 global$0 = $2_1; 2192 block2 : { 2193 block1 : { 2194 block : { 2195 $7_1 = HEAP32[$1_1 >> 2]; 2196 $3_1 = HEAP32[$7_1 + 20 >> 2]; 2197 $10_1 = HEAP32[$7_1 + 16 >> 2]; 2198 if ($3_1 >>> 0 < $10_1 >>> 0) { 2199 $9_1 = $7_1 + 12 | 0; 2200 $11_1 = HEAP32[$7_1 + 12 >> 2]; 2201 while (1) { 2202 $6_1 = HEAPU8[$3_1 + $11_1 | 0]; 2203 $8_1 = $6_1 - 9 | 0; 2204 if ($8_1 >>> 0 > 23 | !(1 << $8_1 & 8388627)) { 2205 break block 2206 } 2207 $3_1 = $3_1 + 1 | 0; 2208 HEAP32[$7_1 + 20 >> 2] = $3_1; 2209 if (($3_1 | 0) != ($10_1 | 0)) { 2210 continue 2211 } 2212 break; 2213 }; 2214 } 2215 HEAP32[$2_1 + 52 >> 2] = 3; 2216 $71($2_1 + 40 | 0, $7_1 + 12 | 0); 2217 (wasm2js_i32$0 = $5_1, wasm2js_i32$1 = $55($2_1 + 52 | 0, HEAP32[$2_1 + 40 >> 2], HEAP32[$2_1 + 44 >> 2])), HEAP32[wasm2js_i32$0 + 4 >> 2] = wasm2js_i32$1; 2218 break block1; 2219 } 2220 if (($6_1 | 0) == 125) { 2221 $8_1 = 0; 2222 HEAP8[$5_1 + 1 | 0] = 0; 2223 break block2; 2224 } 2225 block3 : { 2226 if (!HEAPU8[$1_1 + 4 | 0]) { 2227 if (($6_1 | 0) != 44) { 2228 break block3 2229 } 2230 $8_1 = 1; 2231 $3_1 = $3_1 + 1 | 0; 2232 HEAP32[$7_1 + 20 >> 2] = $3_1; 2233 if ($3_1 >>> 0 < $10_1 >>> 0) { 2234 while (1) { 2235 block5 : { 2236 block8 : { 2237 block6 : { 2238 $6_1 = HEAPU8[$3_1 + $11_1 | 0]; 2239 block4 : { 2240 if ($6_1 >>> 0 <= 12) { 2241 if ($6_1 - 9 >>> 0 >= 2) { 2242 break block4 2243 } 2244 break block5; 2245 } 2246 block7 : { 2247 switch ($6_1 - 32 | 0) { 2248 case 1: 2249 break block4; 2250 case 0: 2251 break block5; 2252 case 2: 2253 break block6; 2254 default: 2255 break block7; 2256 }; 2257 } 2258 if (($6_1 | 0) == 13) { 2259 break block5 2260 } 2261 if (($6_1 | 0) == 125) { 2262 break block8 2263 } 2264 } 2265 HEAP32[$2_1 + 52 >> 2] = 17; 2266 $71($2_1 + 8 | 0, $9_1); 2267 (wasm2js_i32$0 = $5_1, wasm2js_i32$1 = $55($2_1 + 52 | 0, HEAP32[$2_1 + 8 >> 2], HEAP32[$2_1 + 12 >> 2])), HEAP32[wasm2js_i32$0 + 4 >> 2] = wasm2js_i32$1; 2268 break block1; 2269 } 2270 HEAP8[$5_1 + 1 | 0] = 1; 2271 $8_1 = 0; 2272 break block2; 2273 } 2274 HEAP32[$2_1 + 52 >> 2] = 21; 2275 $71($2_1 + 24 | 0, $9_1); 2276 (wasm2js_i32$0 = $5_1, wasm2js_i32$1 = $55($2_1 + 52 | 0, HEAP32[$2_1 + 24 >> 2], HEAP32[$2_1 + 28 >> 2])), HEAP32[wasm2js_i32$0 + 4 >> 2] = wasm2js_i32$1; 2277 break block1; 2278 } 2279 $3_1 = $3_1 + 1 | 0; 2280 HEAP32[$7_1 + 20 >> 2] = $3_1; 2281 if (($3_1 | 0) != ($10_1 | 0)) { 2282 continue 2283 } 2284 break; 2285 } 2286 } 2287 HEAP32[$2_1 + 52 >> 2] = 5; 2288 $71($2_1 + 16 | 0, $9_1); 2289 (wasm2js_i32$0 = $5_1, wasm2js_i32$1 = $55($2_1 + 52 | 0, HEAP32[$2_1 + 16 >> 2], HEAP32[$2_1 + 20 >> 2])), HEAP32[wasm2js_i32$0 + 4 >> 2] = wasm2js_i32$1; 2290 break block2; 2291 } 2292 $8_1 = 0; 2293 HEAP8[$1_1 + 4 | 0] = 0; 2294 if (($6_1 | 0) != 34) { 2295 HEAP32[$2_1 + 52 >> 2] = 17; 2296 $71($2_1, $9_1); 2297 (wasm2js_i32$0 = $5_1, wasm2js_i32$1 = $55($2_1 + 52 | 0, HEAP32[$2_1 >> 2], HEAP32[$2_1 + 4 >> 2])), HEAP32[wasm2js_i32$0 + 4 >> 2] = wasm2js_i32$1; 2298 break block1; 2299 } 2300 HEAP8[$5_1 + 1 | 0] = 1; 2301 break block2; 2302 } 2303 HEAP32[$2_1 + 52 >> 2] = 8; 2304 $71($2_1 + 32 | 0, $9_1); 2305 (wasm2js_i32$0 = $5_1, wasm2js_i32$1 = $55($2_1 + 52 | 0, HEAP32[$2_1 + 32 >> 2], HEAP32[$2_1 + 36 >> 2])), HEAP32[wasm2js_i32$0 + 4 >> 2] = wasm2js_i32$1; 2306 } 2307 $8_1 = 1; 2308 } 2309 HEAP8[$5_1 | 0] = $8_1; 2310 global$0 = $2_1 - -64 | 0; 2311 block9 : { 2312 if (HEAPU8[$4_1 + 20 | 0] == 1) { 2313 HEAP32[$0_1 + 4 >> 2] = HEAP32[$4_1 + 24 >> 2]; 2314 HEAP8[$0_1 | 0] = 1; 2315 break block9; 2316 } 2317 if (!HEAPU8[$4_1 + 21 | 0]) { 2318 HEAP16[$0_1 >> 1] = 65280; 2319 break block9; 2320 } 2321 $1_1 = HEAP32[$1_1 >> 2]; 2322 HEAP32[$1_1 + 8 >> 2] = 0; 2323 HEAP32[$1_1 + 20 >> 2] = HEAP32[$1_1 + 20 >> 2] + 1; 2324 $73($4_1 + 20 | 0, $1_1 + 12 | 0, $1_1); 2325 $1_1 = HEAP32[$4_1 + 24 >> 2]; 2326 block16 : { 2327 block10 : { 2328 if (HEAP32[$4_1 + 20 >> 2] == 2) { 2329 HEAP32[$4_1 + 16 >> 2] = $1_1; 2330 break block10; 2331 } 2332 $2_1 = $4_1 + 12 | 0; 2333 block15 : { 2334 block13 : { 2335 block14 : { 2336 switch (HEAP32[$4_1 + 28 >> 2] - 4 | 0) { 2337 case 1: 2338 if ((HEAPU8[$1_1 | 0] | HEAPU8[$1_1 + 1 | 0] << 8 | (HEAPU8[$1_1 + 2 | 0] << 16 | HEAPU8[$1_1 + 3 | 0] << 24)) ^ 1852143205 | HEAPU8[$1_1 + 4 | 0] ^ 116) { 2339 break block13 2340 } 2341 $1_1 = 0; 2342 break block15; 2343 case 0: 2344 if ((HEAPU8[$1_1 | 0] | HEAPU8[$1_1 + 1 | 0] << 8 | (HEAPU8[$1_1 + 2 | 0] << 16 | HEAPU8[$1_1 + 3 | 0] << 24)) != 1819242356) { 2345 break block13 2346 } 2347 $1_1 = 1; 2348 break block15; 2349 case 3: 2350 break block14; 2351 default: 2352 break block13; 2353 }; 2354 } 2355 $3_1 = (HEAPU8[$1_1 | 0] | HEAPU8[$1_1 + 1 | 0] << 8 | (HEAPU8[$1_1 + 2 | 0] << 16 | HEAPU8[$1_1 + 3 | 0] << 24)) ^ 1835888483; 2356 $1_1 = $1_1 + 3 | 0; 2357 if ($3_1 | (HEAPU8[$1_1 | 0] | HEAPU8[$1_1 + 1 | 0] << 8 | (HEAPU8[$1_1 + 2 | 0] << 16 | HEAPU8[$1_1 + 3 | 0] << 24)) ^ 1684955501) { 2358 break block13 2359 } 2360 $1_1 = 2; 2361 break block15; 2362 } 2363 $1_1 = 3; 2364 } 2365 HEAP8[$2_1 | 0] = 0; 2366 HEAP8[$2_1 + 1 | 0] = $1_1; 2367 if (!HEAPU8[$4_1 + 12 | 0]) { 2368 break block16 2369 } 2370 } 2371 HEAP32[$0_1 + 4 >> 2] = HEAP32[$4_1 + 16 >> 2]; 2372 HEAP8[$0_1 | 0] = 1; 2373 break block9; 2374 } 2375 HEAP8[$0_1 + 1 | 0] = HEAPU8[$4_1 + 13 | 0]; 2376 HEAP8[$0_1 | 0] = 0; 2377 } 2378 global$0 = $4_1 + 32 | 0; 2379 } 2380 2381 function $17($0_1) { 2382 var $1_1 = 0, $2_1 = 0, $3_1 = 0, $4_1 = 0, $5_1 = 0, $6_1 = 0, $7_1 = 0; 2383 $1_1 = global$0 - 32 | 0; 2384 global$0 = $1_1; 2385 block1 : { 2386 block : { 2387 $2_1 = HEAP32[$0_1 + 20 >> 2]; 2388 $3_1 = HEAP32[$0_1 + 16 >> 2]; 2389 if ($2_1 >>> 0 < $3_1 >>> 0) { 2390 $6_1 = $0_1 + 12 | 0; 2391 $7_1 = HEAP32[$0_1 + 12 >> 2]; 2392 while (1) { 2393 $4_1 = HEAPU8[$2_1 + $7_1 | 0]; 2394 $5_1 = $4_1 - 9 | 0; 2395 if ($5_1 >>> 0 > 23 | !(1 << $5_1 & 8388627)) { 2396 break block 2397 } 2398 $2_1 = $2_1 + 1 | 0; 2399 HEAP32[$0_1 + 20 >> 2] = $2_1; 2400 if (($2_1 | 0) != ($3_1 | 0)) { 2401 continue 2402 } 2403 break; 2404 }; 2405 } 2406 HEAP32[$1_1 + 20 >> 2] = 3; 2407 $71($1_1 + 8 | 0, $0_1 + 12 | 0); 2408 $0_1 = $55($1_1 + 20 | 0, HEAP32[$1_1 + 8 >> 2], HEAP32[$1_1 + 12 >> 2]); 2409 break block1; 2410 } 2411 if (($4_1 | 0) == 58) { 2412 HEAP32[$0_1 + 20 >> 2] = $2_1 + 1; 2413 $0_1 = 0; 2414 break block1; 2415 } 2416 HEAP32[$1_1 + 20 >> 2] = 6; 2417 $71($1_1, $6_1); 2418 $0_1 = $55($1_1 + 20 | 0, HEAP32[$1_1 >> 2], HEAP32[$1_1 + 4 >> 2]); 2419 } 2420 global$0 = $1_1 + 32 | 0; 2421 return $0_1; 2422 } 2423 2424 function $18($0_1, $1_1) { 2425 var $2_1 = 0; 2426 $1_1 = HEAP32[$1_1 >> 2]; 2427 $2_1 = $17($1_1); 2428 if ($2_1) { 2429 HEAP32[$0_1 >> 2] = -2; 2430 HEAP32[$0_1 + 4 >> 2] = $2_1; 2431 return; 2432 } 2433 $19($0_1, $1_1); 2434 } 2435 2436 function $19($0_1, $1_1) { 2437 var $2_1 = 0, $3_1 = 0, $4_1 = 0, $5_1 = 0, $6_1 = 0, $7_1 = 0, $8_1 = 0, $9_1 = 0, $10_1 = 0; 2438 $6_1 = global$0 - 16 | 0; 2439 global$0 = $6_1; 2440 block2 : { 2441 block1 : { 2442 block : { 2443 $2_1 = HEAP32[$1_1 + 20 >> 2]; 2444 $4_1 = HEAP32[$1_1 + 16 >> 2]; 2445 if ($2_1 >>> 0 >= $4_1 >>> 0) { 2446 break block 2447 } 2448 $3_1 = HEAP32[$1_1 + 12 >> 2]; 2449 while (1) { 2450 $5_1 = HEAPU8[$2_1 + $3_1 | 0]; 2451 $7_1 = $5_1 - 9 | 0; 2452 if (!($7_1 >>> 0 > 23 | !(1 << $7_1 & 8388627))) { 2453 $2_1 = $2_1 + 1 | 0; 2454 HEAP32[$1_1 + 20 >> 2] = $2_1; 2455 if (($2_1 | 0) != ($4_1 | 0)) { 2456 continue 2457 } 2458 break block; 2459 } 2460 break; 2461 }; 2462 if (($5_1 | 0) != 110) { 2463 break block 2464 } 2465 HEAP32[$1_1 + 20 >> 2] = $2_1 + 1; 2466 $1_1 = $13($1_1, 1052480, 3); 2467 if ($1_1) { 2468 break block1 2469 } 2470 HEAP32[$0_1 >> 2] = -1; 2471 break block2; 2472 } 2473 $4_1 = $6_1 + 4 | 0; 2474 $2_1 = global$0 - 48 | 0; 2475 global$0 = $2_1; 2476 block4 : { 2477 block3 : { 2478 $3_1 = HEAP32[$1_1 + 20 >> 2]; 2479 $5_1 = HEAP32[$1_1 + 16 >> 2]; 2480 if ($3_1 >>> 0 < $5_1 >>> 0) { 2481 $7_1 = $1_1 + 12 | 0; 2482 $10_1 = HEAP32[$1_1 + 12 >> 2]; 2483 while (1) { 2484 $8_1 = HEAPU8[$3_1 + $10_1 | 0]; 2485 $9_1 = $8_1 - 9 | 0; 2486 if ($9_1 >>> 0 > 23 | !(1 << $9_1 & 8388627)) { 2487 break block3 2488 } 2489 $3_1 = $3_1 + 1 | 0; 2490 HEAP32[$1_1 + 20 >> 2] = $3_1; 2491 if (($3_1 | 0) != ($5_1 | 0)) { 2492 continue 2493 } 2494 break; 2495 }; 2496 } 2497 HEAP32[$2_1 + 32 >> 2] = 5; 2498 $71($2_1 + 8 | 0, $1_1 + 12 | 0); 2499 $1_1 = $55($2_1 + 32 | 0, HEAP32[$2_1 + 8 >> 2], HEAP32[$2_1 + 12 >> 2]); 2500 HEAP32[$4_1 >> 2] = -1; 2501 HEAP32[$4_1 + 4 >> 2] = $1_1; 2502 break block4; 2503 } 2504 if (($8_1 | 0) != 34) { 2505 $1_1 = $0($12($1_1, $2_1 + 47 | 0, 1052448), $1_1); 2506 HEAP32[$4_1 >> 2] = -1; 2507 HEAP32[$4_1 + 4 >> 2] = $1_1; 2508 break block4; 2509 } 2510 HEAP32[$1_1 + 8 >> 2] = 0; 2511 HEAP32[$1_1 + 20 >> 2] = $3_1 + 1; 2512 $73($2_1 + 32 | 0, $7_1, $1_1); 2513 $10_1 = HEAP32[$2_1 + 36 >> 2]; 2514 if (HEAP32[$2_1 + 32 >> 2] != 2) { 2515 $7_1 = $2_1 + 20 | 0; 2516 $3_1 = global$0 - 16 | 0; 2517 global$0 = $3_1; 2518 $5_1 = HEAP32[$2_1 + 40 >> 2]; 2519 $35($3_1 + 4 | 0, $5_1, 1, 1); 2520 $8_1 = HEAP32[$3_1 + 8 >> 2]; 2521 block5 : { 2522 if (HEAP32[$3_1 + 4 >> 2] != 1) { 2523 $9_1 = HEAP32[$3_1 + 12 >> 2]; 2524 if ($5_1) { 2525 wasm2js_memory_copy($9_1, $10_1, $5_1) 2526 } 2527 HEAP32[$7_1 + 8 >> 2] = $5_1; 2528 HEAP32[$7_1 + 4 >> 2] = $9_1; 2529 HEAP32[$7_1 >> 2] = $8_1; 2530 global$0 = $3_1 + 16 | 0; 2531 break block5; 2532 } 2533 $120($8_1, HEAP32[$3_1 + 12 >> 2]); 2534 wasm2js_trap(); 2535 } 2536 if (HEAP32[$2_1 + 20 >> 2] == -1) { 2537 $1_1 = $0(HEAP32[$2_1 + 24 >> 2], $1_1); 2538 HEAP32[$4_1 >> 2] = -1; 2539 HEAP32[$4_1 + 4 >> 2] = $1_1; 2540 break block4; 2541 } 2542 HEAP32[$4_1 + 8 >> 2] = HEAP32[$2_1 + 28 >> 2]; 2543 $1_1 = HEAP32[$2_1 + 24 >> 2]; 2544 HEAP32[$4_1 >> 2] = HEAP32[$2_1 + 20 >> 2]; 2545 HEAP32[$4_1 + 4 >> 2] = $1_1; 2546 break block4; 2547 } 2548 HEAP32[$4_1 >> 2] = -1; 2549 HEAP32[$4_1 + 4 >> 2] = $10_1; 2550 } 2551 global$0 = $2_1 + 48 | 0; 2552 if (HEAP32[$6_1 + 4 >> 2] == -1) { 2553 HEAP32[$0_1 + 4 >> 2] = HEAP32[$6_1 + 8 >> 2]; 2554 HEAP32[$0_1 >> 2] = -2; 2555 break block2; 2556 } 2557 HEAP32[$0_1 + 8 >> 2] = HEAP32[$6_1 + 12 >> 2]; 2558 $4_1 = HEAP32[$6_1 + 8 >> 2]; 2559 HEAP32[$0_1 >> 2] = HEAP32[$6_1 + 4 >> 2]; 2560 HEAP32[$0_1 + 4 >> 2] = $4_1; 2561 break block2; 2562 } 2563 HEAP32[$0_1 >> 2] = -2; 2564 HEAP32[$0_1 + 4 >> 2] = $1_1; 2565 } 2566 global$0 = $6_1 + 16 | 0; 2567 } 2568 2569 function $20($0_1, $1_1, $2_1, $3_1, $4_1) { 2570 var $5_1 = 0, $6_1 = 0, $7_1 = 0, $8_1 = 0; 2571 $6_1 = global$0 - 16 | 0; 2572 global$0 = $6_1; 2573 block6 : { 2574 block3 : { 2575 block5 : { 2576 block4 : { 2577 block2 : { 2578 block1 : { 2579 block : { 2580 $5_1 = HEAP32[$1_1 + 20 >> 2]; 2581 if ($5_1 >>> 0 < HEAPU32[$1_1 + 16 >> 2]) { 2582 $5_1 = HEAPU8[$5_1 + HEAP32[$1_1 + 12 >> 2] | 0]; 2583 if (($5_1 | 0) == 46) { 2584 break block 2585 } 2586 if (($5_1 | 0) == 69 | ($5_1 | 0) == 101) { 2587 break block1 2588 } 2589 } 2590 if (!$2_1) { 2591 break block2 2592 } 2593 $7_1 = 1; 2594 break block3; 2595 } 2596 $21($6_1, $1_1, $2_1, $3_1, $4_1, 0); 2597 if (HEAP32[$6_1 >> 2]) { 2598 break block4 2599 } 2600 break block5; 2601 } 2602 $22($6_1, $1_1, $2_1, $3_1, $4_1, 0); 2603 if (!HEAP32[$6_1 >> 2]) { 2604 break block5 2605 } 2606 HEAP32[$0_1 + 8 >> 2] = HEAP32[$6_1 + 4 >> 2]; 2607 HEAP32[$0_1 >> 2] = -1; 2608 HEAP32[$0_1 + 4 >> 2] = -1; 2609 break block6; 2610 } 2611 $2_1 = 0; 2612 $5_1 = ($3_1 >>> 0 > $2_1 >>> 0) + $4_1 | 0; 2613 $1_1 = $2_1 - $3_1 | 0; 2614 $5_1 = 0 - $5_1 | 0; 2615 if (0 > ($5_1 | 0)) { 2616 $2_1 = 1 2617 } else { 2618 $2_1 = $1_1 >>> 0 < $2_1 >>> 0 & ($2_1 | 0) >= ($5_1 | 0) 2619 } 2620 if ($2_1) { 2621 $7_1 = 2; 2622 $3_1 = $1_1; 2623 $4_1 = $5_1; 2624 break block3; 2625 } 2626 wasm2js_scratch_store_f64(+(+($3_1 >>> 0) + +($4_1 >>> 0) * 4294967296.0)); 2627 $1_1 = wasm2js_scratch_load_i32(1) | 0; 2628 $3_1 = wasm2js_scratch_load_i32(0) | 0; 2629 $4_1 = $1_1 | -2147483648; 2630 break block3; 2631 } 2632 HEAP32[$0_1 + 8 >> 2] = HEAP32[$6_1 + 4 >> 2]; 2633 HEAP32[$0_1 >> 2] = -1; 2634 HEAP32[$0_1 + 4 >> 2] = -1; 2635 break block6; 2636 } 2637 $3_1 = HEAP32[$6_1 + 8 >> 2]; 2638 $4_1 = HEAP32[$6_1 + 12 >> 2]; 2639 } 2640 HEAP32[$0_1 + 8 >> 2] = $3_1; 2641 HEAP32[$0_1 + 12 >> 2] = $4_1; 2642 HEAP32[$0_1 >> 2] = $7_1; 2643 HEAP32[$0_1 + 4 >> 2] = $8_1; 2644 } 2645 global$0 = $6_1 + 16 | 0; 2646 } 2647 2648 function $21($0_1, $1_1, $2_1, $3_1, $4_1, $5_1) { 2649 var $6_1 = 0, $7_1 = 0, $8_1 = 0, $9_1 = 0, $10_1 = 0, $11_1 = 0, $12_1 = 0, $13_1 = 0, $14_1 = 0, $15_1 = 0, $16_1 = 0, $17_1 = 0; 2650 $7_1 = global$0 - 32 | 0; 2651 global$0 = $7_1; 2652 $6_1 = HEAP32[$1_1 + 20 >> 2]; 2653 $11_1 = $6_1 + 1 | 0; 2654 HEAP32[$1_1 + 20 >> 2] = $11_1; 2655 block1 : { 2656 block2 : { 2657 block : { 2658 $10_1 = HEAP32[$1_1 + 16 >> 2]; 2659 if ($10_1 >>> 0 <= $11_1 >>> 0) { 2660 break block 2661 } 2662 $14_1 = $11_1 - $10_1 | 0; 2663 $15_1 = $1_1 + 12 | 0; 2664 $16_1 = HEAP32[$1_1 + 12 >> 2] + 1 | 0; 2665 $17_1 = ($6_1 - $10_1 | 0) + 1 | 0; 2666 block3 : { 2667 while (1) { 2668 $8_1 = HEAPU8[$6_1 + $16_1 | 0]; 2669 $12_1 = $8_1 - 48 | 0; 2670 $13_1 = $12_1 & 255; 2671 if ($13_1 >>> 0 >= 10) { 2672 if (!$9_1) { 2673 HEAP32[$7_1 + 20 >> 2] = 13; 2674 $71($7_1 + 8 | 0, $15_1); 2675 $1_1 = $55($7_1 + 20 | 0, HEAP32[$7_1 + 8 >> 2], HEAP32[$7_1 + 12 >> 2]); 2676 HEAP32[$0_1 >> 2] = 1; 2677 HEAP32[$0_1 + 4 >> 2] = $1_1; 2678 break block1; 2679 } 2680 $6_1 = $5_1 + $9_1 | 0; 2681 if (($8_1 | 32) != 101) { 2682 break block2 2683 } 2684 $22($0_1, $1_1, $2_1, $3_1, $4_1, $6_1); 2685 break block1; 2686 } 2687 $8_1 = 429496729; 2688 if (!((($3_1 | 0) != -1717986919 | ($4_1 | 0) != 429496729 | $13_1 >>> 0 > 5) & (($4_1 | 0) == ($8_1 | 0) & $3_1 >>> 0 > 2576980376 | $4_1 >>> 0 > $8_1 >>> 0))) { 2689 HEAP32[$1_1 + 20 >> 2] = $6_1 + 2; 2690 $6_1 = $6_1 + 1 | 0; 2691 $8_1 = $12_1 & 255; 2692 $3_1 = __wasm_i64_mul($3_1, $4_1, 10, 0) + $8_1 | 0; 2693 $4_1 = i64toi32_i32$HIGH_BITS; 2694 $4_1 = $3_1 >>> 0 < $8_1 >>> 0 ? $4_1 + 1 | 0 : $4_1; 2695 $9_1 = $9_1 - 1 | 0; 2696 if (($9_1 | 0) == ($17_1 | 0)) { 2697 break block3 2698 } 2699 continue; 2700 } 2701 break; 2702 }; 2703 $6_1 = $5_1 + $9_1 | 0; 2704 block6 : { 2705 block5 : { 2706 $5_1 = HEAP32[$1_1 + 20 >> 2]; 2707 $9_1 = HEAP32[$1_1 + 16 >> 2]; 2708 block4 : { 2709 if ($5_1 >>> 0 >= $9_1 >>> 0) { 2710 break block4 2711 } 2712 $11_1 = HEAP32[$1_1 + 12 >> 2]; 2713 while (1) { 2714 $10_1 = HEAPU8[$5_1 + $11_1 | 0]; 2715 if (($10_1 - 48 & 255) >>> 0 <= 9) { 2716 $5_1 = $5_1 + 1 | 0; 2717 HEAP32[$1_1 + 20 >> 2] = $5_1; 2718 if (($5_1 | 0) != ($9_1 | 0)) { 2719 continue 2720 } 2721 break block4; 2722 } 2723 break; 2724 }; 2725 if (($10_1 | 32) == 101) { 2726 break block5 2727 } 2728 } 2729 $23($0_1, $1_1, $2_1, $3_1, $4_1, $6_1); 2730 break block6; 2731 } 2732 $22($0_1, $1_1, $2_1, $3_1, $4_1, $6_1); 2733 } 2734 break block1; 2735 } 2736 if (($11_1 | 0) == ($10_1 | 0)) { 2737 break block 2738 } 2739 $6_1 = $5_1 + $14_1 | 0; 2740 break block2; 2741 } 2742 HEAP32[$7_1 + 20 >> 2] = 5; 2743 $71($7_1, $1_1 + 12 | 0); 2744 $1_1 = $55($7_1 + 20 | 0, HEAP32[$7_1 >> 2], HEAP32[$7_1 + 4 >> 2]); 2745 HEAP32[$0_1 >> 2] = 1; 2746 HEAP32[$0_1 + 4 >> 2] = $1_1; 2747 break block1; 2748 } 2749 $23($0_1, $1_1, $2_1, $3_1, $4_1, $6_1); 2750 } 2751 global$0 = $7_1 + 32 | 0; 2752 } 2753 2754 function $22($0_1, $1_1, $2_1, $3_1, $4_1, $5_1) { 2755 var $6_1 = 0, $7_1 = 0, $8_1 = 0, $9_1 = 0, $10_1 = 0, $11_1 = 0, $12_1 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; 2756 $8_1 = global$0 - 32 | 0; 2757 global$0 = $8_1; 2758 $9_1 = 1; 2759 $7_1 = HEAP32[$1_1 + 20 >> 2]; 2760 $6_1 = $7_1 + 1 | 0; 2761 HEAP32[$1_1 + 20 >> 2] = $6_1; 2762 $10_1 = HEAP32[$1_1 + 16 >> 2]; 2763 block : { 2764 if ($10_1 >>> 0 <= $6_1 >>> 0) { 2765 break block 2766 } 2767 block1 : { 2768 switch (HEAPU8[$6_1 + HEAP32[$1_1 + 12 >> 2] | 0] - 43 | 0) { 2769 case 2: 2770 $9_1 = 0; 2771 break; 2772 case 0: 2773 break block1; 2774 default: 2775 break block; 2776 }; 2777 } 2778 $6_1 = $7_1 + 2 | 0; 2779 HEAP32[$1_1 + 20 >> 2] = $6_1; 2780 } 2781 block3 : { 2782 block4 : { 2783 if ($6_1 >>> 0 < $10_1 >>> 0) { 2784 $7_1 = $6_1 + 1 | 0; 2785 HEAP32[$1_1 + 20 >> 2] = $7_1; 2786 $12_1 = HEAP32[$1_1 + 12 >> 2]; 2787 $6_1 = HEAPU8[$6_1 + $12_1 | 0] - 48 & 255; 2788 if ($6_1 >>> 0 >= 10) { 2789 HEAP32[$8_1 + 20 >> 2] = 13; 2790 $72($8_1, $1_1 + 12 | 0); 2791 $1_1 = $55($8_1 + 20 | 0, HEAP32[$8_1 >> 2], HEAP32[$8_1 + 4 >> 2]); 2792 HEAP32[$0_1 >> 2] = 1; 2793 HEAP32[$0_1 + 4 >> 2] = $1_1; 2794 break block3; 2795 } 2796 if ($7_1 >>> 0 >= $10_1 >>> 0) { 2797 break block4 2798 } 2799 while (1) { 2800 $11_1 = HEAPU8[$7_1 + $12_1 | 0] - 48 & 255; 2801 if ($11_1 >>> 0 >= 10) { 2802 break block4 2803 } 2804 $7_1 = $7_1 + 1 | 0; 2805 HEAP32[$1_1 + 20 >> 2] = $7_1; 2806 if (!((($6_1 | 0) != 214748364 | $11_1 >>> 0 > 7) & ($6_1 | 0) > 214748363)) { 2807 $6_1 = $11_1 + Math_imul($6_1, 10) | 0; 2808 if (($7_1 | 0) != ($10_1 | 0)) { 2809 continue 2810 } 2811 break block4; 2812 } 2813 break; 2814 }; 2815 $5_1 = global$0 - 32 | 0; 2816 global$0 = $5_1; 2817 block6 : { 2818 block5 : { 2819 if (!(($9_1 ? $3_1 : 0) | ($9_1 ? $4_1 : 0))) { 2820 $6_1 = HEAP32[$1_1 + 20 >> 2]; 2821 $7_1 = HEAP32[$1_1 + 16 >> 2]; 2822 if ($6_1 >>> 0 >= $7_1 >>> 0) { 2823 break block5 2824 } 2825 $9_1 = HEAP32[$1_1 + 12 >> 2]; 2826 while (1) { 2827 if ((HEAPU8[$6_1 + $9_1 | 0] - 48 & 255) >>> 0 >= 10) { 2828 break block5 2829 } 2830 $6_1 = $6_1 + 1 | 0; 2831 HEAP32[$1_1 + 20 >> 2] = $6_1; 2832 if (($6_1 | 0) != ($7_1 | 0)) { 2833 continue 2834 } 2835 break; 2836 }; 2837 break block5; 2838 } 2839 HEAP32[$5_1 + 20 >> 2] = 14; 2840 $72($5_1 + 8 | 0, $1_1 + 12 | 0); 2841 (wasm2js_i32$0 = $0_1, wasm2js_i32$1 = $55($5_1 + 20 | 0, HEAP32[$5_1 + 8 >> 2], HEAP32[$5_1 + 12 >> 2])), HEAP32[wasm2js_i32$0 + 4 >> 2] = wasm2js_i32$1; 2842 $1_1 = 1; 2843 break block6; 2844 } 2845 HEAPF64[$0_1 + 8 >> 3] = $2_1 ? 0.0 : -0.0; 2846 $1_1 = 0; 2847 } 2848 HEAP32[$0_1 >> 2] = $1_1; 2849 global$0 = $5_1 + 32 | 0; 2850 break block3; 2851 } 2852 HEAP32[$8_1 + 20 >> 2] = 5; 2853 $72($8_1 + 8 | 0, $1_1 + 12 | 0); 2854 $1_1 = $55($8_1 + 20 | 0, HEAP32[$8_1 + 8 >> 2], HEAP32[$8_1 + 12 >> 2]); 2855 HEAP32[$0_1 >> 2] = 1; 2856 HEAP32[$0_1 + 4 >> 2] = $1_1; 2857 break block3; 2858 } 2859 $7_1 = $0_1; 2860 block7 : { 2861 if (!$9_1) { 2862 $0_1 = $5_1 - $6_1 | 0; 2863 $0_1 = ($5_1 | 0) < ($6_1 | 0) ^ ($0_1 | 0) < 0 ? $0_1 >> 31 ^ -2147483648 : $0_1; 2864 break block7; 2865 } 2866 $0_1 = $5_1 + $6_1 | 0; 2867 $0_1 = ($6_1 | 0) < 0 ^ ($0_1 | 0) < ($5_1 | 0) ? $0_1 >> 31 ^ -2147483648 : $0_1; 2868 } 2869 $23($7_1, $1_1, $2_1, $3_1, $4_1, $0_1); 2870 } 2871 global$0 = $8_1 + 32 | 0; 2872 } 2873 2874 function $23($0_1, $1_1, $2_1, $3_1, $4_1, $5_1) { 2875 var $6_1 = 0, $7_1 = 0.0, $8_1 = 0.0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; 2876 $6_1 = global$0 - 32 | 0; 2877 global$0 = $6_1; 2878 $7_1 = +($3_1 >>> 0) + +($4_1 >>> 0) * 4294967296.0; 2879 block4 : { 2880 block : { 2881 block3 : { 2882 block2 : { 2883 block1 : { 2884 $3_1 = $5_1 >> 31; 2885 $3_1 = ($3_1 ^ $5_1) - $3_1 | 0; 2886 if ($3_1 >>> 0 >= 309) { 2887 while (1) { 2888 if ($7_1 == 0.0) { 2889 break block 2890 } 2891 if (($5_1 | 0) >= 0) { 2892 break block1 2893 } 2894 $7_1 = $7_1 / 1.e+308; 2895 $5_1 = $5_1 + 308 | 0; 2896 $3_1 = $5_1 >> 31; 2897 $3_1 = ($3_1 ^ $5_1) - $3_1 | 0; 2898 if ($3_1 >>> 0 > 308) { 2899 continue 2900 } 2901 break; 2902 } 2903 } 2904 $8_1 = HEAPF64[($3_1 << 3) + 1053792 >> 3]; 2905 if (($5_1 | 0) >= 0) { 2906 break block2 2907 } 2908 $7_1 = $7_1 / $8_1; 2909 break block; 2910 } 2911 HEAP32[$6_1 + 20 >> 2] = 14; 2912 $72($6_1, $1_1 + 12 | 0); 2913 (wasm2js_i32$0 = $0_1, wasm2js_i32$1 = $55($6_1 + 20 | 0, HEAP32[$6_1 >> 2], HEAP32[$6_1 + 4 >> 2])), HEAP32[wasm2js_i32$0 + 4 >> 2] = wasm2js_i32$1; 2914 break block3; 2915 } 2916 $7_1 = $7_1 * $8_1; 2917 if (Math_abs($7_1) != Infinity) { 2918 break block 2919 } 2920 HEAP32[$6_1 + 20 >> 2] = 14; 2921 $72($6_1 + 8 | 0, $1_1 + 12 | 0); 2922 (wasm2js_i32$0 = $0_1, wasm2js_i32$1 = $55($6_1 + 20 | 0, HEAP32[$6_1 + 8 >> 2], HEAP32[$6_1 + 12 >> 2])), HEAP32[wasm2js_i32$0 + 4 >> 2] = wasm2js_i32$1; 2923 } 2924 $1_1 = 1; 2925 break block4; 2926 } 2927 HEAPF64[$0_1 + 8 >> 3] = $2_1 ? $7_1 : -$7_1; 2928 $1_1 = 0; 2929 } 2930 HEAP32[$0_1 >> 2] = $1_1; 2931 global$0 = $6_1 + 32 | 0; 2932 } 2933 2934 function $24($0_1, $1_1, $2_1) { 2935 var $3_1 = 0, $4_1 = 0, $5_1 = 0, $6_1 = 0, $7_1 = 0, $8_1 = 0, $9_1 = 0, $10_1 = 0, $11_1 = 0; 2936 $3_1 = global$0 - 48 | 0; 2937 global$0 = $3_1; 2938 block1 : { 2939 block3 : { 2940 $5_1 = HEAP32[$1_1 + 20 >> 2]; 2941 $8_1 = HEAP32[$1_1 + 16 >> 2]; 2942 if ($5_1 >>> 0 < $8_1 >>> 0) { 2943 $7_1 = $5_1 + 1 | 0; 2944 HEAP32[$1_1 + 20 >> 2] = $7_1; 2945 $4_1 = $1_1 + 12 | 0; 2946 $10_1 = HEAP32[$1_1 + 12 >> 2]; 2947 $5_1 = HEAPU8[$10_1 + $5_1 | 0]; 2948 if (($5_1 | 0) == 48) { 2949 block : { 2950 if ($7_1 >>> 0 < $8_1 >>> 0) { 2951 if ((HEAPU8[$7_1 + $10_1 | 0] - 48 & 255) >>> 0 < 10) { 2952 break block 2953 } 2954 } 2955 $20($0_1, $1_1, $2_1, 0, 0); 2956 break block1; 2957 } 2958 HEAP32[$3_1 + 32 >> 2] = 13; 2959 $71($3_1 + 8 | 0, $4_1); 2960 $1_1 = $55($3_1 + 32 | 0, HEAP32[$3_1 + 8 >> 2], HEAP32[$3_1 + 12 >> 2]); 2961 HEAP32[$0_1 >> 2] = -1; 2962 HEAP32[$0_1 + 4 >> 2] = -1; 2963 HEAP32[$0_1 + 8 >> 2] = $1_1; 2964 break block1; 2965 } 2966 if (($5_1 - 49 & 255) >>> 0 >= 9) { 2967 HEAP32[$3_1 + 32 >> 2] = 13; 2968 $72($3_1 + 16 | 0, $4_1); 2969 $1_1 = $55($3_1 + 32 | 0, HEAP32[$3_1 + 16 >> 2], HEAP32[$3_1 + 20 >> 2]); 2970 HEAP32[$0_1 >> 2] = -1; 2971 HEAP32[$0_1 + 4 >> 2] = -1; 2972 HEAP32[$0_1 + 8 >> 2] = $1_1; 2973 break block1; 2974 } 2975 $9_1 = $5_1 - 48 & 255; 2976 block2 : { 2977 if ($7_1 >>> 0 >= $8_1 >>> 0) { 2978 break block2 2979 } 2980 while (1) { 2981 $5_1 = HEAPU8[$7_1 + $10_1 | 0] - 48 | 0; 2982 $4_1 = $5_1 & 255; 2983 if ($4_1 >>> 0 >= 10) { 2984 break block2 2985 } 2986 $11_1 = ($9_1 | 0) != -1717986919 | ($6_1 | 0) != 429496729 | $4_1 >>> 0 > 5; 2987 $4_1 = 429496729; 2988 if ($11_1 & (($4_1 | 0) == ($6_1 | 0) & $9_1 >>> 0 >= 2576980377 | $4_1 >>> 0 < $6_1 >>> 0)) { 2989 break block3 2990 } 2991 $7_1 = $7_1 + 1 | 0; 2992 HEAP32[$1_1 + 20 >> 2] = $7_1; 2993 $4_1 = $5_1 & 255; 2994 $5_1 = __wasm_i64_mul($9_1, $6_1, 10, 0) + $4_1 | 0; 2995 $6_1 = i64toi32_i32$HIGH_BITS; 2996 $6_1 = $4_1 >>> 0 > $5_1 >>> 0 ? $6_1 + 1 | 0 : $6_1; 2997 $9_1 = $5_1; 2998 if (($7_1 | 0) != ($8_1 | 0)) { 2999 continue 3000 } 3001 break; 3002 }; 3003 } 3004 $20($0_1, $1_1, $2_1, $9_1, $6_1); 3005 break block1; 3006 } 3007 HEAP32[$3_1 + 32 >> 2] = 5; 3008 $72($3_1 + 24 | 0, $1_1 + 12 | 0); 3009 $1_1 = $55($3_1 + 32 | 0, HEAP32[$3_1 + 24 >> 2], HEAP32[$3_1 + 28 >> 2]); 3010 HEAP32[$0_1 >> 2] = -1; 3011 HEAP32[$0_1 + 4 >> 2] = -1; 3012 HEAP32[$0_1 + 8 >> 2] = $1_1; 3013 break block1; 3014 } 3015 $5_1 = $3_1 + 32 | 0; 3016 $7_1 = $2_1; 3017 $2_1 = 0; 3018 block6 : { 3019 block5 : { 3020 $8_1 = HEAP32[$1_1 + 16 >> 2]; 3021 $4_1 = HEAP32[$1_1 + 20 >> 2]; 3022 block4 : { 3023 if ($8_1 >>> 0 <= $4_1 >>> 0) { 3024 break block4 3025 } 3026 $10_1 = $4_1 + 1 | 0; 3027 $8_1 = $8_1 - $4_1 | 0; 3028 $11_1 = $4_1 + HEAP32[$1_1 + 12 >> 2] | 0; 3029 while (1) { 3030 $4_1 = HEAPU8[$2_1 + $11_1 | 0]; 3031 if (($4_1 - 48 & 255) >>> 0 >= 10) { 3032 if (($4_1 | 0) == 46) { 3033 break block5 3034 } 3035 if (($4_1 | 0) != 69 & ($4_1 | 0) != 101) { 3036 break block4 3037 } 3038 $22($5_1, $1_1, $7_1, $9_1, $6_1, $2_1); 3039 break block6; 3040 } 3041 HEAP32[$1_1 + 20 >> 2] = $2_1 + $10_1; 3042 $2_1 = $2_1 + 1 | 0; 3043 if (($2_1 | 0) != ($8_1 | 0)) { 3044 continue 3045 } 3046 break; 3047 }; 3048 $2_1 = $8_1; 3049 } 3050 $23($5_1, $1_1, $7_1, $9_1, $6_1, $2_1); 3051 break block6; 3052 } 3053 $21($5_1, $1_1, $7_1, $9_1, $6_1, $2_1); 3054 } 3055 block7 : { 3056 if (HEAP32[$3_1 + 32 >> 2] == 1) { 3057 HEAP32[$0_1 + 8 >> 2] = HEAP32[$3_1 + 36 >> 2]; 3058 $6_1 = -1; 3059 $1_1 = -1; 3060 break block7; 3061 } 3062 HEAPF64[$0_1 + 8 >> 3] = HEAPF64[$3_1 + 40 >> 3]; 3063 $6_1 = 0; 3064 $1_1 = 0; 3065 } 3066 HEAP32[$0_1 >> 2] = $1_1; 3067 HEAP32[$0_1 + 4 >> 2] = $6_1; 3068 } 3069 global$0 = $3_1 + 48 | 0; 3070 } 3071 3072 function $25($0_1) { 3073 var $1_1 = 0, $2_1 = 0, $3_1 = 0, $4_1 = 0, $5_1 = 0; 3074 $3_1 = global$0 - 32 | 0; 3075 global$0 = $3_1; 3076 $2_1 = HEAP32[$0_1 + 20 >> 2]; 3077 $1_1 = $2_1 + 1 | 0; 3078 HEAP32[$0_1 + 20 >> 2] = $1_1; 3079 $4_1 = HEAP32[$0_1 + 16 >> 2]; 3080 block : { 3081 if ($4_1 >>> 0 <= $1_1 >>> 0) { 3082 break block 3083 } 3084 block1 : { 3085 switch (HEAPU8[$1_1 + HEAP32[$0_1 + 12 >> 2] | 0] - 43 | 0) { 3086 case 0: 3087 case 2: 3088 break block1; 3089 default: 3090 break block; 3091 }; 3092 } 3093 $1_1 = $2_1 + 2 | 0; 3094 HEAP32[$0_1 + 20 >> 2] = $1_1; 3095 } 3096 block3 : { 3097 block2 : { 3098 if ($1_1 >>> 0 >= $4_1 >>> 0) { 3099 break block2 3100 } 3101 $2_1 = $1_1 + 1 | 0; 3102 HEAP32[$0_1 + 20 >> 2] = $2_1; 3103 $5_1 = HEAP32[$0_1 + 12 >> 2]; 3104 if ((HEAPU8[$1_1 + $5_1 | 0] - 48 & 255) >>> 0 > 9) { 3105 break block2 3106 } 3107 $1_1 = 0; 3108 if ($2_1 >>> 0 >= $4_1 >>> 0) { 3109 break block3 3110 } 3111 while (1) { 3112 if ((HEAPU8[$2_1 + $5_1 | 0] - 48 & 255) >>> 0 > 9) { 3113 break block3 3114 } 3115 $2_1 = $2_1 + 1 | 0; 3116 HEAP32[$0_1 + 20 >> 2] = $2_1; 3117 if (($2_1 | 0) != ($4_1 | 0)) { 3118 continue 3119 } 3120 break; 3121 }; 3122 break block3; 3123 } 3124 HEAP32[$3_1 + 20 >> 2] = 13; 3125 $72($3_1 + 8 | 0, $0_1 + 12 | 0); 3126 $1_1 = $55($3_1 + 20 | 0, HEAP32[$3_1 + 8 >> 2], HEAP32[$3_1 + 12 >> 2]); 3127 } 3128 global$0 = $3_1 + 32 | 0; 3129 return $1_1; 3130 } 3131 3132 function $26($0_1, $1_1) { 3133 $0_1 = $0_1 | 0; 3134 $1_1 = $1_1 | 0; 3135 return $145($1_1, 1059387, 8) | 0; 3136 } 3137 3138 function $27($0_1, $1_1) { 3139 $0_1 = $0_1 | 0; 3140 $1_1 = $1_1 | 0; 3141 return $145($1_1, 1052870, 13) | 0; 3142 } 3143 3144 function $28($0_1, $1_1) { 3145 $0_1 = $0_1 | 0; 3146 $1_1 = $1_1 | 0; 3147 return $145($1_1, 1059250, 18) | 0; 3148 } 3149 3150 function $29($0_1) { 3151 $0_1 = $0_1 | 0; 3152 var $1_1 = 0; 3153 $1_1 = global$0 - 16 | 0; 3154 global$0 = $1_1; 3155 $35($1_1 + 4 | 0, $0_1, 1, 1); 3156 if (HEAP32[$1_1 + 4 >> 2] == 1) { 3157 $120(HEAP32[$1_1 + 8 >> 2], HEAP32[$1_1 + 12 >> 2]); 3158 wasm2js_trap(); 3159 } 3160 global$0 = $1_1 + 16 | 0; 3161 return HEAP32[$1_1 + 12 >> 2]; 3162 } 3163 3164 function $30($0_1, $1_1) { 3165 $0_1 = $0_1 | 0; 3166 $1_1 = $1_1 | 0; 3167 var $2_1 = 0; 3168 $2_1 = global$0 - 16 | 0; 3169 global$0 = $2_1; 3170 HEAP32[$2_1 + 12 >> 2] = 0; 3171 HEAP32[$2_1 + 8 >> 2] = $0_1; 3172 HEAP32[$2_1 + 4 >> 2] = $1_1; 3173 $46($2_1 + 4 | 0); 3174 global$0 = $2_1 + 16 | 0; 3175 } 3176 3177 function $31($0_1, $1_1) { 3178 $0_1 = $0_1 | 0; 3179 $1_1 = $1_1 | 0; 3180 var $2_1 = 0, $3_1 = 0, $4_1 = 0, $5_1 = 0, $6_1 = 0, $7_1 = 0, $8_1 = 0, $9_1 = 0, $10_1 = 0, $11_1 = 0, $12_1 = 0, $13_1 = 0, $14_1 = 0, $15_1 = 0, $16_1 = 0, $17_1 = 0, $18_1 = 0, $19_1 = 0, $20_1 = 0, $21_1 = 0, $22_1 = 0, $23_1 = 0, $24_1 = 0, $25_1 = 0, $26_1 = 0, $27_1 = 0, $28_1 = 0, $29_1 = 0, $30_1 = 0; 3181 $27_1 = global$0 - 32 | 0; 3182 global$0 = $27_1; 3183 $28_1 = $27_1 + 20 | 0; 3184 $3_1 = global$0 - 192 | 0; 3185 global$0 = $3_1; 3186 HEAP32[$3_1 + 136 >> 2] = 0; 3187 HEAP32[$3_1 + 132 >> 2] = $1_1; 3188 HEAP32[$3_1 + 128 >> 2] = $0_1; 3189 $15_1 = global$0 + -64 | 0; 3190 global$0 = $15_1; 3191 $8_1 = $15_1 + 4 | 0; 3192 HEAP8[$8_1 + 24 | 0] = 128; 3193 HEAP32[$8_1 + 8 >> 2] = 0; 3194 HEAP32[$8_1 >> 2] = 0; 3195 HEAP32[$8_1 + 4 >> 2] = 1; 3196 $21_1 = $3_1 + 128 | 0; 3197 $0_1 = $21_1; 3198 HEAP32[$8_1 + 20 >> 2] = HEAP32[$0_1 + 8 >> 2]; 3199 $13_1 = HEAP32[$0_1 + 4 >> 2]; 3200 HEAP32[$8_1 + 12 >> 2] = HEAP32[$0_1 >> 2]; 3201 HEAP32[$8_1 + 16 >> 2] = $13_1; 3202 $11_1 = $3_1 + 12 | 0; 3203 $4_1 = global$0 - 128 | 0; 3204 global$0 = $4_1; 3205 block1 : { 3206 block : { 3207 $0_1 = HEAP32[$8_1 + 20 >> 2]; 3208 $19_1 = HEAP32[$8_1 + 16 >> 2]; 3209 if ($0_1 >>> 0 < $19_1 >>> 0) { 3210 $20_1 = $8_1 + 12 | 0; 3211 $1_1 = HEAP32[$8_1 + 12 >> 2]; 3212 while (1) { 3213 $16_1 = HEAPU8[$0_1 + $1_1 | 0]; 3214 $2_1 = $16_1 - 9 | 0; 3215 if ($2_1 >>> 0 > 23 | !(1 << $2_1 & 8388627)) { 3216 break block 3217 } 3218 $0_1 = $0_1 + 1 | 0; 3219 HEAP32[$8_1 + 20 >> 2] = $0_1; 3220 if (($0_1 | 0) != ($19_1 | 0)) { 3221 continue 3222 } 3223 break; 3224 }; 3225 } 3226 HEAP32[$4_1 + 52 >> 2] = 5; 3227 $71($4_1 + 24 | 0, $8_1 + 12 | 0); 3228 $0_1 = $55($4_1 + 52 | 0, HEAP32[$4_1 + 24 >> 2], HEAP32[$4_1 + 28 >> 2]); 3229 HEAP32[$11_1 >> 2] = -2; 3230 break block1; 3231 } 3232 block66 : { 3233 block9 : { 3234 block8 : { 3235 block4 : { 3236 block10 : { 3237 block11 : { 3238 block58 : { 3239 block59 : { 3240 block5 : { 3241 block2 : { 3242 if (($16_1 | 0) != 91) { 3243 if (($16_1 | 0) == 123) { 3244 break block2 3245 } 3246 $0_1 = $0($12($8_1, $4_1 + 127 | 0, 1052500), $8_1); 3247 HEAP32[$11_1 >> 2] = -2; 3248 break block1; 3249 } 3250 $1_1 = HEAPU8[$8_1 + 24 | 0] - 1 | 0; 3251 HEAP8[$8_1 + 24 | 0] = $1_1; 3252 if ($1_1 & 255) { 3253 HEAP32[$8_1 + 20 >> 2] = $0_1 + 1; 3254 HEAP8[$4_1 + 96 | 0] = 1; 3255 HEAP32[$4_1 + 92 >> 2] = $8_1; 3256 $1_1 = $4_1 + 52 | 0; 3257 $0_1 = global$0 - 16 | 0; 3258 global$0 = $0_1; 3259 $5_1 = $4_1 + 92 | 0; 3260 $2_1 = $5_1; 3261 $7($0_1 + 8 | 0, $2_1); 3262 block3 : { 3263 if (HEAPU8[$0_1 + 8 | 0] == 1) { 3264 HEAP32[$1_1 + 4 >> 2] = HEAP32[$0_1 + 12 >> 2]; 3265 HEAP8[$1_1 | 0] = 1; 3266 break block3; 3267 } 3268 if (!HEAPU8[$0_1 + 9 | 0]) { 3269 HEAP16[$1_1 >> 1] = 65280; 3270 break block3; 3271 } 3272 $9($0_1 + 8 | 0, HEAP32[$2_1 >> 2]); 3273 if (!HEAPU8[$0_1 + 8 | 0]) { 3274 HEAP8[$1_1 + 1 | 0] = HEAPU8[$0_1 + 9 | 0]; 3275 HEAP8[$1_1 | 0] = 0; 3276 break block3; 3277 } 3278 HEAP32[$1_1 + 4 >> 2] = HEAP32[$0_1 + 12 >> 2]; 3279 HEAP8[$1_1 | 0] = 1; 3280 } 3281 global$0 = $0_1 + 16 | 0; 3282 if (HEAPU8[$4_1 + 52 | 0] == 1) { 3283 break block4 3284 } 3285 $16_1 = HEAPU8[$4_1 + 53 | 0]; 3286 if (($16_1 | 0) == 255) { 3287 break block5 3288 } 3289 $14($1_1, $5_1); 3290 $2_1 = HEAP32[$4_1 + 52 >> 2]; 3291 if (($2_1 | 0) == -3) { 3292 break block4 3293 } 3294 block7 : { 3295 block6 : { 3296 if (($2_1 | 0) != -2) { 3297 $0_1 = HEAP32[$4_1 + 56 >> 2]; 3298 $20_1 = HEAP32[$4_1 + 60 >> 2]; 3299 HEAP32[$4_1 + 112 >> 2] = $20_1; 3300 HEAP32[$4_1 + 108 >> 2] = $0_1; 3301 HEAP32[$4_1 + 104 >> 2] = $2_1; 3302 $14($1_1, $5_1); 3303 $19_1 = HEAP32[$4_1 + 52 >> 2]; 3304 if (($19_1 | 0) != -3) { 3305 break block6 3306 } 3307 $0_1 = HEAP32[$4_1 + 56 >> 2]; 3308 break block7; 3309 } 3310 $0_1 = $15(1); 3311 break block8; 3312 } 3313 if (($19_1 | 0) != -2) { 3314 $23_1 = HEAP32[$4_1 + 60 >> 2]; 3315 $24_1 = HEAP32[$4_1 + 56 >> 2]; 3316 break block9; 3317 } 3318 $0_1 = $15(2); 3319 } 3320 $2($4_1 + 104 | 0); 3321 break block8; 3322 } 3323 HEAP32[$4_1 + 52 >> 2] = 24; 3324 $71($4_1 + 8 | 0, $20_1); 3325 $0_1 = $55($4_1 + 52 | 0, HEAP32[$4_1 + 8 >> 2], HEAP32[$4_1 + 12 >> 2]); 3326 break block10; 3327 } 3328 $1_1 = HEAPU8[$8_1 + 24 | 0] - 1 | 0; 3329 HEAP8[$8_1 + 24 | 0] = $1_1; 3330 if (!($1_1 & 255)) { 3331 break block11 3332 } 3333 HEAP32[$8_1 + 20 >> 2] = $0_1 + 1; 3334 HEAP8[$4_1 + 88 | 0] = 1; 3335 HEAP32[$4_1 + 84 >> 2] = $8_1; 3336 HEAP32[$4_1 + 92 >> 2] = -2; 3337 HEAP32[$4_1 + 104 >> 2] = -2; 3338 $16($4_1 + 52 | 0, $4_1 + 84 | 0); 3339 block18 : { 3340 block12 : { 3341 if (HEAPU8[$4_1 + 52 | 0]) { 3342 break block12 3343 } 3344 $16_1 = 255; 3345 while (1) { 3346 block56 : { 3347 block17 : { 3348 switch (HEAPU8[$4_1 + 53 | 0]) { 3349 case 3: 3350 $6_1 = HEAP32[$4_1 + 84 >> 2]; 3351 $0_1 = $17($6_1); 3352 if ($0_1) { 3353 break block18 3354 } 3355 $17_1 = 0; 3356 $1_1 = 0; 3357 $7_1 = global$0 - 80 | 0; 3358 global$0 = $7_1; 3359 HEAP32[$6_1 + 8 >> 2] = 0; 3360 $2_1 = HEAP32[$6_1 + 20 >> 2]; 3361 $5_1 = HEAP32[$6_1 + 16 >> 2]; 3362 block26 : { 3363 block19 : { 3364 if ($2_1 >>> 0 >= $5_1 >>> 0) { 3365 break block19 3366 } 3367 $12_1 = $6_1 + 12 | 0; 3368 $14_1 = HEAP32[$6_1 + 12 >> 2]; 3369 while (1) { 3370 block20 : { 3371 block39 : { 3372 block38 : { 3373 block30 : { 3374 block25 : { 3375 block29 : { 3376 block23 : { 3377 block27 : { 3378 block24 : { 3379 block22 : { 3380 block28 : { 3381 $0_1 = HEAPU8[$2_1 + $14_1 | 0]; 3382 block21 : { 3383 if ($0_1 >>> 0 <= 31) { 3384 if ($0_1 - 9 >>> 0 < 2) { 3385 break block20 3386 } 3387 if (($0_1 | 0) != 13) { 3388 break block21 3389 } 3390 break block20; 3391 } 3392 if (($0_1 | 0) <= 44) { 3393 switch ($0_1 - 32 | 0) { 3394 case 0: 3395 break block20; 3396 case 2: 3397 break block22; 3398 default: 3399 break block21; 3400 } 3401 } 3402 if (($0_1 | 0) <= 109) { 3403 if (($0_1 | 0) == 45) { 3404 break block23 3405 } 3406 if (($0_1 | 0) == 91) { 3407 break block24 3408 } 3409 if (($0_1 | 0) != 102) { 3410 break block21 3411 } 3412 HEAP32[$6_1 + 20 >> 2] = $2_1 + 1; 3413 $2_1 = $13($6_1, 1052706, 4); 3414 if (!$2_1) { 3415 break block25 3416 } 3417 break block26; 3418 } 3419 if (($0_1 | 0) == 110) { 3420 break block27 3421 } 3422 if (($0_1 | 0) == 116) { 3423 break block28 3424 } 3425 if (($0_1 | 0) == 123) { 3426 break block24 3427 } 3428 } 3429 if (($0_1 - 48 & 255) >>> 0 < 10) { 3430 break block29 3431 } 3432 HEAP32[$7_1 + 68 >> 2] = 10; 3433 $71($7_1 + 56 | 0, $12_1); 3434 $2_1 = $55($7_1 + 68 | 0, HEAP32[$7_1 + 56 >> 2], HEAP32[$7_1 + 60 >> 2]); 3435 break block26; 3436 } 3437 HEAP32[$6_1 + 20 >> 2] = $2_1 + 1; 3438 $2_1 = $13($6_1, 1052703, 3); 3439 if (!$2_1) { 3440 break block25 3441 } 3442 break block26; 3443 } 3444 HEAP32[$6_1 + 20 >> 2] = $2_1 + 1; 3445 $2_1 = $70($12_1); 3446 if (!$2_1) { 3447 break block25 3448 } 3449 break block26; 3450 } 3451 $5_1 = $17_1 & 1; 3452 $2_1 = $5_1; 3453 $14_1 = HEAP32[$6_1 + 8 >> 2]; 3454 if ($2_1 >>> 0 > HEAP32[$6_1 >> 2] - $14_1 >>> 0) { 3455 $38($6_1, $14_1, $2_1, 1, 1) 3456 } 3457 $2_1 = HEAP32[$6_1 + 8 >> 2]; 3458 if ($5_1) { 3459 HEAP8[$2_1 + HEAP32[$6_1 + 4 >> 2] | 0] = $1_1; 3460 $2_1 = $2_1 + 1 | 0; 3461 } 3462 HEAP32[$6_1 + 8 >> 2] = $2_1; 3463 HEAP32[$6_1 + 20 >> 2] = HEAP32[$6_1 + 20 >> 2] + 1; 3464 $18_1 = 0; 3465 break block30; 3466 } 3467 HEAP32[$6_1 + 20 >> 2] = $2_1 + 1; 3468 $2_1 = $13($6_1, 1052480, 3); 3469 if ($2_1) { 3470 break block26 3471 } 3472 break block25; 3473 } 3474 HEAP32[$6_1 + 20 >> 2] = $2_1 + 1; 3475 } 3476 $0_1 = global$0 - 32 | 0; 3477 global$0 = $0_1; 3478 block34 : { 3479 block32 : { 3480 block31 : { 3481 $5_1 = HEAP32[$6_1 + 20 >> 2]; 3482 $14_1 = HEAP32[$6_1 + 16 >> 2]; 3483 if ($5_1 >>> 0 >= $14_1 >>> 0) { 3484 break block31 3485 } 3486 $2_1 = $5_1 + 1 | 0; 3487 HEAP32[$6_1 + 20 >> 2] = $2_1; 3488 block33 : { 3489 $18_1 = HEAP32[$6_1 + 12 >> 2]; 3490 $5_1 = HEAPU8[$5_1 + $18_1 | 0]; 3491 if (($5_1 | 0) == 48) { 3492 if ($2_1 >>> 0 >= $14_1 >>> 0) { 3493 break block32 3494 } 3495 if ((HEAPU8[$2_1 + $18_1 | 0] - 48 & 255) >>> 0 < 10) { 3496 break block33 3497 } 3498 break block32; 3499 } 3500 if (($5_1 - 49 & 255) >>> 0 > 8) { 3501 break block31 3502 } 3503 if ($2_1 >>> 0 >= $14_1 >>> 0) { 3504 break block32 3505 } 3506 while (1) { 3507 if ((HEAPU8[$2_1 + $18_1 | 0] - 48 & 255) >>> 0 > 9) { 3508 break block32 3509 } 3510 $2_1 = $2_1 + 1 | 0; 3511 HEAP32[$6_1 + 20 >> 2] = $2_1; 3512 if (($2_1 | 0) != ($14_1 | 0)) { 3513 continue 3514 } 3515 break; 3516 }; 3517 $5_1 = 0; 3518 break block34; 3519 } 3520 HEAP32[$0_1 + 20 >> 2] = 13; 3521 $71($0_1, $6_1 + 12 | 0); 3522 $5_1 = $55($0_1 + 20 | 0, HEAP32[$0_1 >> 2], HEAP32[$0_1 + 4 >> 2]); 3523 break block34; 3524 } 3525 HEAP32[$0_1 + 20 >> 2] = 13; 3526 $72($0_1 + 8 | 0, $6_1 + 12 | 0); 3527 $5_1 = $55($0_1 + 20 | 0, HEAP32[$0_1 + 8 >> 2], HEAP32[$0_1 + 12 >> 2]); 3528 break block34; 3529 } 3530 $5_1 = 0; 3531 if ($2_1 >>> 0 >= $14_1 >>> 0) { 3532 break block34 3533 } 3534 $2_1 = HEAPU8[$2_1 + $18_1 | 0]; 3535 if (!(($2_1 | 0) == 101 | ($2_1 | 0) == 69)) { 3536 if (($2_1 | 0) != 46) { 3537 break block34 3538 } 3539 $14_1 = 0; 3540 $2_1 = global$0 - 32 | 0; 3541 global$0 = $2_1; 3542 $5_1 = HEAP32[$6_1 + 20 >> 2] + 1 | 0; 3543 HEAP32[$6_1 + 20 >> 2] = $5_1; 3544 block37 : { 3545 block35 : { 3546 block36 : { 3547 $18_1 = HEAP32[$6_1 + 16 >> 2]; 3548 if ($5_1 >>> 0 < $18_1 >>> 0) { 3549 $25_1 = HEAP32[$6_1 + 12 >> 2]; 3550 while (1) { 3551 $26_1 = HEAPU8[$5_1 + $25_1 | 0]; 3552 if (($26_1 - 48 & 255) >>> 0 < 10) { 3553 $14_1 = 1; 3554 $5_1 = $5_1 + 1 | 0; 3555 HEAP32[$6_1 + 20 >> 2] = $5_1; 3556 if ($5_1 >>> 0 < $18_1 >>> 0) { 3557 continue 3558 } 3559 break block35; 3560 } 3561 break; 3562 }; 3563 if ($14_1) { 3564 break block36 3565 } 3566 } 3567 HEAP32[$2_1 + 20 >> 2] = 13; 3568 $71($2_1 + 8 | 0, $6_1 + 12 | 0); 3569 $5_1 = $55($2_1 + 20 | 0, HEAP32[$2_1 + 8 >> 2], HEAP32[$2_1 + 12 >> 2]); 3570 break block37; 3571 } 3572 if (($26_1 | 32) != 101) { 3573 break block35 3574 } 3575 $5_1 = $25($6_1); 3576 break block37; 3577 } 3578 $5_1 = 0; 3579 } 3580 global$0 = $2_1 + 32 | 0; 3581 break block34; 3582 } 3583 $5_1 = $25($6_1); 3584 } 3585 global$0 = $0_1 + 32 | 0; 3586 $2_1 = $5_1; 3587 if ($2_1) { 3588 break block26 3589 } 3590 } 3591 $18_1 = 1; 3592 if ($17_1 & 1) { 3593 $0_1 = $1_1; 3594 break block30; 3595 } 3596 $0_1 = HEAP32[$6_1 + 8 >> 2]; 3597 if (!$0_1) { 3598 break block38 3599 } 3600 $0_1 = $0_1 - 1 | 0; 3601 HEAP32[$6_1 + 8 >> 2] = $0_1; 3602 $0_1 = HEAPU8[$0_1 + HEAP32[$6_1 + 4 >> 2] | 0]; 3603 } 3604 $2_1 = HEAP32[$6_1 + 20 >> 2]; 3605 $5_1 = HEAP32[$6_1 + 16 >> 2]; 3606 if ($2_1 >>> 0 >= $5_1 >>> 0) { 3607 $1_1 = $0_1; 3608 break block39; 3609 } 3610 $25_1 = HEAP32[$6_1 + 4 >> 2]; 3611 $14_1 = HEAP32[$6_1 + 12 >> 2]; 3612 $17_1 = HEAP32[$6_1 + 8 >> 2]; 3613 $1_1 = $0_1; 3614 block54 : { 3615 block48 : { 3616 block53 : { 3617 block46 : { 3618 block47 : { 3619 block45 : { 3620 while (1) { 3621 block41 : { 3622 block42 : { 3623 $0_1 = HEAPU8[$2_1 + $14_1 | 0]; 3624 block40 : { 3625 if ($0_1 >>> 0 <= 12) { 3626 if ($0_1 - 9 >>> 0 < 2) { 3627 break block40 3628 } 3629 break block41; 3630 } 3631 if ($0_1 >>> 0 <= 31) { 3632 if (($0_1 | 0) == 13) { 3633 break block40 3634 } 3635 break block41; 3636 } 3637 if ($0_1 >>> 0 > 43) { 3638 break block42 3639 } 3640 if (($0_1 | 0) != 32) { 3641 break block41 3642 } 3643 } 3644 $2_1 = $2_1 + 1 | 0; 3645 HEAP32[$6_1 + 20 >> 2] = $2_1; 3646 if (($2_1 | 0) == ($5_1 | 0)) { 3647 break block39 3648 } 3649 continue; 3650 } 3651 block44 : { 3652 block43 : { 3653 if (($0_1 | 0) != 44) { 3654 if (($0_1 | 0) == 93) { 3655 break block43 3656 } 3657 if (($0_1 | 0) != 125) { 3658 break block41 3659 } 3660 if (($1_1 & 255) == 123) { 3661 break block44 3662 } 3663 break block41; 3664 } 3665 if (!$18_1) { 3666 break block45 3667 } 3668 $2_1 = $2_1 + 1 | 0; 3669 HEAP32[$6_1 + 20 >> 2] = $2_1; 3670 break block45; 3671 } 3672 if (($1_1 & 255) != 91) { 3673 break block41 3674 } 3675 } 3676 $2_1 = $2_1 + 1 | 0; 3677 HEAP32[$6_1 + 20 >> 2] = $2_1; 3678 if (!$17_1) { 3679 break block38 3680 } 3681 $17_1 = $17_1 - 1 | 0; 3682 HEAP32[$6_1 + 8 >> 2] = $17_1; 3683 $1_1 = HEAPU8[$17_1 + $25_1 | 0]; 3684 $18_1 = 1; 3685 if ($2_1 >>> 0 < $5_1 >>> 0) { 3686 continue 3687 } 3688 break block39; 3689 } 3690 break; 3691 }; 3692 if (!$18_1) { 3693 break block45 3694 } 3695 $0_1 = $1_1 & 255; 3696 $1_1 = 7; 3697 if (($0_1 | 0) == 91) { 3698 break block46 3699 } 3700 if (($0_1 | 0) == 123) { 3701 break block47 3702 } 3703 $129(1052710, 40, 1052768); 3704 wasm2js_trap(); 3705 } 3706 if (($1_1 & 255) != 123) { 3707 break block48 3708 } 3709 block51 : { 3710 block50 : { 3711 if ($2_1 >>> 0 < $5_1 >>> 0) { 3712 while (1) { 3713 $0_1 = HEAPU8[$2_1 + $14_1 | 0]; 3714 block49 : { 3715 if ($0_1 - 9 >>> 0 < 2) { 3716 break block49 3717 } 3718 block52 : { 3719 switch ($0_1 - 32 | 0) { 3720 case 0: 3721 break block49; 3722 case 1: 3723 break block50; 3724 case 2: 3725 break block51; 3726 default: 3727 break block52; 3728 }; 3729 } 3730 if (($0_1 | 0) != 13) { 3731 break block50 3732 } 3733 } 3734 $2_1 = $2_1 + 1 | 0; 3735 HEAP32[$6_1 + 20 >> 2] = $2_1; 3736 if (($2_1 | 0) != ($5_1 | 0)) { 3737 continue 3738 } 3739 break; 3740 } 3741 } 3742 HEAP32[$7_1 + 68 >> 2] = 3; 3743 $71($7_1 + 16 | 0, $12_1); 3744 $2_1 = $55($7_1 + 68 | 0, HEAP32[$7_1 + 16 >> 2], HEAP32[$7_1 + 20 >> 2]); 3745 break block26; 3746 } 3747 HEAP32[$7_1 + 68 >> 2] = 17; 3748 $71($7_1 + 8 | 0, $12_1); 3749 $2_1 = $55($7_1 + 68 | 0, HEAP32[$7_1 + 8 >> 2], HEAP32[$7_1 + 12 >> 2]); 3750 break block26; 3751 } 3752 HEAP32[$6_1 + 20 >> 2] = $2_1 + 1; 3753 $2_1 = $70($12_1); 3754 if ($2_1) { 3755 break block26 3756 } 3757 $2_1 = HEAP32[$6_1 + 20 >> 2]; 3758 $5_1 = HEAP32[$6_1 + 16 >> 2]; 3759 if ($2_1 >>> 0 < $5_1 >>> 0) { 3760 $14_1 = HEAP32[$12_1 >> 2]; 3761 while (1) { 3762 $0_1 = HEAPU8[$2_1 + $14_1 | 0]; 3763 $17_1 = $0_1 - 9 | 0; 3764 if ($17_1 >>> 0 > 23 | !(1 << $17_1 & 8388627)) { 3765 break block53 3766 } 3767 $2_1 = $2_1 + 1 | 0; 3768 HEAP32[$6_1 + 20 >> 2] = $2_1; 3769 if (($2_1 | 0) != ($5_1 | 0)) { 3770 continue 3771 } 3772 break; 3773 }; 3774 } 3775 HEAP32[$7_1 + 68 >> 2] = 3; 3776 $71($7_1 + 32 | 0, $12_1); 3777 $2_1 = $55($7_1 + 68 | 0, HEAP32[$7_1 + 32 >> 2], HEAP32[$7_1 + 36 >> 2]); 3778 break block26; 3779 } 3780 $1_1 = 8; 3781 } 3782 HEAP32[$7_1 + 68 >> 2] = $1_1; 3783 $71($7_1, $12_1); 3784 $2_1 = $55($7_1 + 68 | 0, HEAP32[$7_1 >> 2], HEAP32[$7_1 + 4 >> 2]); 3785 break block26; 3786 } 3787 if (($0_1 | 0) != 58) { 3788 break block54 3789 } 3790 $2_1 = $2_1 + 1 | 0; 3791 HEAP32[$6_1 + 20 >> 2] = $2_1; 3792 } 3793 $17_1 = 1; 3794 if ($2_1 >>> 0 < $5_1 >>> 0) { 3795 continue 3796 } 3797 break block19; 3798 } 3799 HEAP32[$7_1 + 68 >> 2] = 6; 3800 $71($7_1 + 24 | 0, $12_1); 3801 $2_1 = $55($7_1 + 68 | 0, HEAP32[$7_1 + 24 >> 2], HEAP32[$7_1 + 28 >> 2]); 3802 break block26; 3803 } 3804 $2_1 = 0; 3805 break block26; 3806 } 3807 block55 : { 3808 $0_1 = $1_1 & 255; 3809 if (($0_1 | 0) != 91) { 3810 if (($0_1 | 0) != 123) { 3811 break block55 3812 } 3813 $0_1 = 3; 3814 } else { 3815 $0_1 = 2 3816 } 3817 HEAP32[$7_1 + 68 >> 2] = $0_1; 3818 $71($7_1 + 48 | 0, $12_1); 3819 $2_1 = $55($7_1 + 68 | 0, HEAP32[$7_1 + 48 >> 2], HEAP32[$7_1 + 52 >> 2]); 3820 break block26; 3821 } 3822 $129(1052710, 40, 1052752); 3823 wasm2js_trap(); 3824 } 3825 $2_1 = $2_1 + 1 | 0; 3826 HEAP32[$6_1 + 20 >> 2] = $2_1; 3827 if (($2_1 | 0) != ($5_1 | 0)) { 3828 continue 3829 } 3830 break; 3831 }; 3832 } 3833 HEAP32[$7_1 + 68 >> 2] = 5; 3834 $71($7_1 + 40 | 0, $6_1 + 12 | 0); 3835 $2_1 = $55($7_1 + 68 | 0, HEAP32[$7_1 + 40 >> 2], HEAP32[$7_1 + 44 >> 2]); 3836 } 3837 global$0 = $7_1 + 80 | 0; 3838 $0_1 = $2_1; 3839 if (!$0_1) { 3840 break block56 3841 } 3842 break block18; 3843 case 0: 3844 if (($16_1 | 0) != 255) { 3845 HEAP32[$4_1 + 120 >> 2] = 5; 3846 HEAP32[$4_1 + 116 >> 2] = 1051672; 3847 HEAP32[$4_1 + 56 >> 2] = 1; 3848 HEAP32[$4_1 + 52 >> 2] = $4_1 + 116; 3849 $0_1 = $59(1051413, $4_1 + 52 | 0); 3850 break block18; 3851 } 3852 $0_1 = $4_1 + 52 | 0; 3853 $1_1 = HEAP32[$4_1 + 84 >> 2]; 3854 $2_1 = $17($1_1); 3855 block57 : { 3856 if ($2_1) { 3857 HEAP8[$0_1 | 0] = 1; 3858 HEAP32[$0_1 + 4 >> 2] = $2_1; 3859 break block57; 3860 } 3861 $9($0_1, $1_1); 3862 } 3863 if (HEAPU8[$4_1 + 52 | 0]) { 3864 break block12 3865 } 3866 $16_1 = HEAPU8[$4_1 + 53 | 0]; 3867 break block56; 3868 case 1: 3869 if (HEAP32[$4_1 + 92 >> 2] != -2) { 3870 HEAP32[$4_1 + 120 >> 2] = 4; 3871 HEAP32[$4_1 + 116 >> 2] = 1051677; 3872 HEAP32[$4_1 + 56 >> 2] = 1; 3873 HEAP32[$4_1 + 52 >> 2] = $4_1 + 116; 3874 $0_1 = $59(1051413, $4_1 + 52 | 0); 3875 break block18; 3876 } 3877 $18($4_1 + 52 | 0, $4_1 + 84 | 0); 3878 $0_1 = HEAP32[$4_1 + 56 >> 2]; 3879 $1_1 = HEAP32[$4_1 + 52 >> 2]; 3880 if (($1_1 | 0) == -2) { 3881 break block18 3882 } 3883 $2_1 = HEAP32[$4_1 + 60 >> 2]; 3884 if (HEAP32[$4_1 + 92 >> 2] != -2) { 3885 $2($4_1 + 92 | 0) 3886 } 3887 HEAP32[$4_1 + 100 >> 2] = $2_1; 3888 HEAP32[$4_1 + 96 >> 2] = $0_1; 3889 HEAP32[$4_1 + 92 >> 2] = $1_1; 3890 break block56; 3891 case 2: 3892 if (HEAP32[$4_1 + 104 >> 2] != -2) { 3893 HEAP32[$4_1 + 120 >> 2] = 7; 3894 HEAP32[$4_1 + 116 >> 2] = 1051681; 3895 HEAP32[$4_1 + 56 >> 2] = 1; 3896 HEAP32[$4_1 + 52 >> 2] = $4_1 + 116; 3897 $0_1 = $59(1051413, $4_1 + 52 | 0); 3898 break block18; 3899 } 3900 $18($4_1 + 52 | 0, $4_1 + 84 | 0); 3901 $0_1 = HEAP32[$4_1 + 56 >> 2]; 3902 $1_1 = HEAP32[$4_1 + 52 >> 2]; 3903 if (($1_1 | 0) == -2) { 3904 break block18 3905 } 3906 $2_1 = HEAP32[$4_1 + 60 >> 2]; 3907 if (HEAP32[$4_1 + 104 >> 2] != -2) { 3908 $2($4_1 + 104 | 0) 3909 } 3910 HEAP32[$4_1 + 112 >> 2] = $2_1; 3911 HEAP32[$4_1 + 108 >> 2] = $0_1; 3912 HEAP32[$4_1 + 104 >> 2] = $1_1; 3913 break block56; 3914 default: 3915 break block17; 3916 }; 3917 } 3918 if (($16_1 | 0) != 255) { 3919 $0_1 = HEAP32[$4_1 + 92 >> 2]; 3920 $2_1 = ($0_1 | 0) == -2 ? -1 : $0_1; 3921 $0_1 = HEAP32[$4_1 + 104 >> 2]; 3922 $19_1 = ($0_1 | 0) == -2 ? -1 : $0_1; 3923 $10_1 = HEAP32[$4_1 + 100 >> 2]; 3924 $22_1 = HEAP32[$4_1 + 96 >> 2]; 3925 $9_1 = $22_1; 3926 $1_1 = 32; 3927 $0_1 = 0; 3928 if (($1_1 & 63) >>> 0 >= 32) { 3929 $20_1 = $10_1 >>> $0_1 | 0 3930 } else { 3931 $20_1 = ((1 << $0_1) - 1 & $10_1) << 32 - $0_1 | $9_1 >>> $0_1 3932 } 3933 $23_1 = HEAP32[$4_1 + 108 >> 2]; 3934 $24_1 = HEAP32[$4_1 + 112 >> 2]; 3935 $0_1 = $22_1; 3936 break block58; 3937 } 3938 HEAP32[$4_1 + 120 >> 2] = 5; 3939 HEAP32[$4_1 + 116 >> 2] = 1051672; 3940 HEAP32[$4_1 + 56 >> 2] = 1; 3941 HEAP32[$4_1 + 52 >> 2] = $4_1 + 116; 3942 $0_1 = $59(1051393, $4_1 + 52 | 0); 3943 break block18; 3944 } 3945 $16($4_1 + 52 | 0, $4_1 + 84 | 0); 3946 if (!HEAPU8[$4_1 + 52 | 0]) { 3947 continue 3948 } 3949 break; 3950 }; 3951 } 3952 $0_1 = HEAP32[$4_1 + 56 >> 2]; 3953 } 3954 $2_1 = -2; 3955 if (HEAP32[$4_1 + 104 >> 2] == -2) { 3956 break block59 3957 } 3958 $2($4_1 + 104 | 0); 3959 break block59; 3960 } 3961 $2_1 = -2; 3962 $0_1 = $15(0); 3963 break block9; 3964 } 3965 if (HEAP32[$4_1 + 92 >> 2] != -2) { 3966 $2($4_1 + 92 | 0) 3967 } 3968 } 3969 HEAP8[$8_1 + 24 | 0] = HEAPU8[$8_1 + 24 | 0] + 1; 3970 $6_1 = global$0 - 48 | 0; 3971 global$0 = $6_1; 3972 $5_1 = HEAP32[$8_1 + 20 >> 2]; 3973 $12_1 = HEAP32[$8_1 + 16 >> 2]; 3974 block64 : { 3975 if ($5_1 >>> 0 < $12_1 >>> 0) { 3976 $7_1 = $8_1 + 12 | 0; 3977 $14_1 = HEAP32[$8_1 + 12 >> 2]; 3978 while (1) { 3979 block60 : { 3980 block63 : { 3981 block62 : { 3982 $1_1 = HEAPU8[$5_1 + $14_1 | 0]; 3983 block61 : { 3984 if ($1_1 >>> 0 <= 12) { 3985 if ($1_1 - 9 >>> 0 < 2) { 3986 break block60 3987 } 3988 break block61; 3989 } 3990 if ($1_1 >>> 0 <= 31) { 3991 if (($1_1 | 0) != 13) { 3992 break block61 3993 } 3994 break block60; 3995 } 3996 if (($1_1 | 0) == 32) { 3997 break block60 3998 } 3999 if (($1_1 | 0) == 125) { 4000 break block62 4001 } 4002 if (($1_1 | 0) == 44) { 4003 break block63 4004 } 4005 } 4006 HEAP32[$6_1 + 36 >> 2] = 22; 4007 $71($6_1 + 8 | 0, $7_1); 4008 $1_1 = $55($6_1 + 36 | 0, HEAP32[$6_1 + 8 >> 2], HEAP32[$6_1 + 12 >> 2]); 4009 break block64; 4010 } 4011 HEAP32[$8_1 + 20 >> 2] = $5_1 + 1; 4012 $1_1 = 0; 4013 break block64; 4014 } 4015 HEAP32[$6_1 + 36 >> 2] = 21; 4016 $71($6_1 + 24 | 0, $7_1); 4017 $1_1 = $55($6_1 + 36 | 0, HEAP32[$6_1 + 24 >> 2], HEAP32[$6_1 + 28 >> 2]); 4018 break block64; 4019 } 4020 $5_1 = $5_1 + 1 | 0; 4021 HEAP32[$8_1 + 20 >> 2] = $5_1; 4022 if (($5_1 | 0) != ($12_1 | 0)) { 4023 continue 4024 } 4025 break; 4026 }; 4027 } 4028 HEAP32[$6_1 + 36 >> 2] = 3; 4029 $71($6_1 + 16 | 0, $8_1 + 12 | 0); 4030 $1_1 = $55($6_1 + 36 | 0, HEAP32[$6_1 + 16 >> 2], HEAP32[$6_1 + 20 >> 2]); 4031 } 4032 global$0 = $6_1 + 48 | 0; 4033 HEAP32[$4_1 + 80 >> 2] = $1_1; 4034 HEAP8[$4_1 + 76 | 0] = $16_1; 4035 HEAP32[$4_1 + 72 >> 2] = $24_1; 4036 HEAP32[$4_1 + 68 >> 2] = $23_1; 4037 HEAP32[$4_1 + 64 >> 2] = $19_1; 4038 HEAP32[$4_1 + 60 >> 2] = $20_1; 4039 HEAP32[$4_1 + 56 >> 2] = $0_1; 4040 HEAP32[$4_1 + 52 >> 2] = $2_1; 4041 block65 : { 4042 if (($2_1 | 0) != -2) { 4043 if ($1_1) { 4044 break block65 4045 } 4046 $1_1 = $4_1 + 60 | 0; 4047 HEAP32[$4_1 + 48 >> 2] = HEAP32[$1_1 + 16 >> 2]; 4048 $9_1 = HEAP32[$1_1 + 12 >> 2]; 4049 HEAP32[$4_1 + 40 >> 2] = HEAP32[$1_1 + 8 >> 2]; 4050 HEAP32[$4_1 + 44 >> 2] = $9_1; 4051 $13_1 = HEAP32[$1_1 + 4 >> 2]; 4052 HEAP32[$4_1 + 32 >> 2] = HEAP32[$1_1 >> 2]; 4053 HEAP32[$4_1 + 36 >> 2] = $13_1; 4054 break block66; 4055 } 4056 if (!$1_1) { 4057 break block66 4058 } 4059 $3($4_1 + 80 | 0); 4060 break block66; 4061 } 4062 $2($4_1 + 52 | 0); 4063 $2($4_1 - -64 | 0); 4064 $2_1 = -2; 4065 $0_1 = $1_1; 4066 break block66; 4067 } 4068 HEAP32[$4_1 + 52 >> 2] = 24; 4069 $71($4_1 + 16 | 0, $20_1); 4070 $0_1 = $55($4_1 + 52 | 0, HEAP32[$4_1 + 16 >> 2], HEAP32[$4_1 + 20 >> 2]); 4071 } 4072 HEAP32[$11_1 >> 2] = -2; 4073 break block1; 4074 } 4075 $0_1 = HEAP32[$4_1 + 56 >> 2]; 4076 } 4077 $2_1 = -2; 4078 } 4079 HEAP8[$8_1 + 24 | 0] = HEAPU8[$8_1 + 24 | 0] + 1; 4080 $5_1 = global$0 - 48 | 0; 4081 global$0 = $5_1; 4082 $1_1 = HEAP32[$8_1 + 20 >> 2]; 4083 $7_1 = HEAP32[$8_1 + 16 >> 2]; 4084 block71 : { 4085 if ($1_1 >>> 0 < $7_1 >>> 0) { 4086 $12_1 = $8_1 + 12 | 0; 4087 $14_1 = HEAP32[$8_1 + 12 >> 2]; 4088 while (1) { 4089 block67 : { 4090 block70 : { 4091 block69 : { 4092 $6_1 = HEAPU8[$1_1 + $14_1 | 0]; 4093 block68 : { 4094 if ($6_1 >>> 0 <= 12) { 4095 if ($6_1 - 9 >>> 0 < 2) { 4096 break block67 4097 } 4098 break block68; 4099 } 4100 if ($6_1 >>> 0 <= 31) { 4101 if (($6_1 | 0) != 13) { 4102 break block68 4103 } 4104 break block67; 4105 } 4106 if (($6_1 | 0) == 32) { 4107 break block67 4108 } 4109 if (($6_1 | 0) == 93) { 4110 break block69 4111 } 4112 if (($6_1 | 0) == 44) { 4113 break block70 4114 } 4115 } 4116 HEAP32[$5_1 + 36 >> 2] = 22; 4117 $71($5_1, $12_1); 4118 $1_1 = $55($5_1 + 36 | 0, HEAP32[$5_1 >> 2], HEAP32[$5_1 + 4 >> 2]); 4119 break block71; 4120 } 4121 HEAP32[$8_1 + 20 >> 2] = $1_1 + 1; 4122 $1_1 = 0; 4123 break block71; 4124 } 4125 $1_1 = $1_1 + 1 | 0; 4126 HEAP32[$8_1 + 20 >> 2] = $1_1; 4127 block72 : { 4128 if ($1_1 >>> 0 >= $7_1 >>> 0) { 4129 break block72 4130 } 4131 while (1) { 4132 $6_1 = HEAPU8[$1_1 + $14_1 | 0]; 4133 $17_1 = $6_1 - 9 | 0; 4134 if (!($17_1 >>> 0 > 23 | !(1 << $17_1 & 8388627))) { 4135 $1_1 = $1_1 + 1 | 0; 4136 HEAP32[$8_1 + 20 >> 2] = $1_1; 4137 if (($1_1 | 0) != ($7_1 | 0)) { 4138 continue 4139 } 4140 break block72; 4141 } 4142 break; 4143 }; 4144 if (($6_1 | 0) != 93) { 4145 break block72 4146 } 4147 HEAP32[$5_1 + 36 >> 2] = 21; 4148 $71($5_1 + 24 | 0, $12_1); 4149 $1_1 = $55($5_1 + 36 | 0, HEAP32[$5_1 + 24 >> 2], HEAP32[$5_1 + 28 >> 2]); 4150 break block71; 4151 } 4152 HEAP32[$5_1 + 36 >> 2] = 22; 4153 $71($5_1 + 16 | 0, $12_1); 4154 $1_1 = $55($5_1 + 36 | 0, HEAP32[$5_1 + 16 >> 2], HEAP32[$5_1 + 20 >> 2]); 4155 break block71; 4156 } 4157 $1_1 = $1_1 + 1 | 0; 4158 HEAP32[$8_1 + 20 >> 2] = $1_1; 4159 if (($1_1 | 0) != ($7_1 | 0)) { 4160 continue 4161 } 4162 break; 4163 }; 4164 } 4165 HEAP32[$5_1 + 36 >> 2] = 2; 4166 $71($5_1 + 8 | 0, $8_1 + 12 | 0); 4167 $1_1 = $55($5_1 + 36 | 0, HEAP32[$5_1 + 8 >> 2], HEAP32[$5_1 + 12 >> 2]); 4168 } 4169 global$0 = $5_1 + 48 | 0; 4170 HEAP32[$4_1 + 80 >> 2] = $1_1; 4171 HEAP8[$4_1 + 76 | 0] = $16_1; 4172 HEAP32[$4_1 + 72 >> 2] = $23_1; 4173 HEAP32[$4_1 + 68 >> 2] = $24_1; 4174 HEAP32[$4_1 + 64 >> 2] = $19_1; 4175 HEAP32[$4_1 + 60 >> 2] = $20_1; 4176 HEAP32[$4_1 + 56 >> 2] = $0_1; 4177 HEAP32[$4_1 + 52 >> 2] = $2_1; 4178 block74 : { 4179 block73 : { 4180 if (($2_1 | 0) == -2) { 4181 if ($1_1) { 4182 break block73 4183 } 4184 break block74; 4185 } 4186 if (!$1_1) { 4187 $1_1 = $4_1 + 60 | 0; 4188 HEAP32[$4_1 + 48 >> 2] = HEAP32[$1_1 + 16 >> 2]; 4189 $9_1 = HEAP32[$1_1 + 12 >> 2]; 4190 HEAP32[$4_1 + 40 >> 2] = HEAP32[$1_1 + 8 >> 2]; 4191 HEAP32[$4_1 + 44 >> 2] = $9_1; 4192 $13_1 = HEAP32[$1_1 + 4 >> 2]; 4193 HEAP32[$4_1 + 32 >> 2] = HEAP32[$1_1 >> 2]; 4194 HEAP32[$4_1 + 36 >> 2] = $13_1; 4195 break block66; 4196 } 4197 $2($4_1 + 52 | 0); 4198 $2($4_1 - -64 | 0); 4199 $2_1 = -2; 4200 $0_1 = $1_1; 4201 break block66; 4202 } 4203 $3($4_1 + 80 | 0); 4204 } 4205 $2_1 = -2; 4206 } 4207 block75 : { 4208 if (($2_1 | 0) == -2) { 4209 $0_1 = $0($0_1, $8_1); 4210 break block75; 4211 } 4212 HEAP32[$11_1 + 24 >> 2] = HEAP32[$4_1 + 48 >> 2]; 4213 $9_1 = HEAP32[$4_1 + 44 >> 2]; 4214 HEAP32[$11_1 + 16 >> 2] = HEAP32[$4_1 + 40 >> 2]; 4215 HEAP32[$11_1 + 20 >> 2] = $9_1; 4216 $13_1 = HEAP32[$4_1 + 36 >> 2]; 4217 HEAP32[$11_1 + 8 >> 2] = HEAP32[$4_1 + 32 >> 2]; 4218 HEAP32[$11_1 + 12 >> 2] = $13_1; 4219 } 4220 HEAP32[$11_1 >> 2] = $2_1; 4221 } 4222 HEAP32[$11_1 + 4 >> 2] = $0_1; 4223 global$0 = $4_1 + 128 | 0; 4224 block76 : { 4225 if (HEAP32[$11_1 >> 2] == -2) { 4226 break block76 4227 } 4228 HEAP32[$15_1 + 56 >> 2] = HEAP32[$11_1 + 24 >> 2]; 4229 $9_1 = HEAP32[$11_1 + 20 >> 2]; 4230 HEAP32[$15_1 + 48 >> 2] = HEAP32[$11_1 + 16 >> 2]; 4231 HEAP32[$15_1 + 52 >> 2] = $9_1; 4232 $9_1 = $15_1; 4233 $13_1 = HEAP32[$11_1 + 12 >> 2]; 4234 HEAP32[$9_1 + 40 >> 2] = HEAP32[$11_1 + 8 >> 2]; 4235 HEAP32[$9_1 + 44 >> 2] = $13_1; 4236 $9_1 = HEAP32[$11_1 + 4 >> 2]; 4237 HEAP32[$15_1 + 32 >> 2] = HEAP32[$11_1 >> 2]; 4238 HEAP32[$15_1 + 36 >> 2] = $9_1; 4239 $2_1 = 0; 4240 $0_1 = global$0 - 32 | 0; 4241 global$0 = $0_1; 4242 $1_1 = HEAP32[$8_1 + 20 >> 2]; 4243 $5_1 = HEAP32[$8_1 + 16 >> 2]; 4244 block77 : { 4245 if ($1_1 >>> 0 >= $5_1 >>> 0) { 4246 break block77 4247 } 4248 $4_1 = $8_1 + 12 | 0; 4249 $6_1 = HEAP32[$8_1 + 12 >> 2]; 4250 while (1) { 4251 $7_1 = HEAPU8[$1_1 + $6_1 | 0] - 9 | 0; 4252 if (!($7_1 >>> 0 > 23 | !(1 << $7_1 & 8388627))) { 4253 $1_1 = $1_1 + 1 | 0; 4254 HEAP32[$8_1 + 20 >> 2] = $1_1; 4255 if (($1_1 | 0) != ($5_1 | 0)) { 4256 continue 4257 } 4258 break block77; 4259 } 4260 break; 4261 }; 4262 HEAP32[$0_1 + 20 >> 2] = 22; 4263 $71($0_1 + 8 | 0, $4_1); 4264 $2_1 = $55($0_1 + 20 | 0, HEAP32[$0_1 + 8 >> 2], HEAP32[$0_1 + 12 >> 2]); 4265 } 4266 global$0 = $0_1 + 32 | 0; 4267 if (!$2_1) { 4268 break block76 4269 } 4270 HEAP32[$11_1 >> 2] = -2; 4271 HEAP32[$11_1 + 4 >> 2] = $2_1; 4272 $2($15_1 + 32 | 0); 4273 $2($15_1 + 44 | 0); 4274 } 4275 $46($15_1 + 4 | 0); 4276 global$0 = $15_1 - -64 | 0; 4277 block142 : { 4278 block138 : { 4279 block78 : { 4280 block79 : { 4281 block81 : { 4282 if (HEAP32[$3_1 + 12 >> 2] == -2) { 4283 HEAP32[$3_1 + 72 >> 2] = HEAP32[$3_1 + 16 >> 2]; 4284 HEAP32[$3_1 + 112 >> 2] = 0; 4285 HEAP32[$3_1 + 104 >> 2] = 0; 4286 $35($21_1, 4, 1, 1); 4287 $0_1 = HEAP32[$3_1 + 132 >> 2]; 4288 if (HEAP32[$3_1 + 128 >> 2] == 1) { 4289 break block78 4290 } 4291 $1_1 = HEAP32[$3_1 + 136 >> 2]; 4292 $10_1 = 1701605234; 4293 HEAP8[$1_1 | 0] = $10_1; 4294 HEAP8[$1_1 + 1 | 0] = $10_1 >>> 8; 4295 HEAP8[$1_1 + 2 | 0] = $10_1 >>> 16; 4296 HEAP8[$1_1 + 3 | 0] = $10_1 >>> 24; 4297 HEAP32[$3_1 + 88 >> 2] = 4; 4298 HEAP32[$3_1 + 84 >> 2] = $1_1; 4299 HEAP32[$3_1 + 80 >> 2] = $0_1; 4300 $6($21_1, 1052596); 4301 if (HEAPU8[$3_1 + 128 | 0] == 255) { 4302 break block79 4303 } 4304 $13_1 = HEAP32[$3_1 + 148 >> 2]; 4305 HEAP32[$3_1 + 56 >> 2] = HEAP32[$3_1 + 144 >> 2]; 4306 HEAP32[$3_1 + 60 >> 2] = $13_1; 4307 $9_1 = HEAP32[$3_1 + 140 >> 2]; 4308 HEAP32[$3_1 + 48 >> 2] = HEAP32[$3_1 + 136 >> 2]; 4309 HEAP32[$3_1 + 52 >> 2] = $9_1; 4310 $13_1 = HEAP32[$3_1 + 132 >> 2]; 4311 HEAP32[$3_1 + 40 >> 2] = HEAP32[$3_1 + 128 >> 2]; 4312 HEAP32[$3_1 + 44 >> 2] = $13_1; 4313 $58($21_1, $3_1 + 104 | 0, $3_1 + 80 | 0, $3_1 + 40 | 0); 4314 if (HEAPU8[$3_1 + 128 | 0] != 255) { 4315 $4($21_1) 4316 } 4317 $1_1 = $3_1 + 128 | 0; 4318 $35($1_1, 3, 1, 1); 4319 $0_1 = HEAP32[$3_1 + 132 >> 2]; 4320 if (HEAP32[$3_1 + 128 >> 2] == 1) { 4321 break block78 4322 } 4323 $2_1 = HEAP32[$3_1 + 136 >> 2]; 4324 HEAP8[$2_1 + 2 | 0] = HEAPU8[1052578]; 4325 $10_1 = 1052576; 4326 $10_1 = HEAPU8[$10_1 | 0] | HEAPU8[$10_1 + 1 | 0] << 8; 4327 HEAP8[$2_1 | 0] = $10_1; 4328 HEAP8[$2_1 + 1 | 0] = $10_1 >>> 8; 4329 HEAP32[$3_1 + 88 >> 2] = 3; 4330 HEAP32[$3_1 + 84 >> 2] = $2_1; 4331 HEAP32[$3_1 + 80 >> 2] = $0_1; 4332 HEAP32[$3_1 + 132 >> 2] = 5; 4333 HEAP32[$3_1 + 128 >> 2] = $3_1 + 72; 4334 $2_1 = $3_1 + 116 | 0; 4335 $124($2_1, 1049184, $1_1); 4336 $0_1 = global$0 - 16 | 0; 4337 global$0 = $0_1; 4338 $6_1 = HEAP32[$2_1 + 4 >> 2]; 4339 $2_1 = HEAP32[$2_1 + 8 >> 2]; 4340 $35($0_1 + 4 | 0, $2_1, 1, 1); 4341 $5_1 = HEAP32[$0_1 + 8 >> 2]; 4342 block80 : { 4343 if (HEAP32[$0_1 + 4 >> 2] != 1) { 4344 $4_1 = HEAP32[$0_1 + 12 >> 2]; 4345 if ($2_1) { 4346 wasm2js_memory_copy($4_1, $6_1, $2_1) 4347 } 4348 HEAP32[$1_1 + 12 >> 2] = $2_1; 4349 HEAP32[$1_1 + 8 >> 2] = $4_1; 4350 HEAP32[$1_1 + 4 >> 2] = $5_1; 4351 HEAP8[$1_1 | 0] = 3; 4352 global$0 = $0_1 + 16 | 0; 4353 break block80; 4354 } 4355 $120($5_1, HEAP32[$0_1 + 12 >> 2]); 4356 wasm2js_trap(); 4357 } 4358 if (HEAPU8[$3_1 + 128 | 0] == 255) { 4359 break block79 4360 } 4361 $9_1 = HEAP32[$3_1 + 148 >> 2]; 4362 HEAP32[$3_1 + 56 >> 2] = HEAP32[$3_1 + 144 >> 2]; 4363 HEAP32[$3_1 + 60 >> 2] = $9_1; 4364 $13_1 = HEAP32[$3_1 + 140 >> 2]; 4365 HEAP32[$3_1 + 48 >> 2] = HEAP32[$3_1 + 136 >> 2]; 4366 HEAP32[$3_1 + 52 >> 2] = $13_1; 4367 $9_1 = HEAP32[$3_1 + 132 >> 2]; 4368 HEAP32[$3_1 + 40 >> 2] = HEAP32[$3_1 + 128 >> 2]; 4369 HEAP32[$3_1 + 44 >> 2] = $9_1; 4370 $58($1_1, $3_1 + 104 | 0, $3_1 + 80 | 0, $3_1 + 40 | 0); 4371 if (HEAPU8[$3_1 + 128 | 0] != 255) { 4372 $4($1_1) 4373 } 4374 $46($3_1 + 116 | 0); 4375 $13_1 = HEAP32[$3_1 + 108 >> 2]; 4376 HEAP32[$3_1 + 84 >> 2] = HEAP32[$3_1 + 104 >> 2]; 4377 HEAP32[$3_1 + 88 >> 2] = $13_1; 4378 HEAP32[$3_1 + 92 >> 2] = HEAP32[$3_1 + 112 >> 2]; 4379 HEAP8[$3_1 + 80 | 0] = 5; 4380 $3($3_1 + 72 | 0); 4381 break block81; 4382 } 4383 $0_1 = HEAP32[$3_1 + 36 >> 2]; 4384 HEAP32[$3_1 + 64 >> 2] = $0_1; 4385 $9_1 = HEAP32[$3_1 + 32 >> 2]; 4386 HEAP32[$3_1 + 56 >> 2] = HEAP32[$3_1 + 28 >> 2]; 4387 HEAP32[$3_1 + 60 >> 2] = $9_1; 4388 $13_1 = HEAP32[$3_1 + 24 >> 2]; 4389 HEAP32[$3_1 + 48 >> 2] = HEAP32[$3_1 + 20 >> 2]; 4390 HEAP32[$3_1 + 52 >> 2] = $13_1; 4391 $9_1 = HEAP32[$3_1 + 16 >> 2]; 4392 HEAP32[$3_1 + 40 >> 2] = HEAP32[$3_1 + 12 >> 2]; 4393 HEAP32[$3_1 + 44 >> 2] = $9_1; 4394 $0_1 = $0_1 & 255; 4395 $18_1 = HEAPU8[$0_1 + 1052900 | 0]; 4396 block85 : { 4397 block82 : { 4398 if (($0_1 | 0) == 3 | $0_1 >>> 0 > 4) { 4399 break block82 4400 } 4401 $29_1 = 29; 4402 $17_1 = 1052614; 4403 block83 : { 4404 if (HEAP32[$3_1 + 40 >> 2] == -1) { 4405 break block83 4406 } 4407 if (HEAP32[$3_1 + 48 >> 2] != 4) { 4408 break block83 4409 } 4410 $0_1 = HEAP32[$3_1 + 44 >> 2]; 4411 if ((HEAPU8[$0_1 | 0] | HEAPU8[$0_1 + 1 | 0] << 8 | (HEAPU8[$0_1 + 2 | 0] << 16 | HEAPU8[$0_1 + 3 | 0] << 24)) != 1752392002) { 4412 break block83 4413 } 4414 $29_1 = 0; 4415 $7_1 = HEAP32[$3_1 + 52 >> 2] == -1; 4416 if ($7_1) { 4417 break block82 4418 } 4419 $4_1 = HEAP32[$3_1 + 56 >> 2]; 4420 $6_1 = HEAP32[$3_1 + 60 >> 2]; 4421 $8_1 = $4_1 + $6_1 | 0; 4422 if ($6_1) { 4423 $5_1 = $4_1; 4424 while (1) { 4425 $0_1 = HEAP8[$5_1 | 0]; 4426 block84 : { 4427 if (($0_1 | 0) >= 0) { 4428 $1_1 = $0_1 & 255; 4429 $5_1 = $5_1 + 1 | 0; 4430 break block84; 4431 } 4432 $2_1 = HEAPU8[$5_1 + 1 | 0] & 63; 4433 $1_1 = $0_1 & 31; 4434 if ($0_1 >>> 0 <= 4294967263) { 4435 $1_1 = $2_1 | $1_1 << 6; 4436 $5_1 = $5_1 + 2 | 0; 4437 break block84; 4438 } 4439 $2_1 = HEAPU8[$5_1 + 2 | 0] & 63 | $2_1 << 6; 4440 if ($0_1 >>> 0 < 4294967280) { 4441 $1_1 = $1_1 << 12 | $2_1; 4442 $5_1 = $5_1 + 3 | 0; 4443 break block84; 4444 } 4445 $1_1 = $1_1 << 18 & 1835008 | (HEAPU8[$5_1 + 3 | 0] & 63 | $2_1 << 6); 4446 $5_1 = $5_1 + 4 | 0; 4447 } 4448 $2_1 = 0; 4449 $0_1 = -64; 4450 while (1) { 4451 $2_1 = ($1_1 | 0) == HEAP32[$0_1 + 1052848 >> 2] | $2_1; 4452 $0_1 = $0_1 + 4 | 0; 4453 if ($0_1) { 4454 continue 4455 } 4456 break; 4457 }; 4458 $17_1 = 1; 4459 if ($2_1 & 1) { 4460 break block85 4461 } 4462 $0_1 = 64; 4463 while (1) { 4464 if (($1_1 | 0) == HEAP32[$0_1 + 1052784 >> 2]) { 4465 break block85 4466 } 4467 $0_1 = $0_1 + 4 | 0; 4468 if (($0_1 | 0) != 84) { 4469 continue 4470 } 4471 break; 4472 }; 4473 if (($5_1 | 0) != ($8_1 | 0)) { 4474 continue 4475 } 4476 break; 4477 }; 4478 } 4479 $17_1 = 1; 4480 HEAP16[$3_1 + 156 >> 1] = 1; 4481 HEAP32[$3_1 + 152 >> 2] = 0; 4482 HEAP32[$3_1 + 148 >> 2] = $8_1; 4483 $0_1 = $7_1 ? 0 : $4_1; 4484 HEAP32[$3_1 + 144 >> 2] = $0_1; 4485 HEAP32[$3_1 + 140 >> 2] = $6_1; 4486 HEAP32[$3_1 + 136 >> 2] = $0_1; 4487 HEAP32[$3_1 + 132 >> 2] = $6_1; 4488 HEAP32[$3_1 + 128 >> 2] = 0; 4489 $6_1 = $3_1 + 80 | 0; 4490 $0_1 = global$0 + -64 | 0; 4491 global$0 = $0_1; 4492 $1_1 = $3_1 + 128 | 0; 4493 $1($0_1 + 8 | 0, $1_1); 4494 block88 : { 4495 block86 : { 4496 $4_1 = HEAP32[$0_1 + 8 >> 2]; 4497 block87 : { 4498 if ($4_1) { 4499 $8_1 = HEAP32[$0_1 + 12 >> 2]; 4500 $7_1 = $0_1 + 32 | 0; 4501 $35($7_1, 4, 4, 8); 4502 $2_1 = HEAP32[$0_1 + 36 >> 2]; 4503 if (HEAP32[$0_1 + 32 >> 2] == 1) { 4504 break block86 4505 } 4506 $5_1 = HEAP32[$0_1 + 40 >> 2]; 4507 HEAP32[$5_1 + 4 >> 2] = $8_1; 4508 HEAP32[$5_1 >> 2] = $4_1; 4509 HEAP32[$0_1 + 28 >> 2] = 1; 4510 HEAP32[$0_1 + 24 >> 2] = $5_1; 4511 HEAP32[$0_1 + 20 >> 2] = $2_1; 4512 $13_1 = HEAP32[$1_1 + 28 >> 2]; 4513 HEAP32[$0_1 + 56 >> 2] = HEAP32[$1_1 + 24 >> 2]; 4514 HEAP32[$0_1 + 60 >> 2] = $13_1; 4515 $9_1 = HEAP32[$1_1 + 20 >> 2]; 4516 HEAP32[$0_1 + 48 >> 2] = HEAP32[$1_1 + 16 >> 2]; 4517 HEAP32[$0_1 + 52 >> 2] = $9_1; 4518 $13_1 = HEAP32[$1_1 + 12 >> 2]; 4519 HEAP32[$0_1 + 40 >> 2] = HEAP32[$1_1 + 8 >> 2]; 4520 HEAP32[$0_1 + 44 >> 2] = $13_1; 4521 $9_1 = HEAP32[$1_1 + 4 >> 2]; 4522 HEAP32[$0_1 + 32 >> 2] = HEAP32[$1_1 >> 2]; 4523 HEAP32[$0_1 + 36 >> 2] = $9_1; 4524 $2_1 = global$0 - 16 | 0; 4525 global$0 = $2_1; 4526 $1($2_1 + 8 | 0, $7_1); 4527 $5_1 = HEAP32[$2_1 + 8 >> 2]; 4528 if ($5_1) { 4529 $4_1 = $0_1 + 20 | 0; 4530 $1_1 = HEAP32[$2_1 + 12 >> 2]; 4531 while (1) { 4532 $8_1 = HEAP32[$4_1 + 8 >> 2]; 4533 if (($8_1 | 0) == HEAP32[$4_1 >> 2]) { 4534 $38($4_1, $8_1, 1, 4, 8) 4535 } 4536 $11_1 = HEAP32[$4_1 + 4 >> 2] + ($8_1 << 3) | 0; 4537 HEAP32[$11_1 + 4 >> 2] = $1_1; 4538 HEAP32[$11_1 >> 2] = $5_1; 4539 HEAP32[$4_1 + 8 >> 2] = $8_1 + 1; 4540 $1($2_1, $7_1); 4541 $1_1 = HEAP32[$2_1 + 4 >> 2]; 4542 $5_1 = HEAP32[$2_1 >> 2]; 4543 if ($5_1) { 4544 continue 4545 } 4546 break; 4547 }; 4548 } 4549 global$0 = $2_1 + 16 | 0; 4550 HEAP32[$6_1 + 8 >> 2] = HEAP32[$0_1 + 28 >> 2]; 4551 $13_1 = HEAP32[$0_1 + 24 >> 2]; 4552 HEAP32[$6_1 >> 2] = HEAP32[$0_1 + 20 >> 2]; 4553 HEAP32[$6_1 + 4 >> 2] = $13_1; 4554 break block87; 4555 } 4556 HEAP32[$6_1 + 8 >> 2] = 0; 4557 HEAP32[$6_1 >> 2] = 0; 4558 HEAP32[$6_1 + 4 >> 2] = 4; 4559 } 4560 global$0 = $0_1 - -64 | 0; 4561 break block88; 4562 } 4563 $120($2_1, HEAP32[$0_1 + 40 >> 2]); 4564 wasm2js_trap(); 4565 } 4566 block133 : { 4567 block89 : { 4568 $25_1 = HEAP32[$3_1 + 88 >> 2]; 4569 if (!$25_1) { 4570 break block89 4571 } 4572 $24_1 = HEAP32[$3_1 + 84 >> 2]; 4573 $4_1 = $24_1 + 8 | 0; 4574 $21_1 = $25_1 << 3; 4575 $19_1 = $21_1 + $24_1 | 0; 4576 if (($21_1 | 0) != 8) { 4577 $8_1 = $4_1; 4578 while (1) { 4579 $11_1 = HEAP32[$8_1 >> 2]; 4580 $2_1 = HEAP32[$8_1 + 4 >> 2]; 4581 $0_1 = global$0 - 16 | 0; 4582 global$0 = $0_1; 4583 HEAP32[$0_1 + 12 >> 2] = 0; 4584 HEAP8[$0_1 + 12 | 0] = 47; 4585 $1_1 = $116($11_1, $2_1, $0_1 + 12 | 0, 1); 4586 global$0 = $0_1 + 16 | 0; 4587 if ($1_1) { 4588 break block89 4589 } 4590 $8_1 = $8_1 + 8 | 0; 4591 $1_1 = 0; 4592 $0_1 = 0; 4593 block96 : { 4594 label17 : while (1) { 4595 $5_1 = $1_1; 4596 block95 : { 4597 block90 : { 4598 if ($0_1 >>> 0 > $2_1 >>> 0) { 4599 $1_1 = $0_1; 4600 break block90; 4601 } 4602 $1_1 = $0_1; 4603 while (1) { 4604 $6_1 = $1_1 + $11_1 | 0; 4605 block92 : { 4606 block93 : { 4607 $7_1 = $2_1 - $1_1 | 0; 4608 block91 : { 4609 if ($7_1 >>> 0 <= 7) { 4610 if (($1_1 | 0) == ($2_1 | 0)) { 4611 break block91 4612 } 4613 $0_1 = 0; 4614 while (1) { 4615 if (HEAPU8[$0_1 + $6_1 | 0] == 47) { 4616 break block92 4617 } 4618 $0_1 = $0_1 + 1 | 0; 4619 if (($0_1 | 0) != ($7_1 | 0)) { 4620 continue 4621 } 4622 break; 4623 }; 4624 break block91; 4625 } 4626 $154($3_1, 47, $6_1, $7_1); 4627 if (HEAP32[$3_1 >> 2] & 1) { 4628 break block93 4629 } 4630 } 4631 $1_1 = $2_1; 4632 break block90; 4633 } 4634 $0_1 = HEAP32[$3_1 + 4 >> 2]; 4635 } 4636 $6_1 = $0_1 + $1_1 | 0; 4637 $1_1 = $6_1 + 1 | 0; 4638 block94 : { 4639 if ($2_1 >>> 0 <= $6_1 >>> 0) { 4640 break block94 4641 } 4642 if (HEAPU8[$6_1 + $11_1 | 0] != 47) { 4643 break block94 4644 } 4645 $0_1 = $1_1; 4646 if (($6_1 - $5_1 | 0) != 2) { 4647 continue label17 4648 } 4649 $6_1 = 0; 4650 break block95; 4651 } 4652 if ($1_1 >>> 0 <= $2_1 >>> 0) { 4653 continue 4654 } 4655 break; 4656 }; 4657 } 4658 if (($2_1 - $5_1 | 0) != 2) { 4659 break block96 4660 } 4661 $0_1 = $5_1; 4662 $6_1 = 1; 4663 } 4664 $7_1 = $0_1; 4665 $0_1 = $1_1; 4666 $1_1 = $5_1 + $11_1 | 0; 4667 $5_1 = (HEAPU8[$1_1 | 0] | HEAPU8[$1_1 + 1 | 0] << 8) != 11822; 4668 if (!$6_1) { 4669 $1_1 = $7_1; 4670 if ($5_1) { 4671 continue 4672 } 4673 } 4674 break; 4675 }; 4676 if (!$5_1) { 4677 break block89 4678 } 4679 } 4680 block97 : { 4681 if ($2_1 >>> 0 <= 2) { 4682 if (($2_1 | 0) != 2) { 4683 break block97 4684 } 4685 if ((HEAPU8[$11_1 | 0] | HEAPU8[$11_1 + 1 | 0] << 8) == 12093) { 4686 break block89 4687 } 4688 break block97; 4689 } 4690 $146($3_1 + 128 | 0, $11_1, $2_1, 1052868, 2); 4691 block99 : { 4692 block100 : { 4693 if (!HEAP32[$3_1 + 128 >> 2]) { 4694 if (HEAPU8[$3_1 + 142 | 0]) { 4695 break block97 4696 } 4697 $1_1 = HEAPU8[$3_1 + 140 | 0]; 4698 $2_1 = HEAP32[$3_1 + 180 >> 2]; 4699 $6_1 = HEAP32[$3_1 + 176 >> 2]; 4700 $0_1 = HEAP32[$3_1 + 132 >> 2]; 4701 while (1) { 4702 block98 : { 4703 if (!$0_1) { 4704 break block98 4705 } 4706 if ($0_1 >>> 0 >= $2_1 >>> 0) { 4707 if (($0_1 | 0) == ($2_1 | 0)) { 4708 break block98 4709 } 4710 break block99; 4711 } 4712 if (HEAP8[$0_1 + $6_1 | 0] < -64) { 4713 break block99 4714 } 4715 } 4716 if (($0_1 | 0) == ($2_1 | 0)) { 4717 break block100 4718 } 4719 $7_1 = $0_1 + $6_1 | 0; 4720 $5_1 = HEAP8[$7_1 | 0]; 4721 block101 : { 4722 if (($5_1 | 0) >= 0) { 4723 $9_1 = $5_1 & 255; 4724 break block101; 4725 } 4726 $12_1 = HEAPU8[$7_1 + 1 | 0] & 63; 4727 $11_1 = $5_1 & 31; 4728 $9_1 = $12_1 | $11_1 << 6; 4729 if ($5_1 >>> 0 <= 4294967263) { 4730 break block101 4731 } 4732 $12_1 = HEAPU8[$7_1 + 2 | 0] & 63 | $12_1 << 6; 4733 $9_1 = $12_1 | $11_1 << 12; 4734 if ($5_1 >>> 0 < 4294967280) { 4735 break block101 4736 } 4737 $9_1 = $11_1 << 18 & 1835008 | (HEAPU8[$7_1 + 3 | 0] & 63 | $12_1 << 6); 4738 } 4739 $5_1 = $9_1; 4740 if ($1_1 & 1) { 4741 break block89 4742 } 4743 $1_1 = 1; 4744 $9_1 = 1; 4745 block102 : { 4746 if ($5_1 >>> 0 < 128) { 4747 break block102 4748 } 4749 $9_1 = 2; 4750 if ($5_1 >>> 0 < 2048) { 4751 break block102 4752 } 4753 $9_1 = $5_1 >>> 0 < 65536 ? 3 : 4; 4754 } 4755 $0_1 = $9_1 + $0_1 | 0; 4756 continue; 4757 }; 4758 } 4759 $15_1 = HEAP32[$3_1 + 188 >> 2]; 4760 $20_1 = $15_1 - 1 | 0; 4761 $7_1 = HEAP32[$3_1 + 184 >> 2]; 4762 $23_1 = HEAP32[$3_1 + 180 >> 2]; 4763 $14_1 = HEAP32[$3_1 + 176 >> 2]; 4764 block104 : { 4765 $5_1 = HEAP32[$3_1 + 164 >> 2]; 4766 if (($5_1 | 0) != -1) { 4767 $2_1 = HEAP32[$3_1 + 156 >> 2]; 4768 $0_1 = $20_1 + $2_1 | 0; 4769 if ($23_1 >>> 0 <= $0_1 >>> 0) { 4770 break block97 4771 } 4772 $12_1 = HEAP32[$3_1 + 144 >> 2]; 4773 $11_1 = $12_1 - 1 | 0; 4774 $16_1 = 1 - $12_1 | 0; 4775 $26_1 = HEAP32[$3_1 + 152 >> 2]; 4776 $30_1 = $15_1 - $26_1 | 0; 4777 $22_1 = HEAP32[$3_1 + 136 >> 2]; 4778 $9_1 = HEAP32[$3_1 + 140 >> 2]; 4779 while (1) { 4780 $13_1 = $9_1; 4781 $10_1 = $22_1; 4782 $1_1 = HEAPU8[$0_1 + $14_1 | 0]; 4783 $0_1 = $1_1 & 31; 4784 if (($1_1 & 63) >>> 0 >= 32) { 4785 $0_1 = $9_1 >>> $0_1 | 0 4786 } else { 4787 $0_1 = ((1 << $0_1) - 1 & $13_1) << 32 - $0_1 | $10_1 >>> $0_1 4788 } 4789 block105 : { 4790 if ($0_1 & 1) { 4791 block103 : { 4792 $0_1 = $5_1 >>> 0 > $12_1 >>> 0 ? $5_1 : $12_1; 4793 if ($0_1 >>> 0 < $15_1 >>> 0) { 4794 $1_1 = ($0_1 >>> 0 > $15_1 >>> 0 ? $0_1 : $15_1) - $0_1 | 0; 4795 $6_1 = $0_1 + $7_1 | 0; 4796 $0_1 = $0_1 + $2_1 | 0; 4797 while (1) { 4798 if (HEAPU8[$6_1 | 0] != HEAPU8[$0_1 + $14_1 | 0]) { 4799 break block103 4800 } 4801 $6_1 = $6_1 + 1 | 0; 4802 $0_1 = $0_1 + 1 | 0; 4803 $1_1 = $1_1 - 1 | 0; 4804 if ($1_1) { 4805 continue 4806 } 4807 break; 4808 }; 4809 } 4810 if ($5_1 >>> 0 >= $12_1 >>> 0) { 4811 break block89 4812 } 4813 $1_1 = $2_1 + $14_1 | 0; 4814 $0_1 = $11_1; 4815 while (1) { 4816 if ($0_1 >>> 0 >= $15_1 >>> 0) { 4817 break block104 4818 } 4819 if (HEAPU8[$0_1 + $7_1 | 0] == HEAPU8[$0_1 + $1_1 | 0]) { 4820 $10_1 = $0_1 >>> 0 <= $5_1 >>> 0; 4821 $0_1 = $0_1 - 1 | 0; 4822 if ($10_1) { 4823 break block89 4824 } 4825 continue; 4826 } 4827 break; 4828 }; 4829 $2_1 = $2_1 + $26_1 | 0; 4830 $5_1 = $30_1; 4831 break block105; 4832 } 4833 $2_1 = $0_1 + $16_1 | 0; 4834 } else { 4835 $2_1 = $2_1 + $15_1 | 0 4836 } 4837 $5_1 = 0; 4838 } 4839 $0_1 = $2_1 + $20_1 | 0; 4840 if ($0_1 >>> 0 < $23_1 >>> 0) { 4841 continue 4842 } 4843 break; 4844 }; 4845 break block97; 4846 } 4847 $5_1 = HEAP32[$3_1 + 156 >> 2]; 4848 $0_1 = $20_1 + $5_1 | 0; 4849 if ($23_1 >>> 0 <= $0_1 >>> 0) { 4850 break block97 4851 } 4852 $16_1 = HEAP32[$3_1 + 144 >> 2]; 4853 $11_1 = $15_1 >>> 0 < $16_1 >>> 0 ? $16_1 : $15_1; 4854 $26_1 = $14_1 + $16_1 | 0; 4855 $2_1 = $16_1 - 1 | 0; 4856 $30_1 = HEAP32[$3_1 + 152 >> 2]; 4857 $22_1 = HEAP32[$3_1 + 136 >> 2]; 4858 $9_1 = HEAP32[$3_1 + 140 >> 2]; 4859 while (1) { 4860 $13_1 = $22_1; 4861 $1_1 = HEAPU8[$0_1 + $14_1 | 0]; 4862 $0_1 = $1_1 & 31; 4863 if (($1_1 & 63) >>> 0 >= 32) { 4864 $0_1 = $9_1 >>> $0_1 | 0 4865 } else { 4866 $0_1 = ((1 << $0_1) - 1 & $9_1) << 32 - $0_1 | $13_1 >>> $0_1 4867 } 4868 block106 : { 4869 if ($0_1 & 1) { 4870 $1_1 = $11_1; 4871 $6_1 = $7_1; 4872 $0_1 = $5_1; 4873 if ($15_1 >>> 0 > $16_1 >>> 0) { 4874 while (1) { 4875 $12_1 = $0_1 + 1 | 0; 4876 $10_1 = $12_1; 4877 if (HEAPU8[$6_1 + $16_1 | 0] != HEAPU8[$0_1 + $26_1 | 0]) { 4878 break block106 4879 } 4880 $6_1 = $6_1 + 1 | 0; 4881 $0_1 = $12_1; 4882 $1_1 = $1_1 - 1 | 0; 4883 if (($1_1 | 0) != ($16_1 | 0)) { 4884 continue 4885 } 4886 break; 4887 } 4888 } 4889 if (!$16_1) { 4890 break block89 4891 } 4892 $1_1 = $5_1 + $14_1 | 0; 4893 $0_1 = $2_1; 4894 block107 : { 4895 while (1) { 4896 if ($2_1 >>> 0 >= $15_1 >>> 0) { 4897 break block107 4898 } 4899 if (HEAPU8[$0_1 + $7_1 | 0] == HEAPU8[$0_1 + $1_1 | 0]) { 4900 $0_1 = $0_1 - 1 | 0; 4901 if (($0_1 | 0) == -1) { 4902 break block89 4903 } 4904 continue; 4905 } 4906 break; 4907 }; 4908 $10_1 = $5_1 + $30_1 | 0; 4909 break block106; 4910 } 4911 $137($0_1, $15_1, 1051656); 4912 wasm2js_trap(); 4913 } 4914 $10_1 = $5_1 + $15_1 | 0; 4915 } 4916 $5_1 = $10_1; 4917 $0_1 = $20_1 + $5_1 | 0; 4918 if ($0_1 >>> 0 < $23_1 >>> 0) { 4919 continue 4920 } 4921 break; 4922 }; 4923 break block97; 4924 } 4925 $137($0_1, $15_1, 1051656); 4926 wasm2js_trap(); 4927 } 4928 if (!($1_1 & 1)) { 4929 break block97 4930 } 4931 break block89; 4932 } 4933 $148($6_1, $2_1, $0_1, $2_1, 1052884); 4934 wasm2js_trap(); 4935 } 4936 if (($8_1 | 0) != ($19_1 | 0)) { 4937 continue 4938 } 4939 break; 4940 }; 4941 } 4942 $0_1 = HEAP32[$24_1 >> 2]; 4943 block113 : { 4944 block136 : { 4945 block134 : { 4946 block108 : { 4947 block135 : { 4948 block111 : { 4949 switch (HEAP32[$24_1 + 4 >> 2] - 2 | 0) { 4950 case 1: 4951 $1_1 = $0_1 + 2 | 0; 4952 if (!((HEAPU8[$0_1 | 0] | HEAPU8[$0_1 + 1 | 0] << 8) ^ 30576 | HEAPU8[$1_1 | 0] ^ 100)) { 4953 break block113 4954 } 4955 $1_1 = HEAPU8[$1_1 | 0] ^ 116; 4956 if (!($1_1 | (HEAPU8[$0_1 | 0] | HEAPU8[$0_1 + 1 | 0] << 8) ^ 24931)) { 4957 break block113 4958 } 4959 if ((HEAPU8[$0_1 | 0] | HEAPU8[$0_1 + 1 | 0] << 8) ^ 26983 | $1_1) { 4960 break block89 4961 } 4962 $5_1 = 0; 4963 $6_1 = global$0 - 16 | 0; 4964 global$0 = $6_1; 4965 $1_1 = $25_1 - 1 | 0; 4966 block114 : { 4967 if (!$1_1) { 4968 break block114 4969 } 4970 $0_1 = $4_1 + 8 | 0; 4971 $8_1 = ($1_1 << 3) + $4_1 | 0; 4972 block115 : { 4973 if (($1_1 | 0) != 1) { 4974 $2_1 = $0_1; 4975 while (1) { 4976 $1_1 = HEAP32[$2_1 >> 2]; 4977 $7_1 = HEAP32[$2_1 + 4 >> 2]; 4978 if ($116($1_1, $7_1, 1052550, 8)) { 4979 break block115 4980 } 4981 if (($7_1 | 0) == 2) { 4982 if ((HEAPU8[$1_1 | 0] | HEAPU8[$1_1 + 1 | 0] << 8) == 28461) { 4983 break block115 4984 } 4985 } 4986 $2_1 = $2_1 + 8 | 0; 4987 if (($8_1 | 0) != ($2_1 | 0)) { 4988 continue 4989 } 4990 break; 4991 }; 4992 } 4993 $5_1 = 1; 4994 } 4995 $1_1 = HEAP32[$4_1 >> 2]; 4996 block123 : { 4997 block120 : { 4998 block116 : { 4999 switch (HEAP32[$4_1 + 4 >> 2] - 3 | 0) { 5000 case 1: 5001 if ((HEAPU8[$1_1 | 0] | HEAPU8[$1_1 + 1 | 0] << 8 | (HEAPU8[$1_1 + 2 | 0] << 16 | HEAPU8[$1_1 + 3 | 0] << 24)) == 1717987684) { 5002 break block114 5003 } 5004 if ((HEAPU8[$1_1 | 0] | HEAPU8[$1_1 + 1 | 0] << 8 | (HEAPU8[$1_1 + 2 | 0] << 16 | HEAPU8[$1_1 + 3 | 0] << 24)) != 2003789939) { 5005 break block120 5006 } 5007 break block114; 5008 case 2: 5009 if ((HEAPU8[$1_1 | 0] | HEAPU8[$1_1 + 1 | 0] << 8 | (HEAPU8[$1_1 + 2 | 0] << 16 | HEAPU8[$1_1 + 3 | 0] << 24)) ^ 1835101282 | HEAPU8[$1_1 + 4 | 0] ^ 101) { 5010 break block120 5011 } 5012 break block114; 5013 case 6: 5014 $13_1 = (HEAPU8[$1_1 + 4 | 0] | HEAPU8[$1_1 + 5 | 0] << 8 | (HEAPU8[$1_1 + 6 | 0] << 16 | HEAPU8[$1_1 + 7 | 0] << 24)) ^ 1936875888; 5015 if ($13_1 | ((HEAPU8[$1_1 | 0] | HEAPU8[$1_1 + 1 | 0] << 8 | (HEAPU8[$1_1 + 2 | 0] << 16 | HEAPU8[$1_1 + 3 | 0] << 24)) ^ 762733938 | HEAPU8[$1_1 + 8 | 0] ^ 101)) { 5016 break block120 5017 } 5018 break block114; 5019 case 5: 5020 if ((HEAPU8[$1_1 | 0] | HEAPU8[$1_1 + 1 | 0] << 8 | (HEAPU8[$1_1 + 2 | 0] << 16 | HEAPU8[$1_1 + 3 | 0] << 24)) == 1668506980) { 5021 $0_1 = (HEAPU8[$1_1 + 4 | 0] | HEAPU8[$1_1 + 5 | 0] << 8 | (HEAPU8[$1_1 + 6 | 0] << 16 | HEAPU8[$1_1 + 7 | 0] << 24)) == 1700948338 5022 } else { 5023 $0_1 = 0 5024 } 5025 if ($0_1) { 5026 break block114 5027 } 5028 if ((HEAPU8[$1_1 | 0] | HEAPU8[$1_1 + 1 | 0] << 8 | (HEAPU8[$1_1 + 2 | 0] << 16 | HEAPU8[$1_1 + 3 | 0] << 24)) != 1714254700) { 5029 $0_1 = 1 5030 } else { 5031 $0_1 = (HEAPU8[$1_1 + 4 | 0] | HEAPU8[$1_1 + 5 | 0] << 8 | (HEAPU8[$1_1 + 6 | 0] << 16 | HEAPU8[$1_1 + 7 | 0] << 24)) != 1936026729 5032 } 5033 if ($0_1) { 5034 break block120 5035 } 5036 break block114; 5037 case 3: 5038 $2_1 = $1_1 + 4 | 0; 5039 if (!((HEAPU8[$1_1 | 0] | HEAPU8[$1_1 + 1 | 0] << 8 | (HEAPU8[$1_1 + 2 | 0] << 16 | HEAPU8[$1_1 + 3 | 0] << 24)) ^ 1952543859 | (HEAPU8[$2_1 | 0] | HEAPU8[$2_1 + 1 | 0] << 8) ^ 29557)) { 5040 break block114 5041 } 5042 if (!((HEAPU8[$1_1 | 0] | HEAPU8[$1_1 + 1 | 0] << 8 | (HEAPU8[$1_1 + 2 | 0] << 16 | HEAPU8[$1_1 + 3 | 0] << 24)) ^ 1851880034 | (HEAPU8[$2_1 | 0] | HEAPU8[$2_1 + 1 | 0] << 8) ^ 26723)) { 5043 break block123 5044 } 5045 $5_1 = 0; 5046 if ((HEAPU8[$1_1 | 0] | HEAPU8[$1_1 + 1 | 0] << 8 | (HEAPU8[$1_1 + 2 | 0] << 16 | HEAPU8[$1_1 + 3 | 0] << 24)) ^ 1869440370 | (HEAPU8[$2_1 | 0] | HEAPU8[$2_1 + 1 | 0] << 8) ^ 25972) { 5047 break block114 5048 } 5049 HEAP32[$6_1 + 12 >> 2] = $8_1; 5050 HEAP32[$6_1 + 8 >> 2] = $0_1; 5051 $2_1 = $6_1 + 8 | 0; 5052 $0_1 = HEAP32[$2_1 >> 2]; 5053 $4_1 = HEAP32[$2_1 + 4 >> 2]; 5054 while (1) { 5055 block124 : { 5056 $5_1 = ($0_1 | 0) == ($4_1 | 0); 5057 if ($5_1) { 5058 break block124 5059 } 5060 $1_1 = $0_1 + 8 | 0; 5061 HEAP32[$2_1 >> 2] = $1_1; 5062 if (HEAP32[$0_1 + 4 >> 2] != 2) { 5063 break block124 5064 } 5065 $10_1 = HEAP32[$0_1 >> 2]; 5066 $0_1 = $1_1; 5067 if ((HEAPU8[$10_1 | 0] | HEAPU8[$10_1 + 1 | 0] << 8) == 30253) { 5068 continue 5069 } 5070 } 5071 break; 5072 }; 5073 break block114; 5074 case 0: 5075 break block116; 5076 default: 5077 break block120; 5078 }; 5079 } 5080 if (!((HEAPU8[$1_1 | 0] | HEAPU8[$1_1 + 1 | 0] << 8) ^ 28524 | HEAPU8[$1_1 + 2 | 0] ^ 103)) { 5081 break block114 5082 } 5083 } 5084 $5_1 = 0; 5085 break block114; 5086 } 5087 HEAP32[$6_1 + 12 >> 2] = $8_1; 5088 HEAP32[$6_1 + 8 >> 2] = $0_1; 5089 $5_1 = 0; 5090 $4_1 = $6_1 + 8 | 0; 5091 $2_1 = HEAP32[$4_1 >> 2]; 5092 $8_1 = HEAP32[$4_1 + 4 >> 2]; 5093 $0_1 = 1; 5094 block125 : { 5095 if (($2_1 | 0) == ($8_1 | 0)) { 5096 break block125 5097 } 5098 block128 : { 5099 while (1) { 5100 $0_1 = $2_1; 5101 $1_1 = HEAP32[$0_1 >> 2]; 5102 block132 : { 5103 block130 : { 5104 block129 : { 5105 block127 : { 5106 block126 : { 5107 block131 : { 5108 $2_1 = HEAP32[$0_1 + 4 >> 2]; 5109 switch ($2_1 - 2 | 0) { 5110 case 0: 5111 break block126; 5112 case 1: 5113 break block127; 5114 case 2: 5115 break block128; 5116 case 3: 5117 break block129; 5118 case 4: 5119 break block130; 5120 default: 5121 break block131; 5122 }; 5123 } 5124 if (($2_1 | 0) != 14) { 5125 break block128 5126 } 5127 $11_1 = (HEAPU8[$1_1 | 0] | HEAPU8[$1_1 + 1 | 0] << 8 | (HEAPU8[$1_1 + 2 | 0] << 16 | HEAPU8[$1_1 + 3 | 0] << 24)) ^ 1752378669; 5128 $2_1 = (HEAPU8[$1_1 + 4 | 0] | HEAPU8[$1_1 + 5 | 0] << 8 | (HEAPU8[$1_1 + 6 | 0] << 16 | HEAPU8[$1_1 + 7 | 0] << 24)) ^ 1663924079; 5129 $10_1 = $1_1 + 6 | 0; 5130 $1_1 = $10_1; 5131 if (!($11_1 | (HEAPU8[$1_1 | 0] | HEAPU8[$1_1 + 1 | 0] << 8 | (HEAPU8[$1_1 + 2 | 0] << 16 | HEAPU8[$1_1 + 3 | 0] << 24)) ^ 1920295725 | ($2_1 | (HEAPU8[$1_1 + 4 | 0] | HEAPU8[$1_1 + 5 | 0] << 8 | (HEAPU8[$1_1 + 6 | 0] << 16 | HEAPU8[$1_1 + 7 | 0] << 24)) ^ 1953391986))) { 5132 break block132 5133 } 5134 break block128; 5135 } 5136 if ((HEAPU8[$1_1 | 0] | HEAPU8[$1_1 + 1 | 0] << 8) == 24877) { 5137 break block132 5138 } 5139 if ((HEAPU8[$1_1 | 0] | HEAPU8[$1_1 + 1 | 0] << 8) == 29229) { 5140 break block132 5141 } 5142 if ((HEAPU8[$1_1 | 0] | HEAPU8[$1_1 + 1 | 0] << 8) == 30253) { 5143 break block132 5144 } 5145 break block128; 5146 } 5147 if (!((HEAPU8[$1_1 | 0] | HEAPU8[$1_1 + 1 | 0] << 8) ^ 30253 | HEAPU8[$1_1 + 2 | 0] ^ 118)) { 5148 break block132 5149 } 5150 break block128; 5151 } 5152 if (!((HEAPU8[$1_1 | 0] | HEAPU8[$1_1 + 1 | 0] << 8 | (HEAPU8[$1_1 + 2 | 0] << 16 | HEAPU8[$1_1 + 3 | 0] << 24)) ^ 1818307885 | HEAPU8[$1_1 + 4 | 0] ^ 108)) { 5153 break block132 5154 } 5155 break block128; 5156 } 5157 $2_1 = (HEAPU8[$1_1 | 0] | HEAPU8[$1_1 + 1 | 0] << 8 | (HEAPU8[$1_1 + 2 | 0] << 16 | HEAPU8[$1_1 + 3 | 0] << 24)) ^ 1768697133; 5158 $1_1 = $1_1 + 4 | 0; 5159 if ($2_1 | (HEAPU8[$1_1 | 0] | HEAPU8[$1_1 + 1 | 0] << 8) ^ 29811) { 5160 break block128 5161 } 5162 } 5163 $2_1 = $0_1 + 8 | 0; 5164 if (($8_1 | 0) != ($2_1 | 0)) { 5165 continue 5166 } 5167 break; 5168 }; 5169 $5_1 = 1; 5170 } 5171 HEAP32[$4_1 >> 2] = $0_1 + 8; 5172 $0_1 = $5_1; 5173 } 5174 $5_1 = $0_1; 5175 } 5176 global$0 = $6_1 + 16 | 0; 5177 $45($3_1 + 80 | 0, 4, 8); 5178 if ($5_1) { 5179 break block133 5180 } 5181 break block82; 5182 case 2: 5183 if ((HEAPU8[$0_1 | 0] | HEAPU8[$0_1 + 1 | 0] << 8 | (HEAPU8[$0_1 + 2 | 0] << 16 | HEAPU8[$0_1 + 3 | 0] << 24)) == 1684104552) { 5184 break block113 5185 } 5186 if ((HEAPU8[$0_1 | 0] | HEAPU8[$0_1 + 1 | 0] << 8 | (HEAPU8[$0_1 + 2 | 0] << 16 | HEAPU8[$0_1 + 3 | 0] << 24)) == 1818845556) { 5187 break block113 5188 } 5189 if ((HEAPU8[$0_1 | 0] | HEAPU8[$0_1 + 1 | 0] << 8 | (HEAPU8[$0_1 + 2 | 0] << 16 | HEAPU8[$0_1 + 3 | 0] << 24)) == 1701603686) { 5190 break block113 5191 } 5192 if ((HEAPU8[$0_1 | 0] | HEAPU8[$0_1 + 1 | 0] << 8 | (HEAPU8[$0_1 + 2 | 0] << 16 | HEAPU8[$0_1 + 3 | 0] << 24)) == 1952543859) { 5193 break block113 5194 } 5195 if ((HEAPU8[$0_1 | 0] | HEAPU8[$0_1 + 1 | 0] << 8 | (HEAPU8[$0_1 + 2 | 0] << 16 | HEAPU8[$0_1 + 3 | 0] << 24)) == 1869112165) { 5196 break block113 5197 } 5198 if ((HEAPU8[$0_1 | 0] | HEAPU8[$0_1 + 1 | 0] << 8 | (HEAPU8[$0_1 + 2 | 0] << 16 | HEAPU8[$0_1 + 3 | 0] << 24)) == 1885696615) { 5199 break block113 5200 } 5201 if ((HEAPU8[$0_1 | 0] | HEAPU8[$0_1 + 1 | 0] << 8 | (HEAPU8[$0_1 + 2 | 0] << 16 | HEAPU8[$0_1 + 3 | 0] << 24)) != 1701147252) { 5202 break block134 5203 } 5204 if (($21_1 | 0) == 8) { 5205 break block113 5206 } 5207 break block135; 5208 case 4: 5209 $1_1 = (HEAPU8[$0_1 | 0] | HEAPU8[$0_1 + 1 | 0] << 8 | (HEAPU8[$0_1 + 2 | 0] << 16 | HEAPU8[$0_1 + 3 | 0] << 24)) ^ 1634691191; 5210 $0_1 = $0_1 + 4 | 0; 5211 if (!($1_1 | (HEAPU8[$0_1 | 0] | HEAPU8[$0_1 + 1 | 0] << 8) ^ 26989)) { 5212 break block113 5213 } 5214 break block89; 5215 case 0: 5216 break block108; 5217 case 3: 5218 break block111; 5219 default: 5220 break block89; 5221 }; 5222 } 5223 if (!((HEAPU8[$0_1 | 0] | HEAPU8[$0_1 + 1 | 0] << 8 | (HEAPU8[$0_1 + 2 | 0] << 16 | HEAPU8[$0_1 + 3 | 0] << 24)) ^ 1667852407 | HEAPU8[$0_1 + 4 | 0] ^ 104)) { 5224 break block113 5225 } 5226 break block89; 5227 } 5228 while (1) { 5229 if ($116(HEAP32[$4_1 >> 2], HEAP32[$4_1 + 4 >> 2], 1052536, 2)) { 5230 break block89 5231 } 5232 $4_1 = $4_1 + 8 | 0; 5233 if (($4_1 | 0) != ($19_1 | 0)) { 5234 continue 5235 } 5236 break; 5237 }; 5238 break block113; 5239 } 5240 if ((HEAPU8[$0_1 | 0] | HEAPU8[$0_1 + 1 | 0] << 8) != 29548) { 5241 break block136 5242 } 5243 break block113; 5244 } 5245 if ((HEAPU8[$0_1 | 0] | HEAPU8[$0_1 + 1 | 0] << 8 | (HEAPU8[$0_1 + 2 | 0] << 16 | HEAPU8[$0_1 + 3 | 0] << 24)) != 1702125924) { 5246 break block89 5247 } 5248 HEAP32[$3_1 + 132 >> 2] = $19_1; 5249 HEAP32[$3_1 + 128 >> 2] = $4_1; 5250 $1_1 = $3_1 + 128 | 0; 5251 $2_1 = HEAP32[$1_1 >> 2]; 5252 $5_1 = HEAP32[$1_1 + 4 >> 2]; 5253 while (1) { 5254 block137 : { 5255 $0_1 = $2_1; 5256 if (($5_1 | 0) == ($0_1 | 0)) { 5257 break block137 5258 } 5259 $2_1 = $0_1 + 8 | 0; 5260 HEAP32[$1_1 >> 2] = $2_1; 5261 $4_1 = HEAP32[$0_1 >> 2]; 5262 $6_1 = HEAP32[$0_1 + 4 >> 2]; 5263 if ($116($4_1, $6_1, 1052538, 2)) { 5264 break block137 5265 } 5266 if (!$116($4_1, $6_1, 1052540, 5)) { 5267 continue 5268 } 5269 } 5270 break; 5271 }; 5272 $45($3_1 + 80 | 0, 4, 8); 5273 if (($0_1 | 0) != ($5_1 | 0)) { 5274 break block82 5275 } 5276 break block133; 5277 } 5278 if ((HEAPU8[$0_1 | 0] | HEAPU8[$0_1 + 1 | 0] << 8) == 25463) { 5279 break block113 5280 } 5281 if ((HEAPU8[$0_1 | 0] | HEAPU8[$0_1 + 1 | 0] << 8) == 30052) { 5282 break block113 5283 } 5284 if ((HEAPU8[$0_1 | 0] | HEAPU8[$0_1 + 1 | 0] << 8) == 26212) { 5285 break block113 5286 } 5287 if ((HEAPU8[$0_1 | 0] | HEAPU8[$0_1 + 1 | 0] << 8) != 26482) { 5288 break block89 5289 } 5290 if (($21_1 | 0) == 8) { 5291 break block113 5292 } 5293 while (1) { 5294 if ($116(HEAP32[$4_1 >> 2], HEAP32[$4_1 + 4 >> 2], 1052545, 5)) { 5295 break block89 5296 } 5297 $4_1 = $4_1 + 8 | 0; 5298 if (($19_1 | 0) != ($4_1 | 0)) { 5299 continue 5300 } 5301 break; 5302 }; 5303 } 5304 $45($3_1 + 80 | 0, 4, 8); 5305 break block133; 5306 } 5307 $45($3_1 + 80 | 0, 4, 8); 5308 break block85; 5309 } 5310 $29_1 = 17; 5311 $17_1 = 1052597; 5312 } 5313 $18_1 = 2; 5314 break block85; 5315 } 5316 $17_1 = 1; 5317 } 5318 HEAP8[$3_1 + 71 | 0] = $18_1; 5319 HEAP32[$3_1 + 76 >> 2] = $29_1; 5320 HEAP32[$3_1 + 72 >> 2] = $17_1; 5321 HEAP32[$3_1 + 112 >> 2] = 0; 5322 HEAP32[$3_1 + 104 >> 2] = 0; 5323 $1_1 = $3_1 + 128 | 0; 5324 $35($1_1, 4, 1, 1); 5325 $0_1 = HEAP32[$3_1 + 132 >> 2]; 5326 if (HEAP32[$3_1 + 128 >> 2] == 1) { 5327 break block78 5328 } 5329 $2_1 = HEAP32[$3_1 + 136 >> 2]; 5330 $10_1 = 1701605234; 5331 HEAP8[$2_1 | 0] = $10_1; 5332 HEAP8[$2_1 + 1 | 0] = $10_1 >>> 8; 5333 HEAP8[$2_1 + 2 | 0] = $10_1 >>> 16; 5334 HEAP8[$2_1 + 3 | 0] = $10_1 >>> 24; 5335 HEAP32[$3_1 + 124 >> 2] = 4; 5336 HEAP32[$3_1 + 120 >> 2] = $2_1; 5337 HEAP32[$3_1 + 116 >> 2] = $0_1; 5338 $6($1_1, $3_1 + 71 | 0); 5339 if (HEAPU8[$3_1 + 128 | 0] == 255) { 5340 break block138 5341 } 5342 $9_1 = HEAP32[$3_1 + 148 >> 2]; 5343 HEAP32[$3_1 + 96 >> 2] = HEAP32[$3_1 + 144 >> 2]; 5344 HEAP32[$3_1 + 100 >> 2] = $9_1; 5345 $10_1 = HEAP32[$3_1 + 140 >> 2]; 5346 HEAP32[$3_1 + 88 >> 2] = HEAP32[$3_1 + 136 >> 2]; 5347 HEAP32[$3_1 + 92 >> 2] = $10_1; 5348 $9_1 = HEAP32[$3_1 + 132 >> 2]; 5349 HEAP32[$3_1 + 80 >> 2] = HEAP32[$3_1 + 128 >> 2]; 5350 HEAP32[$3_1 + 84 >> 2] = $9_1; 5351 $58($1_1, $3_1 + 104 | 0, $3_1 + 116 | 0, $3_1 + 80 | 0); 5352 if (HEAPU8[$3_1 + 128 | 0] != 255) { 5353 $4($1_1) 5354 } 5355 $1_1 = $3_1 + 128 | 0; 5356 $35($1_1, 3, 1, 1); 5357 $0_1 = HEAP32[$3_1 + 132 >> 2]; 5358 if (HEAP32[$3_1 + 128 >> 2] == 1) { 5359 break block78 5360 } 5361 $2_1 = HEAP32[$3_1 + 136 >> 2]; 5362 HEAP8[$2_1 + 2 | 0] = HEAPU8[1052578]; 5363 $10_1 = 1052576; 5364 $10_1 = HEAPU8[$10_1 | 0] | HEAPU8[$10_1 + 1 | 0] << 8; 5365 HEAP8[$2_1 | 0] = $10_1; 5366 HEAP8[$2_1 + 1 | 0] = $10_1 >>> 8; 5367 HEAP32[$3_1 + 124 >> 2] = 3; 5368 HEAP32[$3_1 + 120 >> 2] = $2_1; 5369 HEAP32[$3_1 + 116 >> 2] = $0_1; 5370 $0_1 = global$0 - 16 | 0; 5371 global$0 = $0_1; 5372 $2_1 = $3_1 + 72 | 0; 5373 $6_1 = HEAP32[$2_1 >> 2]; 5374 $2_1 = HEAP32[$2_1 + 4 >> 2]; 5375 $35($0_1 + 4 | 0, $2_1, 1, 1); 5376 $5_1 = HEAP32[$0_1 + 8 >> 2]; 5377 block139 : { 5378 if (HEAP32[$0_1 + 4 >> 2] != 1) { 5379 $4_1 = HEAP32[$0_1 + 12 >> 2]; 5380 if ($2_1) { 5381 wasm2js_memory_copy($4_1, $6_1, $2_1) 5382 } 5383 HEAP32[$1_1 + 12 >> 2] = $2_1; 5384 HEAP32[$1_1 + 8 >> 2] = $4_1; 5385 HEAP32[$1_1 + 4 >> 2] = $5_1; 5386 HEAP8[$1_1 | 0] = 3; 5387 global$0 = $0_1 + 16 | 0; 5388 break block139; 5389 } 5390 $120($5_1, HEAP32[$0_1 + 12 >> 2]); 5391 wasm2js_trap(); 5392 } 5393 if (HEAPU8[$3_1 + 128 | 0] == 255) { 5394 break block138 5395 } 5396 $10_1 = HEAP32[$3_1 + 148 >> 2]; 5397 HEAP32[$3_1 + 96 >> 2] = HEAP32[$3_1 + 144 >> 2]; 5398 HEAP32[$3_1 + 100 >> 2] = $10_1; 5399 $9_1 = HEAP32[$3_1 + 140 >> 2]; 5400 HEAP32[$3_1 + 88 >> 2] = HEAP32[$3_1 + 136 >> 2]; 5401 HEAP32[$3_1 + 92 >> 2] = $9_1; 5402 $10_1 = HEAP32[$3_1 + 132 >> 2]; 5403 HEAP32[$3_1 + 80 >> 2] = HEAP32[$3_1 + 128 >> 2]; 5404 HEAP32[$3_1 + 84 >> 2] = $10_1; 5405 $58($1_1, $3_1 + 104 | 0, $3_1 + 116 | 0, $3_1 + 80 | 0); 5406 if (HEAPU8[$3_1 + 128 | 0] != 255) { 5407 $4($1_1) 5408 } 5409 $9_1 = HEAP32[$3_1 + 108 >> 2]; 5410 HEAP32[$3_1 + 84 >> 2] = HEAP32[$3_1 + 104 >> 2]; 5411 HEAP32[$3_1 + 88 >> 2] = $9_1; 5412 HEAP32[$3_1 + 92 >> 2] = HEAP32[$3_1 + 112 >> 2]; 5413 HEAP8[$3_1 + 80 | 0] = 5; 5414 $2($3_1 + 40 | 0); 5415 $2($3_1 + 52 | 0); 5416 } 5417 $1_1 = $3_1 + 128 | 0; 5418 $35($1_1, 128, 1, 1); 5419 $0_1 = HEAP32[$3_1 + 132 >> 2]; 5420 block141 : { 5421 block140 : { 5422 if (HEAP32[$3_1 + 128 >> 2] != 1) { 5423 HEAP32[$3_1 + 48 >> 2] = 0; 5424 HEAP32[$3_1 + 44 >> 2] = HEAP32[$3_1 + 136 >> 2]; 5425 HEAP32[$3_1 + 40 >> 2] = $0_1; 5426 $0_1 = $3_1 + 40 | 0; 5427 HEAP32[$3_1 + 128 >> 2] = $0_1; 5428 $1_1 = $8($3_1 + 80 | 0, $1_1); 5429 if ($1_1) { 5430 HEAP32[$3_1 + 128 >> 2] = -1; 5431 HEAP32[$3_1 + 132 >> 2] = $1_1; 5432 $46($0_1); 5433 break block140; 5434 } 5435 HEAP32[$3_1 + 136 >> 2] = HEAP32[$3_1 + 48 >> 2]; 5436 $10_1 = HEAP32[$3_1 + 44 >> 2]; 5437 $22_1 = HEAP32[$3_1 + 40 >> 2]; 5438 HEAP32[$3_1 + 128 >> 2] = $22_1; 5439 HEAP32[$3_1 + 132 >> 2] = $10_1; 5440 if (($22_1 | 0) == -1) { 5441 break block140 5442 } 5443 HEAP32[$28_1 + 8 >> 2] = HEAP32[$3_1 + 136 >> 2]; 5444 $9_1 = HEAP32[$3_1 + 132 >> 2]; 5445 $10_1 = $28_1; 5446 HEAP32[$10_1 >> 2] = HEAP32[$3_1 + 128 >> 2]; 5447 HEAP32[$10_1 + 4 >> 2] = $9_1; 5448 break block141; 5449 } 5450 $120($0_1, HEAP32[$3_1 + 136 >> 2]); 5451 wasm2js_trap(); 5452 } 5453 HEAP32[$28_1 + 8 >> 2] = 0; 5454 $10_1 = $28_1; 5455 HEAP32[$10_1 >> 2] = 0; 5456 HEAP32[$10_1 + 4 >> 2] = 1; 5457 $3($3_1 + 128 | 4); 5458 } 5459 $4($3_1 + 80 | 0); 5460 global$0 = $3_1 + 192 | 0; 5461 break block142; 5462 } 5463 HEAP32[$3_1 + 40 >> 2] = HEAP32[$3_1 + 132 >> 2]; 5464 $152(1052660, 43, $3_1 + 40 | 0, 1052644, 1052580); 5465 wasm2js_trap(); 5466 } 5467 $120($0_1, HEAP32[$3_1 + 136 >> 2]); 5468 wasm2js_trap(); 5469 } 5470 HEAP32[$3_1 + 80 >> 2] = HEAP32[$3_1 + 132 >> 2]; 5471 $152(1052660, 43, $3_1 + 80 | 0, 1052644, 1052560); 5472 wasm2js_trap(); 5473 } 5474 $64($27_1 + 8 | 0, $28_1); 5475 HEAP32[267027] = HEAP32[$27_1 + 12 >> 2]; 5476 global$0 = $27_1 + 32 | 0; 5477 return HEAP32[$27_1 + 8 >> 2]; 5478 } 5479 5480 function $32() { 5481 return HEAP32[267027]; 5482 } 5483 5484 function $33($0_1, $1_1) { 5485 block : { 5486 if ($1_1 >>> 0 >= 9) { 5487 $0_1 = $97($1_1, $0_1); 5488 break block; 5489 } 5490 $0_1 = $98($0_1); 5491 } 5492 return $0_1; 5493 } 5494 5495 function $34($0_1, $1_1, $2_1, $3_1) { 5496 var $4_1 = 0, $5_1 = 0, $6_1 = 0, $7_1 = 0, $8_1 = 0, $9_1 = 0; 5497 $5_1 = $2_1; 5498 block1 : { 5499 block5 : { 5500 block3 : { 5501 block9 : { 5502 block11 : { 5503 block13 : { 5504 block4 : { 5505 block2 : { 5506 block : { 5507 $2_1 = $0_1; 5508 $8_1 = $0_1 - 4 | 0; 5509 $7_1 = HEAP32[$8_1 >> 2]; 5510 $4_1 = $7_1 & -8; 5511 $6_1 = $7_1 & 3; 5512 if ($4_1 >>> 0 >= $1_1 + ($6_1 ? 4 : 8) >>> 0) { 5513 $9_1 = $1_1 + 39 | 0; 5514 if ($4_1 >>> 0 > $9_1 >>> 0 ? $6_1 : 0) { 5515 break block 5516 } 5517 if ($5_1 >>> 0 >= 9) { 5518 $0_1 = $97($5_1, $3_1); 5519 $5_1 = 0; 5520 if (!$0_1) { 5521 break block1 5522 } 5523 $3_1 = $1_1 >>> 0 > $3_1 >>> 0 ? $3_1 : $1_1; 5524 if ($3_1) { 5525 wasm2js_memory_copy($0_1, $2_1, $3_1) 5526 } 5527 $3_1 = HEAP32[$8_1 >> 2]; 5528 $5_1 = $3_1 & -8; 5529 $3_1 = $3_1 & 3; 5530 if ($5_1 >>> 0 < ($3_1 ? 4 : 8) + $1_1 >>> 0) { 5531 break block2 5532 } 5533 if (!$3_1) { 5534 break block3 5535 } 5536 if ($5_1 >>> 0 > $9_1 >>> 0) { 5537 break block4 5538 } 5539 break block3; 5540 } 5541 $0_1 = 0; 5542 $9_1 = HEAP32[267024]; 5543 $1_1 = (-48 - $9_1 & -9) - 3 | 0; 5544 if (($1_1 >>> 0 >= 4294967232 ? -64 : $1_1) >>> 0 <= $3_1 >>> 0) { 5545 break block5 5546 } 5547 $1_1 = $3_1 >>> 0 < 11 ? 16 : $3_1 + 11 & -8; 5548 $5_1 = $2_1 - 8 | 0; 5549 block7 : { 5550 block6 : { 5551 block8 : { 5552 block10 : { 5553 if ($6_1) { 5554 $6_1 = $4_1 + $5_1 | 0; 5555 if ($1_1 >>> 0 <= $4_1 >>> 0) { 5556 break block6 5557 } 5558 if (HEAP32[267018] == ($6_1 | 0)) { 5559 break block7 5560 } 5561 if (HEAP32[267017] == ($6_1 | 0)) { 5562 break block8 5563 } 5564 $7_1 = HEAP32[$6_1 + 4 >> 2]; 5565 if ($7_1 & 2) { 5566 break block9 5567 } 5568 $7_1 = $7_1 & -8; 5569 $4_1 = $4_1 + $7_1 | 0; 5570 if ($1_1 >>> 0 > $4_1 >>> 0) { 5571 break block9 5572 } 5573 $101($6_1, $7_1); 5574 $6_1 = $4_1 - $1_1 | 0; 5575 if ($6_1 >>> 0 < 16) { 5576 break block10 5577 } 5578 HEAP32[$8_1 >> 2] = HEAP32[$8_1 >> 2] & 1 | $1_1 | 2; 5579 $1_1 = $1_1 + $5_1 | 0; 5580 HEAP32[$1_1 + 4 >> 2] = $6_1 | 3; 5581 $4_1 = $4_1 + $5_1 | 0; 5582 HEAP32[$4_1 + 4 >> 2] = HEAP32[$4_1 + 4 >> 2] | 1; 5583 $102($1_1, $6_1); 5584 break block11; 5585 } 5586 if ($1_1 >>> 0 < 256 | $1_1 >>> 0 >= $4_1 >>> 0 | (!$5_1 | $4_1 - $1_1 >>> 0 > $9_1 << 1 >>> 0)) { 5587 break block9 5588 } 5589 $5_1 = $2_1; 5590 break block1; 5591 } 5592 HEAP32[$8_1 >> 2] = HEAP32[$8_1 >> 2] & 1 | $4_1 | 2; 5593 $1_1 = $4_1 + $5_1 | 0; 5594 HEAP32[$1_1 + 4 >> 2] = HEAP32[$1_1 + 4 >> 2] | 1; 5595 break block11; 5596 } 5597 $4_1 = $4_1 + HEAP32[267015] | 0; 5598 if ($1_1 >>> 0 > $4_1 >>> 0) { 5599 break block9 5600 } 5601 $6_1 = $4_1 - $1_1 | 0; 5602 block12 : { 5603 if ($6_1 >>> 0 <= 15) { 5604 HEAP32[$8_1 >> 2] = $4_1 | $7_1 & 1 | 2; 5605 $1_1 = $4_1 + $5_1 | 0; 5606 HEAP32[$1_1 + 4 >> 2] = HEAP32[$1_1 + 4 >> 2] | 1; 5607 $6_1 = 0; 5608 $1_1 = 0; 5609 break block12; 5610 } 5611 HEAP32[$8_1 >> 2] = $7_1 & 1 | $1_1 | 2; 5612 $1_1 = $1_1 + $5_1 | 0; 5613 HEAP32[$1_1 + 4 >> 2] = $6_1 | 1; 5614 $4_1 = $4_1 + $5_1 | 0; 5615 HEAP32[$4_1 >> 2] = $6_1; 5616 HEAP32[$4_1 + 4 >> 2] = HEAP32[$4_1 + 4 >> 2] & -2; 5617 } 5618 HEAP32[267017] = $1_1; 5619 HEAP32[267015] = $6_1; 5620 break block11; 5621 } 5622 $4_1 = $4_1 - $1_1 | 0; 5623 if ($4_1 >>> 0 <= 15) { 5624 break block11 5625 } 5626 HEAP32[$8_1 >> 2] = $7_1 & 1 | $1_1 | 2; 5627 $1_1 = $1_1 + $5_1 | 0; 5628 HEAP32[$1_1 + 4 >> 2] = $4_1 | 3; 5629 HEAP32[$6_1 + 4 >> 2] = HEAP32[$6_1 + 4 >> 2] | 1; 5630 $102($1_1, $4_1); 5631 break block11; 5632 } 5633 $4_1 = $4_1 + HEAP32[267016] | 0; 5634 if ($1_1 >>> 0 < $4_1 >>> 0) { 5635 break block13 5636 } 5637 break block9; 5638 } 5639 $129(1059576, 46, 1059624); 5640 wasm2js_trap(); 5641 } 5642 $129(1059640, 46, 1059688); 5643 wasm2js_trap(); 5644 } 5645 $129(1059576, 46, 1059624); 5646 wasm2js_trap(); 5647 } 5648 $129(1059640, 46, 1059688); 5649 wasm2js_trap(); 5650 } 5651 HEAP32[$8_1 >> 2] = $7_1 & 1 | $1_1 | 2; 5652 $6_1 = $1_1 + $5_1 | 0; 5653 $1_1 = $4_1 - $1_1 | 0; 5654 HEAP32[$6_1 + 4 >> 2] = $1_1 | 1; 5655 HEAP32[267016] = $1_1; 5656 HEAP32[267018] = $6_1; 5657 } 5658 if (!$5_1) { 5659 break block9 5660 } 5661 $5_1 = $2_1; 5662 break block1; 5663 } 5664 $1_1 = $98($3_1); 5665 if (!$1_1) { 5666 break block5 5667 } 5668 $0_1 = HEAP32[$8_1 >> 2]; 5669 $0_1 = ($0_1 & 3 ? -4 : -8) + ($0_1 & -8) | 0; 5670 $0_1 = $0_1 >>> 0 > $3_1 >>> 0 ? $3_1 : $0_1; 5671 if (!$0_1) { 5672 $0_1 = $1_1; 5673 break block3; 5674 } 5675 wasm2js_memory_copy($1_1, $2_1, $0_1); 5676 $0_1 = $1_1; 5677 } 5678 $100($2_1); 5679 } 5680 $5_1 = $0_1; 5681 } 5682 return $5_1; 5683 } 5684 5685 function $35($0_1, $1_1, $2_1, $3_1) { 5686 var $4_1 = 0, $5_1 = 0; 5687 $3_1 = __wasm_i64_mul($3_1, 0, $1_1, $4_1); 5688 $4_1 = i64toi32_i32$HIGH_BITS; 5689 block2 : { 5690 block3 : { 5691 block1 : { 5692 block : { 5693 if (32 >= 32) { 5694 $4_1 = $4_1 >>> $5_1 | 0 5695 } else { 5696 $4_1 = ((1 << $5_1) - 1 & $4_1) << 32 - $5_1 | $3_1 >>> $5_1 5697 } 5698 if ($4_1) { 5699 break block 5700 } 5701 if (-2147483648 - $2_1 >>> 0 < $3_1 >>> 0) { 5702 break block 5703 } 5704 if ($3_1) { 5705 break block1 5706 } 5707 HEAP32[$0_1 + 8 >> 2] = $2_1; 5708 HEAP32[$0_1 + 4 >> 2] = 0; 5709 $1_1 = 0; 5710 break block2; 5711 } 5712 HEAP32[$0_1 + 4 >> 2] = 0; 5713 break block3; 5714 } 5715 $4_1 = $33($3_1, $2_1); 5716 if (!$4_1) { 5717 HEAP32[$0_1 + 8 >> 2] = $3_1; 5718 HEAP32[$0_1 + 4 >> 2] = $2_1; 5719 break block3; 5720 } 5721 HEAP32[$0_1 + 8 >> 2] = $4_1; 5722 HEAP32[$0_1 + 4 >> 2] = $1_1; 5723 $1_1 = 0; 5724 break block2; 5725 } 5726 $1_1 = 1; 5727 } 5728 HEAP32[$0_1 >> 2] = $1_1; 5729 } 5730 5731 function $36($0_1, $1_1, $2_1) { 5732 var $3_1 = 0, $4_1 = 0, $5_1 = 0, $6_1 = 0, $7_1 = 0, $8_1 = 0; 5733 $3_1 = 1; 5734 block1 : { 5735 block : { 5736 $1_1 = HEAP32[$1_1 >> 2]; 5737 $4_1 = HEAPU16[$1_1 + 402 >> 1]; 5738 if (!$4_1) { 5739 break block 5740 } 5741 $5_1 = HEAP32[$2_1 + 8 >> 2]; 5742 $8_1 = HEAP32[$2_1 + 4 >> 2]; 5743 $2_1 = Math_imul($4_1, 12); 5744 $1_1 = $1_1 + 276 | 0; 5745 while (1) { 5746 $6_1 = HEAP32[$1_1 >> 2]; 5747 $3_1 = $168($8_1, HEAP32[$1_1 - 4 >> 2], $5_1 >>> 0 < $6_1 >>> 0 ? $5_1 : $6_1); 5748 $3_1 = $3_1 ? $3_1 : $5_1 - $6_1 | 0; 5749 $3_1 = (($3_1 | 0) > 0) - (($3_1 | 0) < 0) & 255; 5750 if (($3_1 | 0) == 1) { 5751 $3_1 = 1; 5752 $7_1 = $7_1 + 1 | 0; 5753 $1_1 = $1_1 + 12 | 0; 5754 $2_1 = $2_1 - 12 | 0; 5755 if ($2_1) { 5756 continue 5757 } 5758 break block; 5759 } 5760 break; 5761 }; 5762 if ($3_1) { 5763 $3_1 = 1; 5764 break block1; 5765 } 5766 $3_1 = 0; 5767 break block1; 5768 } 5769 $7_1 = $4_1; 5770 } 5771 HEAP32[$0_1 + 4 >> 2] = $7_1; 5772 HEAP32[$0_1 >> 2] = $3_1; 5773 } 5774 5775 function $37($0_1) { 5776 var $1_1 = 0, $2_1 = 0; 5777 block2 : { 5778 switch (HEAPU8[$0_1 | 0]) { 5779 default: 5780 $44($0_1 + 4 | 0); 5781 case 0: 5782 case 1: 5783 case 2: 5784 return; 5785 case 3: 5786 $45($0_1 + 4 | 0, 1, 1); 5787 return; 5788 case 4: 5789 break block2; 5790 }; 5791 } 5792 $2_1 = $0_1 + 4 | 0; 5793 $1_1 = HEAP32[$0_1 + 12 >> 2]; 5794 if ($1_1) { 5795 $0_1 = HEAP32[$0_1 + 8 >> 2]; 5796 while (1) { 5797 $37($0_1); 5798 $0_1 = $0_1 + 24 | 0; 5799 $1_1 = $1_1 - 1 | 0; 5800 if ($1_1) { 5801 continue 5802 } 5803 break; 5804 }; 5805 } 5806 $45($2_1, 8, 24); 5807 } 5808 5809 function $38($0_1, $1_1, $2_1, $3_1, $4_1) { 5810 var $5_1 = 0, $6_1 = 0, $7_1 = 0, $8_1 = 0, $9_1 = 0, $10_1 = 0, $11_1 = 0, $12_1 = 0, $13_1 = 0, $14_1 = 0, $15_1 = 0; 5811 $8_1 = global$0 - 16 | 0; 5812 global$0 = $8_1; 5813 $13_1 = $8_1 + 8 | 0; 5814 $7_1 = global$0 - 16 | 0; 5815 global$0 = $7_1; 5816 block : { 5817 if (!$4_1) { 5818 break block 5819 } 5820 $1_1 = $1_1 + $2_1 | 0; 5821 if ($2_1 >>> 0 > $1_1 >>> 0) { 5822 break block 5823 } 5824 $9_1 = $7_1 + 4 | 0; 5825 $2_1 = HEAP32[$0_1 >> 2] << 1; 5826 $1_1 = $1_1 >>> 0 > $2_1 >>> 0 ? $1_1 : $2_1; 5827 $10_1 = ($4_1 | 0) == 1 ? 8 : $4_1 >>> 0 < 1025 ? 4 : 1; 5828 $14_1 = $1_1 >>> 0 > $10_1 >>> 0 ? $1_1 : $10_1; 5829 $2_1 = $14_1; 5830 $1_1 = global$0 - 16 | 0; 5831 global$0 = $1_1; 5832 $15_1 = 1; 5833 $5_1 = 4; 5834 $2_1 = __wasm_i64_mul($4_1, 0, $2_1, $6_1); 5835 $6_1 = i64toi32_i32$HIGH_BITS; 5836 $11_1 = 32; 5837 block7 : { 5838 block1 : { 5839 if ($11_1 >>> 0 >= 32) { 5840 $6_1 = $6_1 >>> $12_1 | 0 5841 } else { 5842 $6_1 = ((1 << $12_1) - 1 & $6_1) << 32 - $12_1 | $2_1 >>> $12_1 5843 } 5844 if ($6_1) { 5845 break block1 5846 } 5847 if (-2147483648 - $3_1 >>> 0 < $2_1 >>> 0) { 5848 break block1 5849 } 5850 $5_1 = 0; 5851 $11_1 = $1_1 + 12 | 0; 5852 block2 : { 5853 if (!$4_1) { 5854 break block2 5855 } 5856 $6_1 = HEAP32[$0_1 >> 2]; 5857 if (!$6_1) { 5858 break block2 5859 } 5860 HEAP32[$1_1 + 12 >> 2] = $3_1; 5861 $5_1 = Math_imul($4_1, $6_1); 5862 $4_1 = HEAP32[$0_1 + 4 >> 2]; 5863 $11_1 = $1_1 + 8 | 0; 5864 } 5865 HEAP32[$11_1 >> 2] = $5_1; 5866 block6 : { 5867 block5 : { 5868 block4 : { 5869 block3 : { 5870 if (HEAP32[$1_1 + 12 >> 2]) { 5871 $5_1 = HEAP32[$1_1 + 8 >> 2]; 5872 if (!$5_1) { 5873 if ($2_1) { 5874 break block3 5875 } 5876 $4_1 = $3_1; 5877 break block4; 5878 } 5879 $4_1 = $34($4_1, $5_1, $3_1, $2_1); 5880 break block4; 5881 } 5882 if ($2_1) { 5883 break block3 5884 } 5885 $4_1 = $3_1; 5886 break block5; 5887 } 5888 $4_1 = $33($2_1, $3_1); 5889 } 5890 if ($4_1) { 5891 break block5 5892 } 5893 HEAP32[$9_1 + 4 >> 2] = $3_1; 5894 break block6; 5895 } 5896 HEAP32[$9_1 + 4 >> 2] = $4_1; 5897 $15_1 = 0; 5898 } 5899 $5_1 = 8; 5900 break block7; 5901 } 5902 $2_1 = 0; 5903 } 5904 HEAP32[$5_1 + $9_1 >> 2] = $2_1; 5905 HEAP32[$9_1 >> 2] = $15_1; 5906 global$0 = $1_1 + 16 | 0; 5907 if (HEAP32[$7_1 + 4 >> 2] == 1) { 5908 $10_1 = HEAP32[$7_1 + 12 >> 2]; 5909 $5_1 = HEAP32[$7_1 + 8 >> 2]; 5910 break block; 5911 } 5912 $1_1 = HEAP32[$7_1 + 8 >> 2]; 5913 HEAP32[$0_1 >> 2] = $14_1; 5914 HEAP32[$0_1 + 4 >> 2] = $1_1; 5915 $5_1 = -1; 5916 } 5917 HEAP32[$13_1 + 4 >> 2] = $10_1; 5918 HEAP32[$13_1 >> 2] = $5_1; 5919 global$0 = $7_1 + 16 | 0; 5920 $0_1 = HEAP32[$8_1 + 8 >> 2]; 5921 if (($0_1 | 0) != -1) { 5922 $120($0_1, HEAP32[$8_1 + 12 >> 2]); 5923 wasm2js_trap(); 5924 } 5925 global$0 = $8_1 + 16 | 0; 5926 } 5927 5928 function $39() { 5929 var $0_1 = 0; 5930 $0_1 = $33(408, 8); 5931 if (!$0_1) { 5932 $123(8, 408); 5933 wasm2js_trap(); 5934 } 5935 return $0_1; 5936 } 5937 5938 function $40() { 5939 var $0_1 = 0; 5940 $0_1 = $33(456, 8); 5941 if (!$0_1) { 5942 $123(8, 456); 5943 wasm2js_trap(); 5944 } 5945 return $0_1; 5946 } 5947 5948 function $41($0_1, $1_1, $2_1, $3_1) { 5949 var $4_1 = 0, $5_1 = 0, $6_1 = 0, $7_1 = 0, $8_1 = 0, $9_1 = 0, $10_1 = 0; 5950 $5_1 = HEAP32[$0_1 >> 2]; 5951 $6_1 = $5_1 + 268 | 0; 5952 $0_1 = HEAP32[$0_1 + 8 >> 2]; 5953 $7_1 = $6_1 + Math_imul($0_1, 12) | 0; 5954 $8_1 = $0_1 + 1 | 0; 5955 $9_1 = HEAPU16[$5_1 + 402 >> 1]; 5956 block : { 5957 if ($8_1 >>> 0 > $9_1 >>> 0) { 5958 HEAP32[$7_1 + 8 >> 2] = HEAP32[$1_1 + 8 >> 2]; 5959 $4_1 = HEAP32[$1_1 + 4 >> 2]; 5960 HEAP32[$7_1 >> 2] = HEAP32[$1_1 >> 2]; 5961 HEAP32[$7_1 + 4 >> 2] = $4_1; 5962 break block; 5963 } 5964 $4_1 = $9_1 - $0_1 | 0; 5965 $10_1 = Math_imul($4_1, 12); 5966 if ($10_1) { 5967 wasm2js_memory_copy(Math_imul($8_1, 12) + $6_1 | 0, $7_1, $10_1) 5968 } 5969 HEAP32[$7_1 + 8 >> 2] = HEAP32[$1_1 + 8 >> 2]; 5970 $6_1 = HEAP32[$1_1 + 4 >> 2]; 5971 HEAP32[$7_1 >> 2] = HEAP32[$1_1 >> 2]; 5972 HEAP32[$7_1 + 4 >> 2] = $6_1; 5973 $1_1 = Math_imul($4_1, 24); 5974 if (!$1_1) { 5975 break block 5976 } 5977 wasm2js_memory_copy(Math_imul($8_1, 24) + $5_1 | 0, Math_imul($0_1, 24) + $5_1 | 0, $1_1); 5978 } 5979 $7_1 = $9_1 + 1 | 0; 5980 $4_1 = HEAP32[$2_1 + 20 >> 2]; 5981 $1_1 = Math_imul($0_1, 24) + $5_1 | 0; 5982 HEAP32[$1_1 + 16 >> 2] = HEAP32[$2_1 + 16 >> 2]; 5983 HEAP32[$1_1 + 20 >> 2] = $4_1; 5984 $6_1 = HEAP32[$2_1 + 12 >> 2]; 5985 HEAP32[$1_1 + 8 >> 2] = HEAP32[$2_1 + 8 >> 2]; 5986 HEAP32[$1_1 + 12 >> 2] = $6_1; 5987 $4_1 = HEAP32[$2_1 + 4 >> 2]; 5988 HEAP32[$1_1 >> 2] = HEAP32[$2_1 >> 2]; 5989 HEAP32[$1_1 + 4 >> 2] = $4_1; 5990 $1_1 = $5_1 + 408 | 0; 5991 $2_1 = $9_1 + 2 | 0; 5992 $6_1 = $0_1 + 2 | 0; 5993 block1 : { 5994 if ($2_1 >>> 0 <= $6_1 >>> 0) { 5995 break block1 5996 } 5997 $4_1 = $9_1 - $0_1 << 2; 5998 if (!$4_1) { 5999 break block1 6000 } 6001 wasm2js_memory_copy(($6_1 << 2) + $1_1 | 0, ($8_1 << 2) + $1_1 | 0, $4_1); 6002 } 6003 HEAP32[($8_1 << 2) + $1_1 >> 2] = $3_1; 6004 HEAP16[$5_1 + 402 >> 1] = $7_1; 6005 if ($2_1 >>> 0 > $8_1 >>> 0) { 6006 $2_1 = $9_1 + 1 | 0; 6007 $1_1 = ($5_1 + ($0_1 << 2) | 0) + 412 | 0; 6008 while (1) { 6009 $3_1 = HEAP32[$1_1 >> 2]; 6010 $0_1 = $0_1 + 1 | 0; 6011 HEAP16[$3_1 + 400 >> 1] = $0_1; 6012 HEAP32[$3_1 + 264 >> 2] = $5_1; 6013 $1_1 = $1_1 + 4 | 0; 6014 if (($0_1 | 0) != ($2_1 | 0)) { 6015 continue 6016 } 6017 break; 6018 }; 6019 } 6020 } 6021 6022 function $42($0_1, $1_1, $2_1) { 6023 var $3_1 = 0, $4_1 = 0, $5_1 = 0, $6_1 = 0, $7_1 = 0, $8_1 = 0, $9_1 = 0; 6024 $5_1 = global$0 - 48 | 0; 6025 global$0 = $5_1; 6026 $7_1 = HEAP32[$1_1 >> 2]; 6027 $1_1 = HEAP32[$1_1 + 8 >> 2]; 6028 $6_1 = HEAPU16[$7_1 + 402 >> 1] + ($1_1 ^ -1) | 0; 6029 HEAP16[$2_1 + 402 >> 1] = $6_1; 6030 $9_1 = $7_1 + 268 | 0; 6031 $4_1 = $9_1 + Math_imul($1_1, 12) | 0; 6032 HEAP32[$5_1 + 16 >> 2] = HEAP32[$4_1 + 8 >> 2]; 6033 $3_1 = $4_1; 6034 $8_1 = HEAP32[$3_1 >> 2]; 6035 $4_1 = HEAP32[$3_1 + 4 >> 2]; 6036 HEAP32[$5_1 + 8 >> 2] = $8_1; 6037 HEAP32[$5_1 + 12 >> 2] = $4_1; 6038 $4_1 = Math_imul($1_1, 24) + $7_1 | 0; 6039 $3_1 = $4_1; 6040 $8_1 = HEAP32[$3_1 + 16 >> 2]; 6041 $3_1 = HEAP32[$3_1 + 20 >> 2]; 6042 HEAP32[$5_1 + 40 >> 2] = $8_1; 6043 HEAP32[$5_1 + 44 >> 2] = $3_1; 6044 $3_1 = $4_1; 6045 $8_1 = HEAP32[$3_1 + 8 >> 2]; 6046 $4_1 = HEAP32[$3_1 + 12 >> 2]; 6047 HEAP32[$5_1 + 32 >> 2] = $8_1; 6048 HEAP32[$5_1 + 36 >> 2] = $4_1; 6049 $4_1 = HEAP32[$3_1 >> 2]; 6050 $3_1 = HEAP32[$3_1 + 4 >> 2]; 6051 HEAP32[$5_1 + 24 >> 2] = $4_1; 6052 HEAP32[$5_1 + 28 >> 2] = $3_1; 6053 if ($6_1 >>> 0 < 12) { 6054 $4_1 = $1_1 + 1 | 0; 6055 $3_1 = Math_imul($6_1, 12); 6056 if ($3_1) { 6057 wasm2js_memory_copy($2_1 + 268 | 0, Math_imul($4_1, 12) + $9_1 | 0, $3_1) 6058 } 6059 $6_1 = Math_imul($6_1, 24); 6060 if ($6_1) { 6061 wasm2js_memory_copy($2_1, Math_imul($4_1, 24) + $7_1 | 0, $6_1) 6062 } 6063 HEAP16[$7_1 + 402 >> 1] = $1_1; 6064 $4_1 = HEAP32[$5_1 + 12 >> 2]; 6065 $3_1 = $0_1; 6066 HEAP32[$3_1 >> 2] = HEAP32[$5_1 + 8 >> 2]; 6067 HEAP32[$3_1 + 4 >> 2] = $4_1; 6068 HEAP32[$3_1 + 8 >> 2] = HEAP32[$5_1 + 16 >> 2]; 6069 $4_1 = $3_1; 6070 $3_1 = HEAP32[$5_1 + 28 >> 2]; 6071 HEAP32[$4_1 + 16 >> 2] = HEAP32[$5_1 + 24 >> 2]; 6072 HEAP32[$4_1 + 20 >> 2] = $3_1; 6073 $3_1 = $4_1; 6074 $4_1 = HEAP32[$5_1 + 36 >> 2]; 6075 HEAP32[$3_1 + 24 >> 2] = HEAP32[$5_1 + 32 >> 2]; 6076 HEAP32[$3_1 + 28 >> 2] = $4_1; 6077 $4_1 = $3_1; 6078 $3_1 = HEAP32[$5_1 + 44 >> 2]; 6079 HEAP32[$4_1 + 32 >> 2] = HEAP32[$5_1 + 40 >> 2]; 6080 HEAP32[$4_1 + 36 >> 2] = $3_1; 6081 global$0 = $5_1 + 48 | 0; 6082 return; 6083 } 6084 $135(0, $6_1, 11, 1053628); 6085 wasm2js_trap(); 6086 } 6087 6088 function $43($0_1, $1_1, $2_1) { 6089 var $3_1 = 0; 6090 $3_1 = global$0 - 48 | 0; 6091 global$0 = $3_1; 6092 HEAP32[$3_1 + 12 >> 2] = $2_1; 6093 HEAP32[$3_1 + 8 >> 2] = $1_1; 6094 $1_1 = HEAP32[$0_1 + 12 >> 2]; 6095 HEAP32[$3_1 + 24 >> 2] = HEAP32[$0_1 + 8 >> 2]; 6096 HEAP32[$3_1 + 28 >> 2] = $1_1; 6097 $1_1 = HEAP32[$0_1 >> 2]; 6098 $0_1 = HEAP32[$0_1 + 4 >> 2]; 6099 HEAP32[$3_1 + 16 >> 2] = $1_1; 6100 HEAP32[$3_1 + 20 >> 2] = $0_1; 6101 HEAP32[$3_1 + 44 >> 2] = 3; 6102 HEAP32[$3_1 + 36 >> 2] = 13; 6103 HEAP32[$3_1 + 40 >> 2] = $3_1 + 8; 6104 HEAP32[$3_1 + 32 >> 2] = $3_1 + 16; 6105 $0_1 = $59(1049040, $3_1 + 32 | 0); 6106 global$0 = $3_1 + 48 | 0; 6107 return $0_1; 6108 } 6109 6110 function $44($0_1) { 6111 var $1_1 = 0, $2_1 = 0, $3_1 = 0, $4_1 = 0; 6112 $2_1 = global$0 - 48 | 0; 6113 global$0 = $2_1; 6114 $1_1 = HEAP32[$0_1 >> 2]; 6115 block : { 6116 if (!$1_1) { 6117 $1_1 = 0; 6118 $0_1 = 0; 6119 break block; 6120 } 6121 HEAP32[$2_1 + 36 >> 2] = $1_1; 6122 HEAP32[$2_1 + 32 >> 2] = 0; 6123 HEAP32[$2_1 + 20 >> 2] = $1_1; 6124 HEAP32[$2_1 + 16 >> 2] = 0; 6125 $1_1 = HEAP32[$0_1 + 4 >> 2]; 6126 HEAP32[$2_1 + 40 >> 2] = $1_1; 6127 HEAP32[$2_1 + 24 >> 2] = $1_1; 6128 $1_1 = 1; 6129 $0_1 = HEAP32[$0_1 + 8 >> 2]; 6130 } 6131 HEAP32[$2_1 + 44 >> 2] = $0_1; 6132 HEAP32[$2_1 + 28 >> 2] = $1_1; 6133 HEAP32[$2_1 + 12 >> 2] = $1_1; 6134 $0_1 = global$0 - 16 | 0; 6135 global$0 = $0_1; 6136 $3_1 = $2_1 + 12 | 0; 6137 $66($0_1 + 4 | 0, $3_1); 6138 $1_1 = HEAP32[$0_1 + 4 >> 2]; 6139 if ($1_1) { 6140 while (1) { 6141 $4_1 = HEAP32[$0_1 + 12 >> 2]; 6142 $45((Math_imul($4_1, 12) + $1_1 | 0) + 268 | 0, 1, 1); 6143 $37(Math_imul($4_1, 24) + $1_1 | 0); 6144 $66($0_1 + 4 | 0, $3_1); 6145 $1_1 = HEAP32[$0_1 + 4 >> 2]; 6146 if ($1_1) { 6147 continue 6148 } 6149 break; 6150 } 6151 } 6152 global$0 = $0_1 + 16 | 0; 6153 global$0 = $2_1 + 48 | 0; 6154 } 6155 6156 function $45($0_1, $1_1, $2_1) { 6157 var $3_1 = 0, $4_1 = 0, $5_1 = 0, $6_1 = 0; 6158 $3_1 = global$0 - 16 | 0; 6159 global$0 = $3_1; 6160 $4_1 = $3_1 + 12 | 0; 6161 block : { 6162 if (!$2_1) { 6163 break block 6164 } 6165 $5_1 = HEAP32[$0_1 >> 2]; 6166 if (!$5_1) { 6167 break block 6168 } 6169 HEAP32[$3_1 + 12 >> 2] = $1_1; 6170 $6_1 = Math_imul($2_1, $5_1); 6171 $2_1 = HEAP32[$0_1 + 4 >> 2]; 6172 $4_1 = $3_1 + 8 | 0; 6173 } 6174 HEAP32[$4_1 >> 2] = $6_1; 6175 block1 : { 6176 if (!HEAP32[$3_1 + 12 >> 2]) { 6177 break block1 6178 } 6179 $0_1 = HEAP32[$3_1 + 8 >> 2]; 6180 if (!$0_1) { 6181 break block1 6182 } 6183 $99($2_1, $0_1); 6184 } 6185 global$0 = $3_1 + 16 | 0; 6186 } 6187 6188 function $46($0_1) { 6189 $0_1 = $0_1 | 0; 6190 $45($0_1, 1, 1); 6191 } 6192 6193 function $47($0_1, $1_1) { 6194 var $2_1 = 0, $3_1 = 0; 6195 $2_1 = global$0 - 16 | 0; 6196 global$0 = $2_1; 6197 $3_1 = HEAP32[$1_1 + 8 >> 2]; 6198 block : { 6199 if ($3_1 >>> 0 < HEAPU32[$1_1 + 4 >> 2]) { 6200 HEAP8[$0_1 | 0] = 0; 6201 HEAP32[$1_1 + 8 >> 2] = $3_1 + 1; 6202 HEAP8[$0_1 + 1 | 0] = HEAPU8[$3_1 + HEAP32[$1_1 >> 2] | 0]; 6203 break block; 6204 } 6205 HEAP32[$2_1 + 4 >> 2] = 4; 6206 $48($0_1, $1_1, $2_1 + 4 | 0); 6207 } 6208 global$0 = $2_1 + 16 | 0; 6209 } 6210 6211 function $48($0_1, $1_1, $2_1) { 6212 var $3_1 = 0; 6213 $3_1 = global$0 - 16 | 0; 6214 global$0 = $3_1; 6215 $54($3_1 + 8 | 0, $1_1, HEAP32[$1_1 + 8 >> 2]); 6216 $1_1 = $55($2_1, HEAP32[$3_1 + 8 >> 2], HEAP32[$3_1 + 12 >> 2]); 6217 HEAP8[$0_1 | 0] = 1; 6218 HEAP32[$0_1 + 4 >> 2] = $1_1; 6219 global$0 = $3_1 + 16 | 0; 6220 } 6221 6222 function $49($0_1, $1_1) { 6223 var $2_1 = 0, $3_1 = 0; 6224 $2_1 = global$0 - 16 | 0; 6225 global$0 = $2_1; 6226 $3_1 = HEAP32[$1_1 + 8 >> 2]; 6227 block : { 6228 if ($3_1 >>> 0 < HEAPU32[$1_1 + 4 >> 2]) { 6229 HEAP8[$0_1 | 0] = 0; 6230 HEAP8[$0_1 + 1 | 0] = HEAPU8[$3_1 + HEAP32[$1_1 >> 2] | 0]; 6231 break block; 6232 } 6233 HEAP32[$2_1 + 4 >> 2] = 4; 6234 $48($0_1, $1_1, $2_1 + 4 | 0); 6235 } 6236 global$0 = $2_1 + 16 | 0; 6237 } 6238 6239 function $50($0_1, $1_1, $2_1) { 6240 var $3_1 = 0, $4_1 = 0, $5_1 = 0, $6_1 = 0, $7_1 = 0, $8_1 = 0, $9_1 = 0, $10_1 = 0; 6241 $8_1 = global$0 - 16 | 0; 6242 global$0 = $8_1; 6243 $47($8_1 + 4 | 0, $0_1); 6244 block : { 6245 if (HEAPU8[$8_1 + 4 | 0] == 1) { 6246 $0_1 = HEAP32[$8_1 + 8 >> 2]; 6247 break block; 6248 } 6249 block4 : { 6250 block10 : { 6251 block9 : { 6252 block8 : { 6253 block7 : { 6254 block6 : { 6255 block5 : { 6256 block2 : { 6257 block3 : { 6258 block1 : { 6259 $5_1 = HEAPU8[$8_1 + 5 | 0]; 6260 if ($5_1 >>> 0 <= 109) { 6261 if ($5_1 >>> 0 <= 97) { 6262 if (($5_1 | 0) == 34) { 6263 break block1 6264 } 6265 if (($5_1 | 0) == 47) { 6266 break block2 6267 } 6268 if (($5_1 | 0) == 92) { 6269 break block3 6270 } 6271 break block4; 6272 } 6273 switch ($5_1 - 98 | 0) { 6274 case 0: 6275 break block5; 6276 case 4: 6277 break block6; 6278 default: 6279 break block4; 6280 }; 6281 } 6282 switch ($5_1 - 110 | 0) { 6283 case 7: 6284 break block10; 6285 case 0: 6286 break block7; 6287 case 4: 6288 break block8; 6289 case 6: 6290 break block9; 6291 default: 6292 break block4; 6293 }; 6294 } 6295 $0_1 = HEAP32[$2_1 + 8 >> 2]; 6296 if (($0_1 | 0) == HEAP32[$2_1 >> 2]) { 6297 $122($2_1) 6298 } 6299 HEAP8[$0_1 + HEAP32[$2_1 + 4 >> 2] | 0] = 34; 6300 HEAP32[$2_1 + 8 >> 2] = $0_1 + 1; 6301 $0_1 = 0; 6302 break block; 6303 } 6304 $0_1 = HEAP32[$2_1 + 8 >> 2]; 6305 if (($0_1 | 0) == HEAP32[$2_1 >> 2]) { 6306 $122($2_1) 6307 } 6308 HEAP8[$0_1 + HEAP32[$2_1 + 4 >> 2] | 0] = 92; 6309 HEAP32[$2_1 + 8 >> 2] = $0_1 + 1; 6310 $0_1 = 0; 6311 break block; 6312 } 6313 $0_1 = HEAP32[$2_1 + 8 >> 2]; 6314 if (($0_1 | 0) == HEAP32[$2_1 >> 2]) { 6315 $122($2_1) 6316 } 6317 HEAP8[$0_1 + HEAP32[$2_1 + 4 >> 2] | 0] = 47; 6318 HEAP32[$2_1 + 8 >> 2] = $0_1 + 1; 6319 $0_1 = 0; 6320 break block; 6321 } 6322 $0_1 = HEAP32[$2_1 + 8 >> 2]; 6323 if (($0_1 | 0) == HEAP32[$2_1 >> 2]) { 6324 $122($2_1) 6325 } 6326 HEAP8[$0_1 + HEAP32[$2_1 + 4 >> 2] | 0] = 8; 6327 HEAP32[$2_1 + 8 >> 2] = $0_1 + 1; 6328 $0_1 = 0; 6329 break block; 6330 } 6331 $0_1 = HEAP32[$2_1 + 8 >> 2]; 6332 if (($0_1 | 0) == HEAP32[$2_1 >> 2]) { 6333 $122($2_1) 6334 } 6335 HEAP8[$0_1 + HEAP32[$2_1 + 4 >> 2] | 0] = 12; 6336 HEAP32[$2_1 + 8 >> 2] = $0_1 + 1; 6337 $0_1 = 0; 6338 break block; 6339 } 6340 $0_1 = HEAP32[$2_1 + 8 >> 2]; 6341 if (($0_1 | 0) == HEAP32[$2_1 >> 2]) { 6342 $122($2_1) 6343 } 6344 HEAP8[$0_1 + HEAP32[$2_1 + 4 >> 2] | 0] = 10; 6345 HEAP32[$2_1 + 8 >> 2] = $0_1 + 1; 6346 $0_1 = 0; 6347 break block; 6348 } 6349 $0_1 = HEAP32[$2_1 + 8 >> 2]; 6350 if (($0_1 | 0) == HEAP32[$2_1 >> 2]) { 6351 $122($2_1) 6352 } 6353 HEAP8[$0_1 + HEAP32[$2_1 + 4 >> 2] | 0] = 13; 6354 HEAP32[$2_1 + 8 >> 2] = $0_1 + 1; 6355 $0_1 = 0; 6356 break block; 6357 } 6358 $0_1 = HEAP32[$2_1 + 8 >> 2]; 6359 if (($0_1 | 0) == HEAP32[$2_1 >> 2]) { 6360 $122($2_1) 6361 } 6362 HEAP8[$0_1 + HEAP32[$2_1 + 4 >> 2] | 0] = 9; 6363 HEAP32[$2_1 + 8 >> 2] = $0_1 + 1; 6364 $0_1 = 0; 6365 break block; 6366 } 6367 $9_1 = $1_1; 6368 $3_1 = $2_1; 6369 $4_1 = global$0 - 32 | 0; 6370 global$0 = $4_1; 6371 block26 : { 6372 block19 : { 6373 block15 : { 6374 block12 : { 6375 block16 : { 6376 $6_1 = $0_1; 6377 $5_1 = HEAP32[$0_1 + 4 >> 2]; 6378 $0_1 = HEAP32[$0_1 + 8 >> 2]; 6379 if ($5_1 >>> 0 >= $0_1 >>> 0) { 6380 block11 : { 6381 if ($5_1 - $0_1 >>> 0 <= 3) { 6382 HEAP32[$6_1 + 8 >> 2] = $5_1; 6383 HEAP32[$4_1 + 20 >> 2] = 4; 6384 $52($4_1 + 12 | 0, $6_1, $4_1 + 20 | 0); 6385 $1_1 = $5_1; 6386 break block11; 6387 } 6388 $1_1 = $0_1 + 4 | 0; 6389 HEAP32[$6_1 + 8 >> 2] = $1_1; 6390 $0_1 = $0_1 + HEAP32[$6_1 >> 2] | 0; 6391 $0_1 = (HEAPU16[(HEAPU8[$0_1 + 1 | 0] << 1) + 1056264 >> 1] | HEAPU16[(HEAPU8[$0_1 | 0] << 1) + 1056776 >> 1]) << 16 >> 16 << 8 | HEAP16[(HEAPU8[$0_1 + 2 | 0] << 1) + 1056776 >> 1] | HEAP16[(HEAPU8[$0_1 + 3 | 0] << 1) + 1056264 >> 1]; 6392 if (($0_1 | 0) >= 0) { 6393 HEAP16[$4_1 + 12 >> 1] = 0; 6394 HEAP16[$4_1 + 14 >> 1] = $0_1; 6395 break block11; 6396 } 6397 HEAP32[$4_1 + 20 >> 2] = 12; 6398 $52($4_1 + 12 | 0, $6_1, $4_1 + 20 | 0); 6399 } 6400 if (HEAPU16[$4_1 + 12 >> 1] == 1) { 6401 break block12 6402 } 6403 block25 : { 6404 block24 : { 6405 block23 : { 6406 block17 : { 6407 block18 : { 6408 block22 : { 6409 block21 : { 6410 block14 : { 6411 block13 : { 6412 $2_1 = HEAPU16[$4_1 + 14 >> 1]; 6413 if (!(($2_1 & 64512) == 56320 ? $9_1 : 0)) { 6414 if (($2_1 + 9216 & 65535) >>> 0 >= 64512) { 6415 break block13 6416 } 6417 $0_1 = $2_1; 6418 break block14; 6419 } 6420 HEAP32[$4_1 + 20 >> 2] = 20; 6421 $0_1 = $51($6_1, $4_1 + 20 | 0); 6422 break block15; 6423 } 6424 $10_1 = HEAP32[$6_1 >> 2]; 6425 while (1) { 6426 $7_1 = $4_1 + 20 | 0; 6427 $49($7_1, $6_1); 6428 if (HEAPU8[$4_1 + 20 | 0] == 1) { 6429 break block16 6430 } 6431 if (HEAPU8[$4_1 + 21 | 0] != 92) { 6432 break block17 6433 } 6434 HEAP32[$6_1 + 8 >> 2] = $1_1 + 1; 6435 $49($7_1, $6_1); 6436 if (HEAPU8[$4_1 + 20 | 0]) { 6437 break block16 6438 } 6439 if (HEAPU8[$4_1 + 21 | 0] != 117) { 6440 break block18 6441 } 6442 $0_1 = $1_1 + 2 | 0; 6443 HEAP32[$6_1 + 8 >> 2] = $0_1; 6444 if ($0_1 >>> 0 > $5_1 >>> 0) { 6445 break block19 6446 } 6447 block20 : { 6448 if ($5_1 - $0_1 >>> 0 <= 3) { 6449 HEAP32[$6_1 + 8 >> 2] = $5_1; 6450 HEAP32[$4_1 + 20 >> 2] = 4; 6451 $52($4_1 + 12 | 0, $6_1, $7_1); 6452 $1_1 = $5_1; 6453 break block20; 6454 } 6455 $1_1 = $1_1 + 6 | 0; 6456 HEAP32[$6_1 + 8 >> 2] = $1_1; 6457 $0_1 = $0_1 + $10_1 | 0; 6458 $0_1 = (HEAPU16[(HEAPU8[$0_1 + 1 | 0] << 1) + 1056264 >> 1] | HEAPU16[(HEAPU8[$0_1 | 0] << 1) + 1056776 >> 1]) << 16 >> 16 << 8 | HEAP16[(HEAPU8[$0_1 + 2 | 0] << 1) + 1056776 >> 1] | HEAP16[(HEAPU8[$0_1 + 3 | 0] << 1) + 1056264 >> 1]; 6459 if (($0_1 | 0) >= 0) { 6460 HEAP16[$4_1 + 12 >> 1] = 0; 6461 HEAP16[$4_1 + 14 >> 1] = $0_1; 6462 break block20; 6463 } 6464 HEAP32[$4_1 + 20 >> 2] = 12; 6465 $52($4_1 + 12 | 0, $6_1, $4_1 + 20 | 0); 6466 } 6467 if (HEAPU16[$4_1 + 12 >> 1]) { 6468 break block12 6469 } 6470 $0_1 = HEAPU16[$4_1 + 14 >> 1]; 6471 if (($0_1 - -8192 & 65535) >>> 0 > 64511) { 6472 break block21 6473 } 6474 if ($9_1) { 6475 break block22 6476 } 6477 $7_1 = HEAP32[$3_1 + 8 >> 2]; 6478 if (HEAP32[$3_1 >> 2] - $7_1 >>> 0 <= 3) { 6479 $38($3_1, $7_1, 4, 1, 1); 6480 $7_1 = HEAP32[$3_1 + 8 >> 2]; 6481 } 6482 HEAP32[$3_1 + 8 >> 2] = $7_1 + 3; 6483 $7_1 = $7_1 + HEAP32[$3_1 + 4 >> 2] | 0; 6484 HEAP8[$7_1 | 0] = 237; 6485 HEAP8[$7_1 + 2 | 0] = $2_1 & 63 | 128; 6486 HEAP8[$7_1 + 1 | 0] = $2_1 >>> 6 & 47 | 128; 6487 $2_1 = $0_1; 6488 if (($0_1 + 9216 & 65535) >>> 0 >= 64512) { 6489 continue 6490 } 6491 break; 6492 }; 6493 } 6494 if (($0_1 & 65535) >>> 0 < 128) { 6495 break block23 6496 } 6497 $1_1 = HEAP32[$3_1 + 8 >> 2]; 6498 if (HEAP32[$3_1 >> 2] - $1_1 >>> 0 <= 3) { 6499 $38($3_1, $1_1, 4, 1, 1); 6500 $1_1 = HEAP32[$3_1 + 8 >> 2]; 6501 } 6502 $5_1 = $1_1 + HEAP32[$3_1 + 4 >> 2] | 0; 6503 if (($0_1 & 65535) >>> 0 >= 2048) { 6504 break block24 6505 } 6506 $6_1 = $0_1 >>> 6 | -64; 6507 $2_1 = 2; 6508 break block25; 6509 } 6510 $5_1 = $0_1 + 9216 & 65535 | ($2_1 + 10240 & 65535) << 10; 6511 $2_1 = $5_1 + 65536 | 0; 6512 $1_1 = HEAP32[$3_1 + 8 >> 2]; 6513 if (HEAP32[$3_1 >> 2] - $1_1 >>> 0 <= 3) { 6514 $38($3_1, $1_1, 4, 1, 1); 6515 $1_1 = HEAP32[$3_1 + 8 >> 2]; 6516 } 6517 HEAP32[$3_1 + 8 >> 2] = $1_1 + 4; 6518 $1_1 = $1_1 + HEAP32[$3_1 + 4 >> 2] | 0; 6519 HEAP8[$1_1 | 0] = $2_1 >>> 18 | 240; 6520 HEAP8[$1_1 + 3 | 0] = $0_1 & 63 | 128; 6521 HEAP8[$1_1 + 2 | 0] = $5_1 >>> 6 & 63 | 128; 6522 HEAP8[$1_1 + 1 | 0] = $2_1 >>> 12 & 63 | 128; 6523 $0_1 = 0; 6524 break block15; 6525 } 6526 HEAP32[$4_1 + 20 >> 2] = 20; 6527 $0_1 = $51($6_1, $4_1 + 20 | 0); 6528 break block15; 6529 } 6530 if (!$9_1) { 6531 $1_1 = HEAP32[$3_1 + 8 >> 2]; 6532 if (HEAP32[$3_1 >> 2] - $1_1 >>> 0 <= 3) { 6533 $38($3_1, $1_1, 4, 1, 1); 6534 $1_1 = HEAP32[$3_1 + 8 >> 2]; 6535 } 6536 HEAP32[$3_1 + 8 >> 2] = $1_1 + 3; 6537 $0_1 = $1_1 + HEAP32[$3_1 + 4 >> 2] | 0; 6538 HEAP8[$0_1 | 0] = 237; 6539 HEAP8[$0_1 + 2 | 0] = $2_1 & 63 | 128; 6540 HEAP8[$0_1 + 1 | 0] = $2_1 >>> 6 & 47 | 128; 6541 $0_1 = $50($6_1, 0, $3_1); 6542 break block15; 6543 } 6544 HEAP32[$6_1 + 8 >> 2] = $1_1 + 2; 6545 HEAP32[$4_1 + 20 >> 2] = 23; 6546 $0_1 = $51($6_1, $4_1 + 20 | 0); 6547 break block15; 6548 } 6549 if (!$9_1) { 6550 $1_1 = HEAP32[$3_1 + 8 >> 2]; 6551 if (HEAP32[$3_1 >> 2] - $1_1 >>> 0 <= 3) { 6552 $38($3_1, $1_1, 4, 1, 1); 6553 $1_1 = HEAP32[$3_1 + 8 >> 2]; 6554 } 6555 HEAP32[$3_1 + 8 >> 2] = $1_1 + 3; 6556 $0_1 = $1_1 + HEAP32[$3_1 + 4 >> 2] | 0; 6557 HEAP8[$0_1 | 0] = 237; 6558 HEAP8[$0_1 + 2 | 0] = $2_1 & 63 | 128; 6559 HEAP8[$0_1 + 1 | 0] = $2_1 >>> 6 & 47 | 128; 6560 $0_1 = 0; 6561 break block15; 6562 } 6563 HEAP32[$6_1 + 8 >> 2] = $1_1 + 1; 6564 HEAP32[$4_1 + 20 >> 2] = 23; 6565 $0_1 = $51($6_1, $4_1 + 20 | 0); 6566 break block15; 6567 } 6568 $1_1 = HEAP32[$3_1 + 8 >> 2]; 6569 if (($1_1 | 0) == HEAP32[$3_1 >> 2]) { 6570 $122($3_1) 6571 } 6572 HEAP8[$1_1 + HEAP32[$3_1 + 4 >> 2] | 0] = $0_1; 6573 HEAP32[$3_1 + 8 >> 2] = $1_1 + 1; 6574 $0_1 = 0; 6575 break block15; 6576 } 6577 HEAP8[$5_1 + 1 | 0] = $0_1 >>> 6 & 63 | 128; 6578 $6_1 = ($0_1 & 61440) >>> 12 | -32; 6579 $2_1 = 3; 6580 } 6581 HEAP8[$5_1 | 0] = $6_1; 6582 HEAP32[$3_1 + 8 >> 2] = $1_1 + $2_1; 6583 HEAP8[($2_1 + $5_1 | 0) - 1 | 0] = $0_1 & 63 | 128; 6584 $0_1 = 0; 6585 break block15; 6586 } 6587 break block19; 6588 } 6589 $0_1 = HEAP32[$4_1 + 24 >> 2]; 6590 break block15; 6591 } 6592 $0_1 = HEAP32[$4_1 + 16 >> 2]; 6593 } 6594 global$0 = $4_1 + 32 | 0; 6595 break block26; 6596 } 6597 $135($0_1, $5_1, $5_1, 1057984); 6598 wasm2js_trap(); 6599 } 6600 break block; 6601 } 6602 HEAP32[$8_1 + 4 >> 2] = 12; 6603 $0_1 = $51($0_1, $8_1 + 4 | 0); 6604 } 6605 global$0 = $8_1 + 16 | 0; 6606 return $0_1; 6607 } 6608 6609 function $51($0_1, $1_1) { 6610 var $2_1 = 0; 6611 $2_1 = global$0 - 16 | 0; 6612 global$0 = $2_1; 6613 $54($2_1 + 8 | 0, $0_1, HEAP32[$0_1 + 8 >> 2]); 6614 $0_1 = $55($1_1, HEAP32[$2_1 + 8 >> 2], HEAP32[$2_1 + 12 >> 2]); 6615 global$0 = $2_1 + 16 | 0; 6616 return $0_1; 6617 } 6618 6619 function $52($0_1, $1_1, $2_1) { 6620 var $3_1 = 0; 6621 $3_1 = global$0 - 16 | 0; 6622 global$0 = $3_1; 6623 $54($3_1 + 8 | 0, $1_1, HEAP32[$1_1 + 8 >> 2]); 6624 $1_1 = $55($2_1, HEAP32[$3_1 + 8 >> 2], HEAP32[$3_1 + 12 >> 2]); 6625 HEAP16[$0_1 >> 1] = 1; 6626 HEAP32[$0_1 + 4 >> 2] = $1_1; 6627 global$0 = $3_1 + 16 | 0; 6628 } 6629 6630 function $53($0_1, $1_1, $2_1) { 6631 var $3_1 = 0; 6632 $3_1 = global$0 - 16 | 0; 6633 global$0 = $3_1; 6634 $54($3_1 + 8 | 0, $1_1, HEAP32[$1_1 + 8 >> 2]); 6635 $1_1 = $55($2_1, HEAP32[$3_1 + 8 >> 2], HEAP32[$3_1 + 12 >> 2]); 6636 HEAP32[$0_1 >> 2] = 2; 6637 HEAP32[$0_1 + 4 >> 2] = $1_1; 6638 global$0 = $3_1 + 16 | 0; 6639 } 6640 6641 function $54($0_1, $1_1, $2_1) { 6642 var $3_1 = 0, $4_1 = 0, $5_1 = 0, $6_1 = 0, $7_1 = 0, $8_1 = 0, $9_1 = 0; 6643 block8 : { 6644 $8_1 = HEAP32[$1_1 + 4 >> 2]; 6645 if ($2_1 >>> 0 <= $8_1 >>> 0) { 6646 $1_1 = HEAP32[$1_1 >> 2]; 6647 block : { 6648 if (!$2_1) { 6649 break block 6650 } 6651 block4 : { 6652 block5 : { 6653 block6 : { 6654 block7 : { 6655 block3 : { 6656 block2 : { 6657 block1 : { 6658 $5_1 = $1_1 + $2_1 | 0; 6659 $7_1 = $5_1 - $1_1 | 0; 6660 if ($7_1 >>> 0 <= 3) { 6661 $3_1 = $5_1 - 1 | 0; 6662 break block1; 6663 } 6664 $4_1 = $5_1 - 4 | 0; 6665 $4_1 = HEAPU8[$4_1 | 0] | HEAPU8[$4_1 + 1 | 0] << 8 | (HEAPU8[$4_1 + 2 | 0] << 16 | HEAPU8[$4_1 + 3 | 0] << 24); 6666 if (((16843008 - ($4_1 ^ 168430090) | $4_1) & -2139062144) == -2139062144) { 6667 break block2 6668 } 6669 $3_1 = $5_1 - 1 | 0; 6670 break block3; 6671 } 6672 while (1) { 6673 if (HEAPU8[$3_1 | 0] == 10) { 6674 break block4 6675 } 6676 $4_1 = $1_1 >>> 0 >= $3_1 >>> 0; 6677 $3_1 = $3_1 - 1 | 0; 6678 if (!$4_1) { 6679 continue 6680 } 6681 break; 6682 }; 6683 break block; 6684 } 6685 $4_1 = $5_1 & 3; 6686 $3_1 = $2_1 - $4_1 | 0; 6687 if ($7_1 >>> 0 >= 9) { 6688 $4_1 = $1_1 + $3_1 | 0; 6689 if (($3_1 | 0) < 8) { 6690 break block5 6691 } 6692 break block6; 6693 } 6694 if (($3_1 | 0) <= 0) { 6695 break block 6696 } 6697 $3_1 = ($2_1 + ($4_1 ^ -1) | 0) + $1_1 | 0; 6698 break block7; 6699 } 6700 while (1) { 6701 if (HEAPU8[$3_1 | 0] == 10) { 6702 break block4 6703 } 6704 $4_1 = $1_1 >>> 0 >= $3_1 >>> 0; 6705 $3_1 = $3_1 - 1 | 0; 6706 if (!$4_1) { 6707 continue 6708 } 6709 break; 6710 }; 6711 break block; 6712 } 6713 while (1) { 6714 if (HEAPU8[$3_1 | 0] == 10) { 6715 break block4 6716 } 6717 $4_1 = $1_1 >>> 0 >= $3_1 >>> 0; 6718 $3_1 = $3_1 - 1 | 0; 6719 if (!$4_1) { 6720 continue 6721 } 6722 break; 6723 }; 6724 break block; 6725 } 6726 while (1) { 6727 $5_1 = $3_1 - 8 | 0; 6728 $7_1 = $1_1 + $5_1 | 0; 6729 $6_1 = HEAP32[$7_1 >> 2]; 6730 if (((16843008 - ($6_1 ^ 168430090) | $6_1) & -2139062144) != -2139062144) { 6731 break block5 6732 } 6733 $4_1 = $1_1 + $3_1 | 0; 6734 $6_1 = HEAP32[$4_1 - 4 >> 2]; 6735 if (((16843008 - ($6_1 ^ 168430090) | $6_1) & -2139062144) != -2139062144) { 6736 break block5 6737 } 6738 $6_1 = ($3_1 | 0) < 16; 6739 $4_1 = $7_1; 6740 $3_1 = $5_1; 6741 if (!$6_1) { 6742 continue 6743 } 6744 break; 6745 }; 6746 $4_1 = $1_1 + $3_1 | 0; 6747 } 6748 if ($1_1 >>> 0 >= $4_1 >>> 0) { 6749 break block 6750 } 6751 $3_1 = $4_1 - 1 | 0; 6752 while (1) { 6753 if (HEAPU8[$3_1 | 0] == 10) { 6754 break block4 6755 } 6756 $4_1 = $1_1 >>> 0 >= $3_1 >>> 0; 6757 $3_1 = $3_1 - 1 | 0; 6758 if (!$4_1) { 6759 continue 6760 } 6761 break; 6762 }; 6763 break block; 6764 } 6765 $4_1 = $3_1 - $1_1 | 0; 6766 $9_1 = $4_1 + 1 | 0; 6767 if ($4_1 >>> 0 >= $8_1 >>> 0) { 6768 break block8 6769 } 6770 } 6771 if ($1_1 >>> 0 < $1_1 + $9_1 >>> 0) { 6772 $3_1 = 0; 6773 $4_1 = $9_1; 6774 while (1) { 6775 $3_1 = (HEAPU8[$1_1 | 0] == 10) + $3_1 | 0; 6776 $1_1 = $1_1 + 1 | 0; 6777 $4_1 = $4_1 - 1 | 0; 6778 if ($4_1) { 6779 continue 6780 } 6781 break; 6782 }; 6783 $1_1 = $3_1 + 1 | 0; 6784 } else { 6785 $1_1 = 1 6786 } 6787 HEAP32[$0_1 >> 2] = $1_1; 6788 HEAP32[$0_1 + 4 >> 2] = $2_1 - $9_1; 6789 return; 6790 } 6791 $135(0, $2_1, $8_1, 1053580); 6792 wasm2js_trap(); 6793 } 6794 $135(0, $9_1, $8_1, 1053596); 6795 wasm2js_trap(); 6796 } 6797 6798 function $55($0_1, $1_1, $2_1) { 6799 var $3_1 = 0; 6800 $3_1 = $33(20, 4); 6801 if (!$3_1) { 6802 $123(4, 20); 6803 wasm2js_trap(); 6804 } 6805 HEAP32[$3_1 + 16 >> 2] = $2_1; 6806 HEAP32[$3_1 + 12 >> 2] = $1_1; 6807 HEAP32[$3_1 + 8 >> 2] = HEAP32[$0_1 + 8 >> 2]; 6808 $1_1 = HEAP32[$0_1 + 4 >> 2]; 6809 HEAP32[$3_1 >> 2] = HEAP32[$0_1 >> 2]; 6810 HEAP32[$3_1 + 4 >> 2] = $1_1; 6811 return $3_1; 6812 } 6813 6814 function $56($0_1, $1_1, $2_1, $3_1) { 6815 var $4_1 = 0, $5_1 = 0, $6_1 = 0, $7_1 = 0, $8_1 = 0, $9_1 = 0, $10_1 = 0, $11_1 = 0, $12_1 = 0, $13_1 = 0; 6816 $7_1 = global$0 - 32 | 0; 6817 global$0 = $7_1; 6818 $9_1 = $7_1 + 8 | 0; 6819 block18 : { 6820 block : { 6821 if (!$3_1) { 6822 break block 6823 } 6824 $5_1 = $3_1 - 7 | 0; 6825 $11_1 = $3_1 >>> 0 >= $5_1 >>> 0 ? $5_1 : 0; 6826 $12_1 = ($2_1 + 3 & -4) - $2_1 | 0; 6827 $5_1 = 0; 6828 while (1) { 6829 block19 : { 6830 block2 : { 6831 block1 : { 6832 $8_1 = HEAPU8[$2_1 + $5_1 | 0]; 6833 $10_1 = $8_1 << 24 >> 24; 6834 if (($10_1 | 0) >= 0) { 6835 if ($12_1 - $5_1 & 3) { 6836 break block1 6837 } 6838 if ($5_1 >>> 0 >= $11_1 >>> 0) { 6839 break block2 6840 } 6841 while (1) { 6842 $4_1 = $2_1 + $5_1 | 0; 6843 if ((HEAP32[$4_1 + 4 >> 2] | HEAP32[$4_1 >> 2]) & -2139062144) { 6844 break block2 6845 } 6846 $5_1 = $5_1 + 8 | 0; 6847 if ($11_1 >>> 0 > $5_1 >>> 0) { 6848 continue 6849 } 6850 break; 6851 }; 6852 break block2; 6853 } 6854 $6_1 = 257; 6855 block10 : { 6856 block6 : { 6857 block13 : { 6858 block9 : { 6859 block8 : { 6860 block7 : { 6861 block5 : { 6862 switch (HEAPU8[$8_1 + 1064095 | 0] - 2 | 0) { 6863 case 0: 6864 $4_1 = $5_1 + 1 | 0; 6865 if ($3_1 >>> 0 > $4_1 >>> 0) { 6866 break block7 6867 } 6868 $6_1 = 0; 6869 break block6; 6870 case 1: 6871 $4_1 = $5_1 + 1 | 0; 6872 if ($3_1 >>> 0 > $4_1 >>> 0) { 6873 break block8 6874 } 6875 $6_1 = 0; 6876 break block6; 6877 case 2: 6878 break block5; 6879 default: 6880 break block6; 6881 }; 6882 } 6883 $4_1 = $5_1 + 1 | 0; 6884 if ($3_1 >>> 0 > $4_1 >>> 0) { 6885 break block9 6886 } 6887 $6_1 = 0; 6888 break block6; 6889 } 6890 if (HEAP8[$2_1 + $4_1 | 0] > -65) { 6891 break block6 6892 } 6893 break block10; 6894 } 6895 $4_1 = HEAP8[$2_1 + $4_1 | 0]; 6896 block12 : { 6897 block11 : { 6898 $8_1 = $8_1 - 224 | 0; 6899 if ($8_1) { 6900 if (($8_1 | 0) == 13) { 6901 break block11 6902 } else { 6903 break block12 6904 } 6905 } 6906 if (($4_1 & -32) == -96) { 6907 break block13 6908 } 6909 break block6; 6910 } 6911 if (($4_1 | 0) > -97) { 6912 break block6 6913 } 6914 break block13; 6915 } 6916 if (($10_1 + 31 & 255) >>> 0 >= 12) { 6917 if (($10_1 & -2) != -18) { 6918 break block6 6919 } 6920 if (($4_1 | 0) < -64) { 6921 break block13 6922 } 6923 break block6; 6924 } 6925 if (($4_1 | 0) < -64) { 6926 break block13 6927 } 6928 break block6; 6929 } 6930 $4_1 = HEAP8[$2_1 + $4_1 | 0]; 6931 block17 : { 6932 block16 : { 6933 switch ($8_1 - 240 | 0) { 6934 default: 6935 if (($10_1 + 15 & 255) >>> 0 > 2) { 6936 break block6 6937 } 6938 if (($4_1 | 0) < -64) { 6939 break block17 6940 } 6941 break block6; 6942 case 0: 6943 if (($4_1 + 112 & 255) >>> 0 < 48) { 6944 break block17 6945 } 6946 break block6; 6947 case 4: 6948 break block16; 6949 }; 6950 } 6951 if (($4_1 | 0) > -113) { 6952 break block6 6953 } 6954 } 6955 $4_1 = $5_1 + 2 | 0; 6956 if ($4_1 >>> 0 >= $3_1 >>> 0) { 6957 $6_1 = 0; 6958 break block6; 6959 } 6960 if (HEAP8[$2_1 + $4_1 | 0] > -65) { 6961 $6_1 = 513; 6962 break block6; 6963 } 6964 $6_1 = 0; 6965 $4_1 = $5_1 + 3 | 0; 6966 if ($3_1 >>> 0 <= $4_1 >>> 0) { 6967 break block6 6968 } 6969 if (HEAP8[$2_1 + $4_1 | 0] < -64) { 6970 break block10 6971 } 6972 $6_1 = 769; 6973 break block6; 6974 } 6975 $6_1 = 0; 6976 $4_1 = $5_1 + 2 | 0; 6977 if ($3_1 >>> 0 <= $4_1 >>> 0) { 6978 break block6 6979 } 6980 if (HEAP8[$2_1 + $4_1 | 0] <= -65) { 6981 break block10 6982 } 6983 $6_1 = 513; 6984 } 6985 HEAP32[$9_1 + 4 >> 2] = $5_1 | $13_1; 6986 HEAP32[$9_1 + 8 >> 2] = $6_1; 6987 HEAP32[$9_1 >> 2] = 1; 6988 break block18; 6989 } 6990 $5_1 = $4_1 + 1 | 0; 6991 break block19; 6992 } 6993 $5_1 = $5_1 + 1 | 0; 6994 break block19; 6995 } 6996 if ($3_1 >>> 0 <= $5_1 >>> 0) { 6997 break block19 6998 } 6999 while (1) { 7000 if (HEAP8[$2_1 + $5_1 | 0] < 0) { 7001 break block19 7002 } 7003 $5_1 = $5_1 + 1 | 0; 7004 if (($5_1 | 0) != ($3_1 | 0)) { 7005 continue 7006 } 7007 break; 7008 }; 7009 break block; 7010 } 7011 if ($3_1 >>> 0 > $5_1 >>> 0) { 7012 continue 7013 } 7014 break; 7015 }; 7016 } 7017 HEAP32[$9_1 + 8 >> 2] = $3_1; 7018 HEAP32[$9_1 + 4 >> 2] = $2_1; 7019 HEAP32[$9_1 >> 2] = 0; 7020 } 7021 block20 : { 7022 if (HEAP32[$7_1 + 8 >> 2] == 1) { 7023 HEAP32[$7_1 + 20 >> 2] = 15; 7024 $2_1 = global$0 - 16 | 0; 7025 global$0 = $2_1; 7026 $54($2_1 + 8 | 0, $1_1, HEAP32[$1_1 + 8 >> 2]); 7027 $1_1 = $55($7_1 + 20 | 0, HEAP32[$2_1 + 8 >> 2], HEAP32[$2_1 + 12 >> 2]); 7028 HEAP32[$0_1 >> 2] = 0; 7029 HEAP32[$0_1 + 4 >> 2] = $1_1; 7030 global$0 = $2_1 + 16 | 0; 7031 break block20; 7032 } 7033 $1_1 = HEAP32[$7_1 + 16 >> 2]; 7034 HEAP32[$0_1 >> 2] = HEAP32[$7_1 + 12 >> 2]; 7035 HEAP32[$0_1 + 4 >> 2] = $1_1; 7036 } 7037 global$0 = $7_1 + 32 | 0; 7038 } 7039 7040 function $57($0_1) { 7041 var $1_1 = 0, $2_1 = 0; 7042 $1_1 = HEAP32[$0_1 >> 2]; 7043 $2_1 = HEAP32[$0_1 + 4 >> 2]; 7044 $0_1 = $33(20, 4); 7045 if (!$0_1) { 7046 $123(4, 20); 7047 wasm2js_trap(); 7048 } 7049 HEAP32[$0_1 + 12 >> 2] = 0; 7050 HEAP32[$0_1 + 16 >> 2] = 0; 7051 HEAP32[$0_1 + 4 >> 2] = $1_1; 7052 HEAP32[$0_1 + 8 >> 2] = $2_1; 7053 HEAP32[$0_1 >> 2] = 1; 7054 return $0_1; 7055 } 7056 7057 function $58($0_1, $1_1, $2_1, $3_1) { 7058 var $4_1 = 0, $5_1 = 0, $6_1 = 0, $7_1 = 0, $8_1 = 0, $9_1 = 0, $10_1 = 0, $11_1 = 0, $12_1 = 0, $13_1 = 0, $14_1 = 0, $15_1 = 0, $16_1 = 0, $17_1 = 0, $18_1 = 0, $19_1 = 0, $20_1 = 0, $21_1 = 0, $22_1 = 0, $23_1 = 0, $24_1 = 0, $25_1 = 0, $26_1 = 0, $27_1 = 0; 7059 $17_1 = global$0 - 48 | 0; 7060 global$0 = $17_1; 7061 $8_1 = $17_1 + 4 | 0; 7062 $4_1 = global$0 - 32 | 0; 7063 global$0 = $4_1; 7064 block1 : { 7065 block : { 7066 $6_1 = HEAP32[$1_1 >> 2]; 7067 if ($6_1) { 7068 $11_1 = HEAP32[$1_1 + 4 >> 2]; 7069 HEAP32[$4_1 + 28 >> 2] = $11_1; 7070 HEAP32[$4_1 + 24 >> 2] = $6_1; 7071 $36($4_1 + 16 | 0, $4_1 + 24 | 0, $2_1); 7072 $14_1 = HEAP32[$4_1 + 20 >> 2]; 7073 if (HEAP32[$4_1 + 16 >> 2] == 1) { 7074 while (1) { 7075 if (!$11_1) { 7076 break block 7077 } 7078 $6_1 = HEAP32[(($14_1 << 2) + $6_1 | 0) + 408 >> 2]; 7079 $11_1 = $11_1 - 1 | 0; 7080 HEAP32[$4_1 + 28 >> 2] = $11_1; 7081 HEAP32[$4_1 + 24 >> 2] = $6_1; 7082 $36($4_1 + 8 | 0, $4_1 + 24 | 0, $2_1); 7083 $14_1 = HEAP32[$4_1 + 12 >> 2]; 7084 if (HEAP32[$4_1 + 8 >> 2] & 1) { 7085 continue 7086 } 7087 break; 7088 } 7089 } 7090 HEAP32[$8_1 + 16 >> 2] = $1_1; 7091 HEAP32[$8_1 + 12 >> 2] = $14_1; 7092 HEAP32[$8_1 + 8 >> 2] = $11_1; 7093 HEAP32[$8_1 + 4 >> 2] = $6_1; 7094 HEAP32[$8_1 >> 2] = -1; 7095 $45($2_1, 1, 1); 7096 break block1; 7097 } 7098 HEAP32[$8_1 + 16 >> 2] = 0; 7099 HEAP32[$8_1 + 12 >> 2] = $1_1; 7100 HEAP32[$8_1 + 8 >> 2] = HEAP32[$2_1 + 8 >> 2]; 7101 $5_1 = HEAP32[$2_1 + 4 >> 2]; 7102 HEAP32[$8_1 >> 2] = HEAP32[$2_1 >> 2]; 7103 HEAP32[$8_1 + 4 >> 2] = $5_1; 7104 break block1; 7105 } 7106 HEAP32[$8_1 + 24 >> 2] = $14_1; 7107 HEAP32[$8_1 + 20 >> 2] = 0; 7108 HEAP32[$8_1 + 16 >> 2] = $6_1; 7109 HEAP32[$8_1 + 12 >> 2] = $1_1; 7110 HEAP32[$8_1 + 8 >> 2] = HEAP32[$2_1 + 8 >> 2]; 7111 $7_1 = HEAP32[$2_1 + 4 >> 2]; 7112 HEAP32[$8_1 >> 2] = HEAP32[$2_1 >> 2]; 7113 HEAP32[$8_1 + 4 >> 2] = $7_1; 7114 } 7115 global$0 = $4_1 + 32 | 0; 7116 block2 : { 7117 if (HEAP32[$17_1 + 4 >> 2] == -1) { 7118 $1_1 = HEAP32[$17_1 + 8 >> 2] + Math_imul(HEAP32[$17_1 + 16 >> 2], 24) | 0; 7119 $4_1 = HEAP32[$1_1 >> 2]; 7120 $2_1 = HEAP32[$1_1 + 4 >> 2]; 7121 $7_1 = HEAP32[$3_1 + 4 >> 2]; 7122 HEAP32[$1_1 >> 2] = HEAP32[$3_1 >> 2]; 7123 HEAP32[$1_1 + 4 >> 2] = $7_1; 7124 $5_1 = $0_1; 7125 HEAP32[$5_1 >> 2] = $4_1; 7126 HEAP32[$5_1 + 4 >> 2] = $2_1; 7127 $4_1 = HEAP32[$1_1 + 8 >> 2]; 7128 $2_1 = HEAP32[$1_1 + 12 >> 2]; 7129 $7_1 = HEAP32[$3_1 + 12 >> 2]; 7130 HEAP32[$1_1 + 8 >> 2] = HEAP32[$3_1 + 8 >> 2]; 7131 HEAP32[$1_1 + 12 >> 2] = $7_1; 7132 HEAP32[$5_1 + 8 >> 2] = $4_1; 7133 HEAP32[$5_1 + 12 >> 2] = $2_1; 7134 $4_1 = HEAP32[$1_1 + 16 >> 2]; 7135 $2_1 = HEAP32[$1_1 + 20 >> 2]; 7136 $7_1 = HEAP32[$3_1 + 20 >> 2]; 7137 HEAP32[$1_1 + 16 >> 2] = HEAP32[$3_1 + 16 >> 2]; 7138 HEAP32[$1_1 + 20 >> 2] = $7_1; 7139 HEAP32[$5_1 + 16 >> 2] = $4_1; 7140 HEAP32[$5_1 + 20 >> 2] = $2_1; 7141 break block2; 7142 } 7143 $22_1 = $17_1 + 32 | 0; 7144 $14_1 = 0; 7145 $19_1 = global$0 - 16 | 0; 7146 global$0 = $19_1; 7147 $8_1 = $17_1 + 4 | 0; 7148 $1_1 = $8_1 + 12 | 0; 7149 block26 : { 7150 block25 : { 7151 block24 : { 7152 if (HEAP32[$8_1 + 16 >> 2]) { 7153 $20_1 = $19_1 + 4 | 0; 7154 $2_1 = $3_1; 7155 $14_1 = $1_1; 7156 $9_1 = global$0 - 144 | 0; 7157 global$0 = $9_1; 7158 $13_1 = $9_1 + 16 | 0; 7159 $10_1 = global$0 - 80 | 0; 7160 global$0 = $10_1; 7161 $1_1 = $8_1 + 16 | 0; 7162 $15_1 = $1_1; 7163 $7_1 = HEAP32[$1_1 >> 2]; 7164 block8 : { 7165 if (HEAPU16[$7_1 + 402 >> 1] >= 11) { 7166 $4_1 = $10_1 - -64 | 0; 7167 $6_1 = $10_1 + 68 | 0; 7168 $3_1 = 4; 7169 $1_1 = HEAP32[$1_1 + 8 >> 2]; 7170 block3 : { 7171 if ($1_1 >>> 0 < 5) { 7172 break block3 7173 } 7174 $5_1 = $10_1 + 72 | 0; 7175 $12_1 = $10_1 + 76 | 0; 7176 $3_1 = $1_1; 7177 block6 : { 7178 block4 : { 7179 switch ($1_1 - 5 | 0) { 7180 default: 7181 $3_1 = 6; 7182 $1_1 = $1_1 - 7 | 0; 7183 break block6; 7184 case 0: 7185 break block3; 7186 case 1: 7187 break block4; 7188 }; 7189 } 7190 $3_1 = 5; 7191 $1_1 = 0; 7192 } 7193 $4_1 = $5_1; 7194 $6_1 = $12_1; 7195 } 7196 HEAP32[$10_1 + 20 >> 2] = $3_1; 7197 HEAP32[$10_1 + 12 >> 2] = $7_1; 7198 HEAP32[$10_1 + 16 >> 2] = HEAP32[$15_1 + 4 >> 2]; 7199 $3_1 = $39(); 7200 HEAP16[$3_1 + 402 >> 1] = 0; 7201 HEAP32[$3_1 + 264 >> 2] = 0; 7202 $11_1 = $10_1 + 24 | 0; 7203 $12_1 = $10_1 + 12 | 0; 7204 $42($11_1, $12_1, $3_1); 7205 HEAP32[$11_1 + 52 >> 2] = 0; 7206 HEAP32[$11_1 + 48 >> 2] = $3_1; 7207 $5_1 = $12_1; 7208 $3_1 = HEAP32[$5_1 >> 2]; 7209 $5_1 = HEAP32[$5_1 + 4 >> 2]; 7210 $7_1 = $11_1; 7211 HEAP32[$7_1 + 40 >> 2] = $3_1; 7212 HEAP32[$7_1 + 44 >> 2] = $5_1; 7213 $4_1 = HEAP32[$4_1 >> 2]; 7214 $3_1 = ($4_1 + 268 | 0) + Math_imul($1_1, 12) | 0; 7215 $11_1 = HEAP32[$6_1 >> 2]; 7216 $6_1 = HEAPU16[$4_1 + 402 >> 1]; 7217 block7 : { 7218 if ($6_1 >>> 0 <= $1_1 >>> 0) { 7219 HEAP32[$3_1 + 8 >> 2] = HEAP32[$8_1 + 8 >> 2]; 7220 $7_1 = HEAP32[$8_1 + 4 >> 2]; 7221 HEAP32[$3_1 >> 2] = HEAP32[$8_1 >> 2]; 7222 HEAP32[$3_1 + 4 >> 2] = $7_1; 7223 break block7; 7224 } 7225 $12_1 = $6_1 - $1_1 | 0; 7226 $15_1 = Math_imul($12_1, 12); 7227 if ($15_1) { 7228 wasm2js_memory_copy($3_1 + 12 | 0, $3_1, $15_1) 7229 } 7230 HEAP32[$3_1 + 8 >> 2] = HEAP32[$8_1 + 8 >> 2]; 7231 $5_1 = HEAP32[$8_1 + 4 >> 2]; 7232 HEAP32[$3_1 >> 2] = HEAP32[$8_1 >> 2]; 7233 HEAP32[$3_1 + 4 >> 2] = $5_1; 7234 $3_1 = Math_imul($12_1, 24); 7235 if (!$3_1) { 7236 break block7 7237 } 7238 $12_1 = Math_imul($1_1, 24) + $4_1 | 0; 7239 wasm2js_memory_copy($12_1 + 24 | 0, $12_1, $3_1); 7240 } 7241 $7_1 = HEAP32[$2_1 + 20 >> 2]; 7242 $3_1 = Math_imul($1_1, 24) + $4_1 | 0; 7243 HEAP32[$3_1 + 16 >> 2] = HEAP32[$2_1 + 16 >> 2]; 7244 HEAP32[$3_1 + 20 >> 2] = $7_1; 7245 $5_1 = HEAP32[$2_1 + 12 >> 2]; 7246 HEAP32[$3_1 + 8 >> 2] = HEAP32[$2_1 + 8 >> 2]; 7247 HEAP32[$3_1 + 12 >> 2] = $5_1; 7248 $7_1 = HEAP32[$2_1 + 4 >> 2]; 7249 HEAP32[$3_1 >> 2] = HEAP32[$2_1 >> 2]; 7250 HEAP32[$3_1 + 4 >> 2] = $7_1; 7251 HEAP16[$4_1 + 402 >> 1] = $6_1 + 1; 7252 wasm2js_memory_copy($13_1, $10_1 + 24 | 0, 56); 7253 HEAP32[$13_1 + 64 >> 2] = $1_1; 7254 HEAP32[$13_1 + 60 >> 2] = $11_1; 7255 HEAP32[$13_1 + 56 >> 2] = $4_1; 7256 break block8; 7257 } 7258 $6_1 = $10_1 + 12 | 0; 7259 $1_1 = HEAP32[$15_1 >> 2]; 7260 $7_1 = $1_1 + 268 | 0; 7261 $3_1 = HEAP32[$15_1 + 8 >> 2]; 7262 $4_1 = $7_1 + Math_imul($3_1, 12) | 0; 7263 $11_1 = $3_1 + 1 | 0; 7264 $12_1 = HEAPU16[$1_1 + 402 >> 1]; 7265 block9 : { 7266 if ($11_1 >>> 0 > $12_1 >>> 0) { 7267 HEAP32[$4_1 + 8 >> 2] = HEAP32[$8_1 + 8 >> 2]; 7268 $5_1 = HEAP32[$8_1 + 4 >> 2]; 7269 HEAP32[$4_1 >> 2] = HEAP32[$8_1 >> 2]; 7270 HEAP32[$4_1 + 4 >> 2] = $5_1; 7271 break block9; 7272 } 7273 $16_1 = $12_1 - $3_1 | 0; 7274 $5_1 = Math_imul($16_1, 12); 7275 if ($5_1) { 7276 wasm2js_memory_copy(Math_imul($11_1, 12) + $7_1 | 0, $4_1, $5_1) 7277 } 7278 HEAP32[$4_1 + 8 >> 2] = HEAP32[$8_1 + 8 >> 2]; 7279 $7_1 = HEAP32[$8_1 + 4 >> 2]; 7280 HEAP32[$4_1 >> 2] = HEAP32[$8_1 >> 2]; 7281 HEAP32[$4_1 + 4 >> 2] = $7_1; 7282 $4_1 = Math_imul($16_1, 24); 7283 if (!$4_1) { 7284 break block9 7285 } 7286 wasm2js_memory_copy(Math_imul($11_1, 24) + $1_1 | 0, Math_imul($3_1, 24) + $1_1 | 0, $4_1); 7287 } 7288 $5_1 = HEAP32[$2_1 + 20 >> 2]; 7289 $4_1 = Math_imul($3_1, 24) + $1_1 | 0; 7290 HEAP32[$4_1 + 16 >> 2] = HEAP32[$2_1 + 16 >> 2]; 7291 HEAP32[$4_1 + 20 >> 2] = $5_1; 7292 HEAP32[$6_1 + 8 >> 2] = $3_1; 7293 HEAP32[$6_1 >> 2] = $1_1; 7294 HEAP32[$6_1 + 4 >> 2] = HEAP32[$15_1 + 4 >> 2]; 7295 $7_1 = HEAP32[$2_1 + 12 >> 2]; 7296 HEAP32[$4_1 + 8 >> 2] = HEAP32[$2_1 + 8 >> 2]; 7297 HEAP32[$4_1 + 12 >> 2] = $7_1; 7298 $5_1 = HEAP32[$2_1 + 4 >> 2]; 7299 HEAP32[$4_1 >> 2] = HEAP32[$2_1 >> 2]; 7300 HEAP32[$4_1 + 4 >> 2] = $5_1; 7301 HEAP16[$1_1 + 402 >> 1] = $12_1 + 1; 7302 HEAP32[$13_1 >> 2] = -1; 7303 HEAP32[$13_1 + 64 >> 2] = HEAP32[$10_1 + 20 >> 2]; 7304 $7_1 = HEAP32[$10_1 + 16 >> 2]; 7305 $5_1 = $13_1; 7306 HEAP32[$5_1 + 56 >> 2] = HEAP32[$10_1 + 12 >> 2]; 7307 HEAP32[$5_1 + 60 >> 2] = $7_1; 7308 } 7309 global$0 = $10_1 + 80 | 0; 7310 block23 : { 7311 if (HEAP32[$9_1 + 16 >> 2] != -1) { 7312 $4_1 = HEAP32[$9_1 + 60 >> 2]; 7313 $6_1 = HEAP32[$9_1 + 56 >> 2]; 7314 wasm2js_memory_copy($9_1 + 104 | 0, $13_1, 40); 7315 $25_1 = HEAP32[$9_1 + 80 >> 2]; 7316 $26_1 = HEAP32[$9_1 + 72 >> 2]; 7317 $27_1 = HEAP32[$9_1 + 76 >> 2]; 7318 $2_1 = HEAP32[$9_1 + 64 >> 2]; 7319 $1_1 = HEAP32[$9_1 + 68 >> 2]; 7320 block19 : { 7321 $3_1 = HEAP32[$6_1 + 264 >> 2]; 7322 block18 : { 7323 if ($3_1) { 7324 $24_1 = $9_1 + 120 | 0; 7325 while (1) { 7326 HEAP32[$9_1 + 100 >> 2] = HEAPU16[$6_1 + 400 >> 1]; 7327 HEAP32[$9_1 + 96 >> 2] = $4_1 + 1; 7328 HEAP32[$9_1 + 92 >> 2] = $3_1; 7329 $15_1 = $9_1 + 16 | 0; 7330 $7_1 = $9_1 + 104 | 0; 7331 $6_1 = $2_1; 7332 $10_1 = global$0 - 96 | 0; 7333 global$0 = $10_1; 7334 block17 : { 7335 block10 : { 7336 $2_1 = $9_1 + 92 | 0; 7337 $13_1 = HEAP32[$2_1 + 4 >> 2]; 7338 if (($1_1 | 0) == ($13_1 - 1 | 0)) { 7339 $16_1 = HEAP32[$2_1 >> 2]; 7340 if (HEAPU16[$16_1 + 402 >> 1] < 11) { 7341 break block10 7342 } 7343 $4_1 = $10_1 - -64 | 0; 7344 $3_1 = $10_1 + 68 | 0; 7345 $1_1 = 4; 7346 $2_1 = HEAP32[$2_1 + 8 >> 2]; 7347 block11 : { 7348 if ($2_1 >>> 0 < 5) { 7349 break block11 7350 } 7351 $5_1 = $10_1 + 72 | 0; 7352 $12_1 = $10_1 + 76 | 0; 7353 block14 : { 7354 block12 : { 7355 block13 : { 7356 $1_1 = $2_1; 7357 switch ($1_1 - 5 | 0) { 7358 case 0: 7359 break block11; 7360 case 1: 7361 break block12; 7362 default: 7363 break block13; 7364 }; 7365 } 7366 $2_1 = $2_1 - 7 | 0; 7367 $1_1 = 6; 7368 break block14; 7369 } 7370 $2_1 = 0; 7371 $1_1 = 5; 7372 } 7373 $4_1 = $5_1; 7374 $3_1 = $12_1; 7375 } 7376 HEAP32[$10_1 + 20 >> 2] = $1_1; 7377 HEAP32[$10_1 + 16 >> 2] = $13_1; 7378 HEAP32[$10_1 + 12 >> 2] = $16_1; 7379 $1_1 = $10_1 + 24 | 0; 7380 $16_1 = global$0 - 48 | 0; 7381 global$0 = $16_1; 7382 $5_1 = $10_1 + 12 | 0; 7383 $23_1 = HEAP32[$5_1 >> 2]; 7384 $13_1 = HEAPU16[$23_1 + 402 >> 1]; 7385 $11_1 = $40(); 7386 HEAP16[$11_1 + 402 >> 1] = 0; 7387 HEAP32[$11_1 + 264 >> 2] = 0; 7388 $42($16_1 + 8 | 0, $5_1, $11_1); 7389 $18_1 = HEAPU16[$11_1 + 402 >> 1]; 7390 $12_1 = $18_1 + 1 | 0; 7391 block16 : { 7392 block15 : { 7393 if ($18_1 >>> 0 <= 11) { 7394 $18_1 = HEAP32[$5_1 + 8 >> 2]; 7395 if (($12_1 | 0) != ($13_1 - $18_1 | 0)) { 7396 break block15 7397 } 7398 $13_1 = $11_1 + 408 | 0; 7399 $21_1 = $12_1 << 2; 7400 if ($21_1) { 7401 wasm2js_memory_copy($13_1, (($18_1 << 2) + $23_1 | 0) + 412 | 0, $21_1) 7402 } 7403 $18_1 = HEAP32[$5_1 + 4 >> 2]; 7404 $5_1 = 0; 7405 while (1) { 7406 $21_1 = HEAP32[$13_1 >> 2]; 7407 HEAP16[$21_1 + 400 >> 1] = $5_1; 7408 HEAP32[$21_1 + 264 >> 2] = $11_1; 7409 $13_1 = $13_1 + 4 | 0; 7410 $5_1 = $5_1 + 1 | 0; 7411 if (($5_1 | 0) != ($12_1 | 0)) { 7412 continue 7413 } 7414 break; 7415 }; 7416 HEAP32[$1_1 + 44 >> 2] = $18_1; 7417 HEAP32[$1_1 + 40 >> 2] = $23_1; 7418 wasm2js_memory_copy($1_1, $16_1 + 8 | 0, 40); 7419 HEAP32[$1_1 + 52 >> 2] = $18_1; 7420 HEAP32[$1_1 + 48 >> 2] = $11_1; 7421 global$0 = $16_1 + 48 | 0; 7422 break block16; 7423 } 7424 $135(0, $12_1, 12, 1053360); 7425 wasm2js_trap(); 7426 } 7427 $129(1053424, 40, 1053464); 7428 wasm2js_trap(); 7429 } 7430 HEAP32[$10_1 + 92 >> 2] = $2_1; 7431 HEAP32[$10_1 + 88 >> 2] = HEAP32[$3_1 >> 2]; 7432 HEAP32[$10_1 + 84 >> 2] = HEAP32[$4_1 >> 2]; 7433 $41($10_1 + 84 | 0, $7_1, $24_1, $6_1); 7434 wasm2js_memory_copy($15_1, $1_1, 56); 7435 break block17; 7436 } 7437 $129(1053288, 53, 1053344); 7438 wasm2js_trap(); 7439 } 7440 $41($2_1, $7_1, $24_1, $6_1); 7441 HEAP32[$15_1 >> 2] = -1; 7442 } 7443 global$0 = $10_1 + 96 | 0; 7444 if (HEAP32[$9_1 + 16 >> 2] == -1) { 7445 break block18 7446 } 7447 $4_1 = HEAP32[$9_1 + 60 >> 2]; 7448 $6_1 = HEAP32[$9_1 + 56 >> 2]; 7449 wasm2js_memory_copy($7_1, $15_1, 40); 7450 $2_1 = HEAP32[$9_1 + 64 >> 2]; 7451 $1_1 = HEAP32[$9_1 + 68 >> 2]; 7452 $3_1 = HEAP32[$6_1 + 264 >> 2]; 7453 if ($3_1) { 7454 continue 7455 } 7456 break; 7457 }; 7458 } 7459 $11_1 = $9_1 + 16 | 0; 7460 wasm2js_memory_copy($11_1, $9_1 + 104 | 0, 40); 7461 HEAP32[$9_1 + 68 >> 2] = $1_1; 7462 HEAP32[$9_1 + 64 >> 2] = $2_1; 7463 HEAP32[$9_1 + 60 >> 2] = $4_1; 7464 HEAP32[$9_1 + 56 >> 2] = $6_1; 7465 $4_1 = HEAP32[$14_1 >> 2]; 7466 $6_1 = HEAP32[$4_1 >> 2]; 7467 if (!$6_1) { 7468 break block19 7469 } 7470 $14_1 = $9_1 + 8 | 0; 7471 $12_1 = HEAP32[$4_1 + 4 >> 2]; 7472 $3_1 = $40(); 7473 HEAP32[$3_1 + 408 >> 2] = $6_1; 7474 HEAP16[$3_1 + 402 >> 1] = 0; 7475 HEAP32[$3_1 + 264 >> 2] = 0; 7476 block20 : { 7477 $12_1 = $12_1 + 1 | 0; 7478 if ($12_1) { 7479 HEAP16[$6_1 + 400 >> 1] = 0; 7480 HEAP32[$6_1 + 264 >> 2] = $3_1; 7481 HEAP32[$14_1 + 4 >> 2] = $12_1; 7482 HEAP32[$14_1 >> 2] = $3_1; 7483 break block20; 7484 } 7485 $151(1053272); 7486 wasm2js_trap(); 7487 } 7488 $3_1 = HEAP32[$9_1 + 8 >> 2]; 7489 $6_1 = HEAP32[$9_1 + 12 >> 2]; 7490 HEAP32[$4_1 + 4 >> 2] = $6_1; 7491 HEAP32[$4_1 >> 2] = $3_1; 7492 HEAP32[$9_1 + 96 >> 2] = $6_1; 7493 HEAP32[$9_1 + 92 >> 2] = $3_1; 7494 $3_1 = $9_1 + 32 | 0; 7495 block22 : { 7496 block21 : { 7497 $4_1 = $9_1 + 92 | 0; 7498 if ((HEAP32[$4_1 + 4 >> 2] - 1 | 0) == ($1_1 | 0)) { 7499 $1_1 = HEAP32[$4_1 >> 2]; 7500 $4_1 = HEAPU16[$1_1 + 402 >> 1]; 7501 if ($4_1 >>> 0 >= 11) { 7502 break block21 7503 } 7504 $6_1 = $4_1 + 1 | 0; 7505 HEAP16[$1_1 + 402 >> 1] = $6_1; 7506 $14_1 = Math_imul($4_1, 12) + $1_1 | 0; 7507 HEAP32[$14_1 + 276 >> 2] = HEAP32[$11_1 + 8 >> 2]; 7508 $5_1 = HEAP32[$11_1 + 4 >> 2]; 7509 $7_1 = $14_1; 7510 HEAP32[$7_1 + 268 >> 2] = HEAP32[$11_1 >> 2]; 7511 HEAP32[$7_1 + 272 >> 2] = $5_1; 7512 $7_1 = HEAP32[$3_1 + 4 >> 2]; 7513 $4_1 = Math_imul($4_1, 24) + $1_1 | 0; 7514 HEAP32[$4_1 >> 2] = HEAP32[$3_1 >> 2]; 7515 HEAP32[$4_1 + 4 >> 2] = $7_1; 7516 $5_1 = HEAP32[$3_1 + 12 >> 2]; 7517 HEAP32[$4_1 + 8 >> 2] = HEAP32[$3_1 + 8 >> 2]; 7518 HEAP32[$4_1 + 12 >> 2] = $5_1; 7519 $7_1 = HEAP32[$3_1 + 20 >> 2]; 7520 HEAP32[$4_1 + 16 >> 2] = HEAP32[$3_1 + 16 >> 2]; 7521 HEAP32[$4_1 + 20 >> 2] = $7_1; 7522 HEAP32[(($6_1 << 2) + $1_1 | 0) + 408 >> 2] = $2_1; 7523 HEAP16[$2_1 + 400 >> 1] = $6_1; 7524 HEAP32[$2_1 + 264 >> 2] = $1_1; 7525 break block22; 7526 } 7527 $129(1053692, 48, 1053740); 7528 wasm2js_trap(); 7529 } 7530 $129(1053644, 32, 1053756); 7531 wasm2js_trap(); 7532 } 7533 } 7534 HEAP32[$20_1 + 8 >> 2] = $25_1; 7535 HEAP32[$20_1 + 4 >> 2] = $27_1; 7536 HEAP32[$20_1 >> 2] = $26_1; 7537 break block23; 7538 } 7539 $151(1053484); 7540 wasm2js_trap(); 7541 } 7542 HEAP32[$20_1 + 8 >> 2] = HEAP32[$9_1 + 80 >> 2]; 7543 $5_1 = HEAP32[$9_1 + 76 >> 2]; 7544 $7_1 = $20_1; 7545 HEAP32[$7_1 >> 2] = HEAP32[$9_1 + 72 >> 2]; 7546 HEAP32[$7_1 + 4 >> 2] = $5_1; 7547 } 7548 global$0 = $9_1 + 144 | 0; 7549 $2_1 = HEAP32[$8_1 + 12 >> 2]; 7550 $6_1 = HEAP32[$19_1 + 12 >> 2]; 7551 $1_1 = HEAP32[$19_1 + 4 >> 2]; 7552 $14_1 = HEAP32[$19_1 + 8 >> 2]; 7553 break block24; 7554 } 7555 $2_1 = HEAP32[$1_1 >> 2]; 7556 $1_1 = $39(); 7557 HEAP16[$1_1 + 402 >> 1] = 0; 7558 HEAP32[$1_1 + 264 >> 2] = 0; 7559 HEAP32[$2_1 + 4 >> 2] = 0; 7560 HEAP32[$2_1 >> 2] = $1_1; 7561 $6_1 = HEAPU16[$1_1 + 402 >> 1]; 7562 if ($6_1 >>> 0 >= 11) { 7563 break block25 7564 } 7565 HEAP16[$1_1 + 402 >> 1] = $6_1 + 1; 7566 $4_1 = Math_imul($6_1, 12) + $1_1 | 0; 7567 HEAP32[$4_1 + 276 >> 2] = HEAP32[$8_1 + 8 >> 2]; 7568 $7_1 = HEAP32[$8_1 + 4 >> 2]; 7569 HEAP32[$4_1 + 268 >> 2] = HEAP32[$8_1 >> 2]; 7570 HEAP32[$4_1 + 272 >> 2] = $7_1; 7571 $5_1 = HEAP32[$3_1 + 4 >> 2]; 7572 $8_1 = Math_imul($6_1, 24) + $1_1 | 0; 7573 HEAP32[$8_1 >> 2] = HEAP32[$3_1 >> 2]; 7574 HEAP32[$8_1 + 4 >> 2] = $5_1; 7575 $7_1 = HEAP32[$3_1 + 12 >> 2]; 7576 HEAP32[$8_1 + 8 >> 2] = HEAP32[$3_1 + 8 >> 2]; 7577 HEAP32[$8_1 + 12 >> 2] = $7_1; 7578 $5_1 = HEAP32[$3_1 + 20 >> 2]; 7579 HEAP32[$8_1 + 16 >> 2] = HEAP32[$3_1 + 16 >> 2]; 7580 HEAP32[$8_1 + 20 >> 2] = $5_1; 7581 } 7582 HEAP32[$22_1 + 12 >> 2] = $2_1; 7583 HEAP32[$22_1 + 8 >> 2] = $6_1; 7584 HEAP32[$22_1 + 4 >> 2] = $14_1; 7585 HEAP32[$22_1 >> 2] = $1_1; 7586 HEAP32[$2_1 + 8 >> 2] = HEAP32[$2_1 + 8 >> 2] + 1; 7587 global$0 = $19_1 + 16 | 0; 7588 break block26; 7589 } 7590 $129(1053644, 32, 1053676); 7591 wasm2js_trap(); 7592 } 7593 HEAP8[$0_1 | 0] = 255; 7594 } 7595 global$0 = $17_1 + 48 | 0; 7596 } 7597 7598 function $59($0_1, $1_1) { 7599 var $2_1 = 0, $3_1 = 0, $4_1 = 0, $5_1 = 0, $6_1 = 0, $7_1 = 0, $8_1 = 0, $9_1 = 0, $10_1 = 0, $11_1 = 0, $12_1 = 0, $13_1 = 0, $14_1 = 0, $15_1 = 0, $16_1 = 0, $17_1 = 0, $18_1 = 0, $19_1 = 0, $20_1 = 0, $21_1 = 0, $22_1 = 0, $23_1 = 0, $24_1 = 0; 7600 $13_1 = global$0 - 16 | 0; 7601 global$0 = $13_1; 7602 block : { 7603 block1 : { 7604 if ($1_1 & 1) { 7605 $1_1 = $1_1 >>> 1 | 0; 7606 $35($13_1 + 4 | 0, $1_1, 1, 1); 7607 $4_1 = HEAP32[$13_1 + 8 >> 2]; 7608 if (HEAP32[$13_1 + 4 >> 2] == 1) { 7609 break block 7610 } 7611 $5_1 = HEAP32[$13_1 + 12 >> 2]; 7612 if ($1_1) { 7613 wasm2js_memory_copy($5_1, $0_1, $1_1) 7614 } 7615 HEAP32[$13_1 + 12 >> 2] = $1_1; 7616 HEAP32[$13_1 + 8 >> 2] = $5_1; 7617 HEAP32[$13_1 + 4 >> 2] = $4_1; 7618 break block1; 7619 } 7620 $124($13_1 + 4 | 0, $0_1, $1_1); 7621 } 7622 $5_1 = 0; 7623 $4_1 = 0; 7624 $6_1 = global$0 - 80 | 0; 7625 global$0 = $6_1; 7626 $19_1 = $13_1 + 4 | 0; 7627 $11_1 = HEAP32[$19_1 + 4 >> 2]; 7628 $7_1 = HEAP32[$19_1 + 8 >> 2]; 7629 $146($6_1 + 16 | 0, $11_1, $7_1, 1057288, 9); 7630 block47 : { 7631 block5 : { 7632 block19 : { 7633 block23 : { 7634 block17 : { 7635 block26 : { 7636 block46 : { 7637 block39 : { 7638 block29 : { 7639 block30 : { 7640 block32 : { 7641 block13 : { 7642 block8 : { 7643 block3 : { 7644 block2 : { 7645 if (!HEAP32[$6_1 + 16 >> 2]) { 7646 if (HEAPU8[$6_1 + 30 | 0]) { 7647 break block2 7648 } 7649 $8_1 = HEAPU8[$6_1 + 29 | 0]; 7650 $1_1 = HEAP32[$6_1 + 24 >> 2]; 7651 if (!$1_1) { 7652 break block3 7653 } 7654 $4_1 = HEAP32[$6_1 + 68 >> 2]; 7655 $5_1 = HEAP32[$6_1 + 64 >> 2]; 7656 while (1) { 7657 block4 : { 7658 if ($1_1 >>> 0 >= $4_1 >>> 0) { 7659 if (($1_1 | 0) == ($4_1 | 0)) { 7660 break block4 7661 } 7662 break block5; 7663 } 7664 if (HEAP8[$1_1 + $5_1 | 0] < -64) { 7665 break block5 7666 } 7667 } 7668 $3_1 = $1_1 + $5_1 | 0; 7669 $0_1 = HEAP8[$3_1 - 1 | 0]; 7670 if (($0_1 | 0) < 0) { 7671 $9_1 = $0_1 & 63; 7672 $0_1 = HEAPU8[$3_1 - 2 | 0]; 7673 $2_1 = $0_1 << 24 >> 24; 7674 block6 : { 7675 if (($2_1 | 0) >= -64) { 7676 $0_1 = $0_1 & 31; 7677 break block6; 7678 } 7679 $14_1 = $2_1 & 63; 7680 $0_1 = HEAPU8[$3_1 - 3 | 0]; 7681 $2_1 = $0_1 << 24 >> 24; 7682 block7 : { 7683 if (($2_1 | 0) >= -64) { 7684 $0_1 = $0_1 & 15; 7685 break block7; 7686 } 7687 $0_1 = $2_1 & 63 | (HEAPU8[$3_1 - 4 | 0] & 7) << 6; 7688 } 7689 $0_1 = $14_1 | $0_1 << 6; 7690 } 7691 $0_1 = $9_1 | $0_1 << 6; 7692 } 7693 if ($8_1 & 1) { 7694 break block8 7695 } 7696 $8_1 = 1; 7697 $9_1 = -1; 7698 block9 : { 7699 if ($0_1 >>> 0 < 128) { 7700 break block9 7701 } 7702 $9_1 = -2; 7703 if ($0_1 >>> 0 < 2048) { 7704 break block9 7705 } 7706 $9_1 = $0_1 >>> 0 < 65536 ? -3 : -4; 7707 } 7708 $1_1 = $9_1 + $1_1 | 0; 7709 if ($1_1) { 7710 continue 7711 } 7712 break; 7713 }; 7714 $1_1 = 0; 7715 break block8; 7716 } 7717 $5_1 = HEAP32[$6_1 + 76 >> 2]; 7718 $12_1 = HEAP32[$6_1 + 72 >> 2]; 7719 $16_1 = HEAP32[$6_1 + 68 >> 2]; 7720 $23_1 = HEAP32[$6_1 + 64 >> 2]; 7721 if (HEAP32[$6_1 + 52 >> 2] != -1) { 7722 $3_1 = HEAP32[$6_1 + 48 >> 2]; 7723 $1_1 = $3_1 - $5_1 | 0; 7724 if ($16_1 >>> 0 <= $1_1 >>> 0) { 7725 break block2 7726 } 7727 $8_1 = HEAP32[$6_1 + 36 >> 2]; 7728 $20_1 = $5_1 >>> 0 < $8_1 >>> 0 ? $8_1 : $5_1; 7729 $2_1 = HEAP32[$6_1 + 56 >> 2]; 7730 $21_1 = HEAP32[$6_1 + 40 >> 2]; 7731 $14_1 = HEAP32[$6_1 + 24 >> 2]; 7732 $18_1 = HEAP32[$6_1 + 28 >> 2]; 7733 while (1) { 7734 $9_1 = $14_1; 7735 $4_1 = $1_1 + $23_1 | 0; 7736 $15_1 = HEAPU8[$4_1 | 0]; 7737 $10_1 = $15_1 & 31; 7738 if (($15_1 & 63) >>> 0 >= 32) { 7739 $0_1 = $18_1 >>> $10_1 | 0 7740 } else { 7741 $0_1 = ((1 << $10_1) - 1 & $18_1) << 32 - $10_1 | $9_1 >>> $10_1 7742 } 7743 block10 : { 7744 if (!($0_1 & 1)) { 7745 $3_1 = $1_1; 7746 $0_1 = $5_1; 7747 break block10; 7748 } 7749 block12 : { 7750 block11 : { 7751 $0_1 = $2_1 >>> 0 < $8_1 >>> 0 ? $2_1 : $8_1; 7752 if ($0_1) { 7753 $22_1 = $0_1 - 1 | 0; 7754 $0_1 = $22_1; 7755 while (1) { 7756 if ($5_1 >>> 0 <= $22_1 >>> 0) { 7757 break block11 7758 } 7759 if (HEAPU8[$0_1 + $12_1 | 0] != HEAPU8[$0_1 + $4_1 | 0]) { 7760 break block12 7761 } 7762 $0_1 = $0_1 - 1 | 0; 7763 if (($0_1 | 0) != -1) { 7764 continue 7765 } 7766 break; 7767 }; 7768 } 7769 if ($2_1 >>> 0 <= $8_1 >>> 0) { 7770 break block8 7771 } 7772 $2_1 = $2_1 >>> 0 > $8_1 >>> 0 ? $2_1 : $8_1; 7773 $0_1 = $8_1; 7774 while (1) { 7775 if (($0_1 | 0) == ($20_1 | 0)) { 7776 break block13 7777 } 7778 if (HEAPU8[$0_1 + $12_1 | 0] == HEAPU8[$0_1 + $4_1 | 0]) { 7779 $0_1 = $0_1 + 1 | 0; 7780 if (($0_1 | 0) == ($2_1 | 0)) { 7781 break block8 7782 } 7783 continue; 7784 } 7785 break; 7786 }; 7787 $3_1 = $3_1 - $21_1 | 0; 7788 $0_1 = $21_1; 7789 break block10; 7790 } 7791 $137($0_1, $5_1, 1053408); 7792 wasm2js_trap(); 7793 } 7794 $3_1 = $0_1 + ($3_1 - $8_1 | 0) | 0; 7795 $0_1 = $5_1; 7796 } 7797 $2_1 = $0_1; 7798 $1_1 = $3_1 - $5_1 | 0; 7799 if ($16_1 >>> 0 > $1_1 >>> 0) { 7800 continue 7801 } 7802 break; 7803 }; 7804 break block2; 7805 } 7806 $2_1 = HEAP32[$6_1 + 48 >> 2]; 7807 $1_1 = $2_1 - $5_1 | 0; 7808 if ($16_1 >>> 0 <= $1_1 >>> 0) { 7809 break block2 7810 } 7811 $4_1 = HEAP32[$6_1 + 36 >> 2]; 7812 $3_1 = $5_1 >>> 0 < $4_1 >>> 0 ? $4_1 : $5_1; 7813 $8_1 = $4_1 - 1 | 0; 7814 $20_1 = $8_1 + $12_1 | 0; 7815 $21_1 = $8_1 + $23_1 | 0; 7816 $22_1 = HEAP32[$6_1 + 40 >> 2]; 7817 $14_1 = HEAP32[$6_1 + 24 >> 2]; 7818 $18_1 = HEAP32[$6_1 + 28 >> 2]; 7819 while (1) { 7820 $9_1 = $18_1; 7821 $17_1 = $14_1; 7822 $24_1 = $1_1 + $23_1 | 0; 7823 $15_1 = HEAPU8[$24_1 | 0]; 7824 $10_1 = $15_1 & 31; 7825 if (($15_1 & 63) >>> 0 >= 32) { 7826 $0_1 = $9_1 >>> $10_1 | 0 7827 } else { 7828 $0_1 = ((1 << $10_1) - 1 & $9_1) << 32 - $10_1 | $17_1 >>> $10_1 7829 } 7830 block14 : { 7831 if (!($0_1 & 1)) { 7832 break block14 7833 } 7834 block16 : { 7835 block15 : { 7836 if ($4_1) { 7837 $9_1 = $1_1 + $21_1 | 0; 7838 $0_1 = 0; 7839 while (1) { 7840 if ($5_1 >>> 0 <= $8_1 >>> 0) { 7841 break block15 7842 } 7843 if (HEAPU8[$0_1 + $20_1 | 0] != HEAPU8[$0_1 + $9_1 | 0]) { 7844 break block16 7845 } 7846 $0_1 = $0_1 - 1 | 0; 7847 if ($0_1 + $4_1 | 0) { 7848 continue 7849 } 7850 break; 7851 }; 7852 } 7853 if ($5_1 >>> 0 <= $4_1 >>> 0) { 7854 break block8 7855 } 7856 $0_1 = $4_1; 7857 while (1) { 7858 if (HEAPU8[$0_1 + $12_1 | 0] == HEAPU8[$0_1 + $24_1 | 0]) { 7859 $0_1 = $0_1 + 1 | 0; 7860 if (($3_1 | 0) != ($0_1 | 0)) { 7861 continue 7862 } 7863 break block8; 7864 } 7865 break; 7866 }; 7867 $1_1 = $2_1 - $22_1 | 0; 7868 break block14; 7869 } 7870 $137(($0_1 + $4_1 | 0) - 1 | 0, $5_1, 1053408); 7871 wasm2js_trap(); 7872 } 7873 $1_1 = ($0_1 + $2_1 | 0) - 1 | 0; 7874 } 7875 $2_1 = $1_1; 7876 $1_1 = $2_1 - $5_1 | 0; 7877 if ($16_1 >>> 0 > $1_1 >>> 0) { 7878 continue 7879 } 7880 break; 7881 }; 7882 } 7883 $1_1 = 0; 7884 break block17; 7885 } 7886 $1_1 = 0; 7887 if (!($8_1 & 1)) { 7888 break block17 7889 } 7890 } 7891 $8_1 = $1_1; 7892 $12_1 = $1_1 - $7_1 | 0; 7893 $0_1 = 9; 7894 $1_1 = $11_1 + 9 | 0; 7895 $3_1 = $7_1 + $11_1 | 0; 7896 $2_1 = $8_1 + 9 | 0; 7897 while (1) { 7898 $5_1 = $0_1 + $12_1 | 0; 7899 $4_1 = $0_1 + $8_1 | 0; 7900 block18 : { 7901 if (!$4_1) { 7902 break block18 7903 } 7904 if ($4_1 >>> 0 >= $7_1 >>> 0) { 7905 if (!$5_1) { 7906 break block18 7907 } 7908 break block19; 7909 } 7910 if (HEAP8[$1_1 + $8_1 | 0] <= -65) { 7911 break block19 7912 } 7913 } 7914 block24 : { 7915 block21 : { 7916 block20 : { 7917 if (!$5_1) { 7918 $5_1 = $3_1; 7919 $3_1 = $7_1; 7920 break block20; 7921 } 7922 $5_1 = $1_1 + $8_1 | 0; 7923 if ((HEAPU8[$5_1 | 0] - 48 & 255) >>> 0 < 10) { 7924 break block21 7925 } 7926 $3_1 = $4_1; 7927 } 7928 block22 : { 7929 if (!$4_1) { 7930 break block22 7931 } 7932 if ($3_1 >>> 0 >= $7_1 >>> 0) { 7933 if (($3_1 | 0) == ($7_1 | 0)) { 7934 break block22 7935 } 7936 break block23; 7937 } 7938 if (HEAP8[$5_1 | 0] <= -65) { 7939 break block23 7940 } 7941 } 7942 $1_1 = 0; 7943 if ($116($5_1, $7_1 - $3_1 | 0, 1057332, 8)) { 7944 break block24 7945 } 7946 break block17; 7947 } 7948 $1_1 = $1_1 + 1 | 0; 7949 $0_1 = $0_1 + 1 | 0; 7950 continue; 7951 } 7952 break; 7953 }; 7954 $12_1 = $3_1 + 8 | 0; 7955 $0_1 = $12_1; 7956 while (1) { 7957 block25 : { 7958 if (!$0_1) { 7959 break block25 7960 } 7961 if ($0_1 >>> 0 >= $7_1 >>> 0) { 7962 if (($0_1 | 0) == ($7_1 | 0)) { 7963 break block25 7964 } 7965 break block26; 7966 } 7967 if (HEAP8[$0_1 + $11_1 | 0] <= -65) { 7968 break block26 7969 } 7970 } 7971 block31 : { 7972 block28 : { 7973 block27 : { 7974 if (($0_1 | 0) == ($7_1 | 0)) { 7975 $0_1 = $7_1; 7976 break block27; 7977 } 7978 if ((HEAPU8[$0_1 + $11_1 | 0] - 48 & 255) >>> 0 < 10) { 7979 break block28 7980 } 7981 if ($0_1 >>> 0 < $7_1 >>> 0) { 7982 break block17 7983 } 7984 } 7985 if ($3_1 >>> 0 < $2_1 >>> 0 | $3_1 >>> 0 > $7_1 >>> 0) { 7986 break block29 7987 } 7988 if (($2_1 | 0) == ($7_1 | 0)) { 7989 break block30 7990 } 7991 if ($2_1) { 7992 break block31 7993 } 7994 break block32; 7995 } 7996 $0_1 = $0_1 + 1 | 0; 7997 continue; 7998 } 7999 break; 8000 }; 8001 if (HEAP8[$2_1 + $11_1 | 0] > -65) { 8002 break block32 8003 } 8004 break block29; 8005 } 8006 $137($20_1, $5_1, 1053392); 8007 wasm2js_trap(); 8008 } 8009 if (($3_1 | 0) == ($7_1 | 0)) { 8010 break block30 8011 } 8012 if (HEAP8[$5_1 | 0] <= -65) { 8013 break block29 8014 } 8015 } 8016 $16_1 = $2_1 + $11_1 | 0; 8017 block35 : { 8018 block34 : { 8019 block33 : { 8020 $3_1 = $3_1 - $2_1 | 0; 8021 switch ($3_1 | 0) { 8022 case 0: 8023 break block17; 8024 case 1: 8025 break block33; 8026 default: 8027 break block34; 8028 }; 8029 } 8030 $2_1 = HEAPU8[$16_1 | 0]; 8031 switch ($2_1 - 43 | 0) { 8032 case 0: 8033 case 2: 8034 break block17; 8035 default: 8036 break block35; 8037 }; 8038 } 8039 $2_1 = HEAPU8[$16_1 | 0]; 8040 } 8041 $5_1 = ($2_1 | 0) == 43; 8042 $4_1 = $5_1 + $16_1 | 0; 8043 block38 : { 8044 block37 : { 8045 block36 : { 8046 $2_1 = $3_1 - $5_1 | 0; 8047 if ($2_1 >>> 0 >= 9) { 8048 $5_1 = 0; 8049 break block36; 8050 } 8051 if ($2_1) { 8052 break block37 8053 } 8054 $5_1 = 0; 8055 break block38; 8056 } 8057 while (1) { 8058 $14_1 = __wasm_i64_mul($5_1, 0, 10, 0); 8059 $9_1 = $14_1; 8060 $17_1 = i64toi32_i32$HIGH_BITS; 8061 $18_1 = $9_1; 8062 $15_1 = 32; 8063 $10_1 = 0; 8064 if (($15_1 & 63) >>> 0 >= 32) { 8065 $9_1 = $17_1 >>> $10_1 | 0 8066 } else { 8067 $9_1 = ((1 << $10_1) - 1 & $17_1) << 32 - $10_1 | $18_1 >>> $10_1 8068 } 8069 if ($9_1) { 8070 break block17 8071 } 8072 $3_1 = HEAPU8[$4_1 | 0] - 48 | 0; 8073 if ($3_1 >>> 0 > 9) { 8074 break block17 8075 } 8076 $5_1 = $3_1 + $14_1 | 0; 8077 if ($3_1 >>> 0 > $5_1 >>> 0) { 8078 break block17 8079 } 8080 $4_1 = $4_1 + 1 | 0; 8081 $2_1 = $2_1 - 1 | 0; 8082 if ($2_1) { 8083 continue 8084 } 8085 break; 8086 }; 8087 break block38; 8088 } 8089 $5_1 = 0; 8090 while (1) { 8091 $3_1 = HEAPU8[$4_1 | 0] - 48 | 0; 8092 if ($3_1 >>> 0 > 9) { 8093 break block17 8094 } 8095 $4_1 = $4_1 + 1 | 0; 8096 $5_1 = Math_imul($5_1, 10) + $3_1 | 0; 8097 $2_1 = $2_1 - 1 | 0; 8098 if ($2_1) { 8099 continue 8100 } 8101 break; 8102 }; 8103 } 8104 if ($0_1 >>> 0 < $12_1 >>> 0 | $0_1 >>> 0 > $7_1 >>> 0) { 8105 break block39 8106 } 8107 if (!(!$12_1 | ($7_1 | 0) == ($12_1 | 0)) & HEAP8[$11_1 + $12_1 | 0] <= -65) { 8108 break block39 8109 } 8110 $3_1 = $11_1 + $12_1 | 0; 8111 block42 : { 8112 block41 : { 8113 block40 : { 8114 $2_1 = $0_1 - $12_1 | 0; 8115 switch ($2_1 | 0) { 8116 case 0: 8117 break block17; 8118 case 1: 8119 break block40; 8120 default: 8121 break block41; 8122 }; 8123 } 8124 $0_1 = HEAPU8[$3_1 | 0]; 8125 switch ($0_1 - 43 | 0) { 8126 case 0: 8127 case 2: 8128 break block17; 8129 default: 8130 break block42; 8131 }; 8132 } 8133 $0_1 = HEAPU8[$3_1 | 0]; 8134 } 8135 $4_1 = ($0_1 & 255) == 43; 8136 $0_1 = $4_1 + $3_1 | 0; 8137 block45 : { 8138 block44 : { 8139 block43 : { 8140 $2_1 = $2_1 - $4_1 | 0; 8141 if ($2_1 >>> 0 >= 9) { 8142 $4_1 = 0; 8143 break block43; 8144 } 8145 if ($2_1) { 8146 break block44 8147 } 8148 $4_1 = 0; 8149 break block45; 8150 } 8151 while (1) { 8152 $14_1 = __wasm_i64_mul($4_1, 0, 10, 0); 8153 $9_1 = i64toi32_i32$HIGH_BITS; 8154 $17_1 = $14_1; 8155 $15_1 = 32; 8156 $10_1 = 0; 8157 if (($15_1 & 63) >>> 0 >= 32) { 8158 $9_1 = $9_1 >>> $10_1 | 0 8159 } else { 8160 $9_1 = ((1 << $10_1) - 1 & $9_1) << 32 - $10_1 | $17_1 >>> $10_1 8161 } 8162 if ($9_1) { 8163 break block17 8164 } 8165 $3_1 = HEAPU8[$0_1 | 0] - 48 | 0; 8166 if ($3_1 >>> 0 > 9) { 8167 break block17 8168 } 8169 $4_1 = $3_1 + $14_1 | 0; 8170 if ($3_1 >>> 0 > $4_1 >>> 0) { 8171 break block17 8172 } 8173 $0_1 = $0_1 + 1 | 0; 8174 $2_1 = $2_1 - 1 | 0; 8175 if ($2_1) { 8176 continue 8177 } 8178 break; 8179 }; 8180 break block45; 8181 } 8182 $4_1 = 0; 8183 while (1) { 8184 $3_1 = HEAPU8[$0_1 | 0] - 48 | 0; 8185 if ($3_1 >>> 0 > 9) { 8186 break block17 8187 } 8188 $0_1 = $0_1 + 1 | 0; 8189 $4_1 = Math_imul($4_1, 10) + $3_1 | 0; 8190 $2_1 = $2_1 - 1 | 0; 8191 if ($2_1) { 8192 continue 8193 } 8194 break; 8195 }; 8196 } 8197 $1_1 = 1; 8198 if ($7_1 >>> 0 < $8_1 >>> 0) { 8199 break block17 8200 } 8201 if (!$8_1 | $7_1 >>> 0 <= $8_1 >>> 0) { 8202 break block46 8203 } 8204 if (HEAP8[$8_1 + $11_1 | 0] > -65) { 8205 break block46 8206 } 8207 $129(1053516, 48, 1057388); 8208 wasm2js_trap(); 8209 } 8210 $148($11_1, $7_1, $2_1, $3_1, 1057356); 8211 wasm2js_trap(); 8212 } 8213 $148($11_1, $7_1, $12_1, $0_1, 1057372); 8214 wasm2js_trap(); 8215 } 8216 HEAP32[$19_1 + 8 >> 2] = $8_1; 8217 break block17; 8218 } 8219 $148($11_1, $7_1, $0_1, $7_1, 1057340); 8220 wasm2js_trap(); 8221 } 8222 HEAP32[$6_1 + 24 >> 2] = HEAP32[$19_1 + 8 >> 2]; 8223 $9_1 = $19_1; 8224 $0_1 = HEAP32[$9_1 >> 2]; 8225 $17_1 = HEAP32[$9_1 + 4 >> 2]; 8226 HEAP32[$6_1 + 16 >> 2] = $0_1; 8227 HEAP32[$6_1 + 20 >> 2] = $17_1; 8228 $64($6_1 + 8 | 0, $6_1 + 16 | 0); 8229 $7_1 = HEAP32[$6_1 + 12 >> 2]; 8230 $8_1 = HEAP32[$6_1 + 8 >> 2]; 8231 $0_1 = $33(20, 4); 8232 if ($0_1) { 8233 HEAP32[$0_1 + 4 >> 2] = $8_1; 8234 HEAP32[$0_1 >> 2] = 0; 8235 HEAP32[$0_1 + 16 >> 2] = $1_1 ? $4_1 : 0; 8236 HEAP32[$0_1 + 12 >> 2] = $1_1 ? $5_1 : 0; 8237 HEAP32[$0_1 + 8 >> 2] = $7_1; 8238 global$0 = $6_1 + 80 | 0; 8239 break block47; 8240 } 8241 $123(4, 20); 8242 wasm2js_trap(); 8243 } 8244 $148($11_1, $7_1, $3_1, $7_1, 1057316); 8245 wasm2js_trap(); 8246 } 8247 $148($11_1, $7_1, $4_1, $7_1, 1057300); 8248 wasm2js_trap(); 8249 } 8250 $148($5_1, $4_1, 0, $1_1, 1058136); 8251 wasm2js_trap(); 8252 } 8253 global$0 = $13_1 + 16 | 0; 8254 return $0_1; 8255 } 8256 $120($4_1, HEAP32[$13_1 + 12 >> 2]); 8257 wasm2js_trap(); 8258 } 8259 8260 function $60($0_1, $1_1, $2_1) { 8261 $61($0_1, $1_1, $1_1 + $2_1 | 0); 8262 } 8263 8264 function $61($0_1, $1_1, $2_1) { 8265 var $3_1 = 0, $4_1 = 0; 8266 $3_1 = $2_1 - $1_1 | 0; 8267 $4_1 = HEAP32[$0_1 + 8 >> 2]; 8268 block1 : { 8269 block : { 8270 if ($3_1 >>> 0 > HEAP32[$0_1 >> 2] - $4_1 >>> 0) { 8271 $38($0_1, $4_1, $3_1, 1, 1); 8272 $4_1 = HEAP32[$0_1 + 8 >> 2]; 8273 break block; 8274 } 8275 if (($1_1 | 0) == ($2_1 | 0)) { 8276 break block1 8277 } 8278 } 8279 if (!$3_1) { 8280 break block1 8281 } 8282 wasm2js_memory_copy($4_1 + HEAP32[$0_1 + 4 >> 2] | 0, $1_1, $3_1); 8283 } 8284 HEAP32[$0_1 + 8 >> 2] = $3_1 + $4_1; 8285 } 8286 8287 function $62($0_1, $1_1, $2_1) { 8288 var $3_1 = 0, $4_1 = 0, $5_1 = 0.0; 8289 $3_1 = global$0 - 16 | 0; 8290 global$0 = $3_1; 8291 block3 : { 8292 block1 : { 8293 switch (HEAP32[$0_1 >> 2] - 1 | 0) { 8294 default: 8295 $5_1 = HEAPF64[$0_1 + 8 >> 3]; 8296 HEAP8[$3_1 | 0] = 3; 8297 HEAPF64[$3_1 + 8 >> 3] = $5_1; 8298 break block3; 8299 case 0: 8300 $4_1 = HEAP32[$0_1 + 8 >> 2]; 8301 $0_1 = HEAP32[$0_1 + 12 >> 2]; 8302 HEAP8[$3_1 | 0] = 1; 8303 HEAP32[$3_1 + 8 >> 2] = $4_1; 8304 HEAP32[$3_1 + 12 >> 2] = $0_1; 8305 break block3; 8306 case 1: 8307 break block1; 8308 }; 8309 } 8310 $4_1 = HEAP32[$0_1 + 8 >> 2]; 8311 $0_1 = HEAP32[$0_1 + 12 >> 2]; 8312 HEAP8[$3_1 | 0] = 2; 8313 HEAP32[$3_1 + 8 >> 2] = $4_1; 8314 HEAP32[$3_1 + 12 >> 2] = $0_1; 8315 } 8316 $0_1 = $43($3_1, $1_1, $2_1); 8317 global$0 = $3_1 + 16 | 0; 8318 return $0_1; 8319 } 8320 8321 function $63($0_1) { 8322 var $1_1 = 0, $2_1 = 0, $3_1 = 0, $4_1 = 0, $5_1 = 0, $6_1 = 0, $7_1 = 0, $8_1 = 0, $9_1 = 0, $10_1 = 0; 8323 block1 : { 8324 $1_1 = HEAP32[$0_1 + 8 >> 2]; 8325 $4_1 = HEAP32[$0_1 + 4 >> 2]; 8326 block : { 8327 if (($1_1 | 0) == ($4_1 | 0)) { 8328 break block 8329 } 8330 if ($1_1 >>> 0 >= $4_1 >>> 0) { 8331 break block1 8332 } 8333 $8_1 = HEAP32[$0_1 >> 2]; 8334 $2_1 = HEAPU8[$1_1 + $8_1 | 0]; 8335 if (($2_1 | 0) == 34 | ($2_1 | 0) == 92 | $2_1 >>> 0 < 32) { 8336 break block 8337 } 8338 $2_1 = $1_1 + 1 | 0; 8339 HEAP32[$0_1 + 8 >> 2] = $2_1; 8340 block2 : { 8341 $9_1 = $4_1 - $2_1 | 0; 8342 $1_1 = $9_1 & 2147483640; 8343 if (!$1_1) { 8344 break block2 8345 } 8346 $4_1 = 0 - $1_1 | 0; 8347 $1_1 = $2_1; 8348 while (1) { 8349 $3_1 = $1_1 + $8_1 | 0; 8350 $5_1 = HEAPU8[$3_1 | 0] | HEAPU8[$3_1 + 1 | 0] << 8 | (HEAPU8[$3_1 + 2 | 0] << 16 | HEAPU8[$3_1 + 3 | 0] << 24); 8351 $7_1 = HEAPU8[$3_1 + 4 | 0] | HEAPU8[$3_1 + 5 | 0] << 8 | (HEAPU8[$3_1 + 6 | 0] << 16 | HEAPU8[$3_1 + 7 | 0] << 24); 8352 $6_1 = $7_1; 8353 $3_1 = $6_1 ^ 572662306; 8354 $7_1 = $5_1 ^ 572662306; 8355 $10_1 = $7_1 - 16843009 | 0; 8356 $7_1 = $6_1 - (($5_1 >>> 0 < 538976288) + 538976288 | 0) | $3_1 - (($7_1 >>> 0 < 16843009) + 16843009 | 0); 8357 $3_1 = $5_1 ^ 1549556828; 8358 $5_1 = ($3_1 - 16843009 | ($10_1 | $5_1 - 538976288)) & ($5_1 ^ -1) & -2139062144; 8359 $6_1 = ($7_1 | ($6_1 ^ 1549556828) - (($3_1 >>> 0 < 16843009) + 16843009 | 0)) & ($6_1 ^ -1) & -2139062144; 8360 if (!($5_1 | $6_1)) { 8361 $1_1 = $1_1 + 8 | 0; 8362 $4_1 = $4_1 + 8 | 0; 8363 if ($4_1) { 8364 continue 8365 } 8366 break block2; 8367 } 8368 break; 8369 }; 8370 $7_1 = $0_1; 8371 __inlined_func$__wasm_ctz_i64 : { 8372 if ($5_1 | $6_1) { 8373 $0_1 = $5_1 - 1 | 0; 8374 $3_1 = Math_clz32($5_1 ^ $0_1) + 32 | 0; 8375 $2_1 = $6_1 - 1 | 0; 8376 $0_1 = Math_clz32((($0_1 | 0) != -1 ? $2_1 + 1 | 0 : $2_1) ^ $6_1); 8377 $0_1 = ($0_1 | 0) == 32 ? $3_1 : $0_1; 8378 i64toi32_i32$HIGH_BITS = 0 - ($0_1 >>> 0 > 63) | 0; 8379 $0_1 = 63 - $0_1 | 0; 8380 break __inlined_func$__wasm_ctz_i64; 8381 } 8382 i64toi32_i32$HIGH_BITS = 0; 8383 $0_1 = 64; 8384 } 8385 HEAP32[$7_1 + 8 >> 2] = $1_1 + ($0_1 >>> 3 | 0); 8386 return; 8387 } 8388 HEAP32[$0_1 + 8 >> 2] = $2_1 + ($9_1 & -8); 8389 $1_1 = HEAP32[$0_1 + 8 >> 2]; 8390 $4_1 = HEAP32[$0_1 + 4 >> 2]; 8391 block3 : { 8392 if ($1_1 >>> 0 >= $4_1 >>> 0) { 8393 break block3 8394 } 8395 $8_1 = HEAP32[$0_1 >> 2]; 8396 while (1) { 8397 $2_1 = HEAPU8[$1_1 + $8_1 | 0]; 8398 if (($2_1 | 0) == 34 | ($2_1 | 0) == 92 | $2_1 >>> 0 < 32) { 8399 break block3 8400 } 8401 $1_1 = $1_1 + 1 | 0; 8402 HEAP32[$0_1 + 8 >> 2] = $1_1; 8403 if (($1_1 | 0) != ($4_1 | 0)) { 8404 continue 8405 } 8406 break; 8407 }; 8408 } 8409 } 8410 return; 8411 } 8412 $137($1_1, $4_1, 1053564); 8413 wasm2js_trap(); 8414 } 8415 8416 function $64($0_1, $1_1) { 8417 var $2_1 = 0, $3_1 = 0, $4_1 = 0, $5_1 = 0, $6_1 = 0, $7_1 = 0, $8_1 = 0, $9_1 = 0; 8418 $6_1 = global$0 - 16 | 0; 8419 global$0 = $6_1; 8420 block2 : { 8421 $2_1 = HEAP32[$1_1 + 8 >> 2]; 8422 if ($2_1 >>> 0 < HEAPU32[$1_1 >> 2]) { 8423 $8_1 = $6_1 + 8 | 0; 8424 $4_1 = global$0 - 16 | 0; 8425 global$0 = $4_1; 8426 $7_1 = $4_1 + 12 | 0; 8427 $3_1 = HEAP32[$1_1 >> 2]; 8428 if ($3_1) { 8429 HEAP32[$4_1 + 12 >> 2] = 1; 8430 $9_1 = HEAP32[$1_1 + 4 >> 2]; 8431 $5_1 = $3_1; 8432 $7_1 = $4_1 + 8 | 0; 8433 } 8434 HEAP32[$7_1 >> 2] = $5_1; 8435 $5_1 = HEAP32[$4_1 + 12 >> 2]; 8436 block1 : { 8437 if ($5_1) { 8438 $3_1 = HEAP32[$4_1 + 8 >> 2]; 8439 block : { 8440 if (!$2_1) { 8441 if ($3_1) { 8442 $99($9_1, $3_1) 8443 } 8444 HEAP32[$1_1 + 4 >> 2] = 1; 8445 break block; 8446 } 8447 $7_1 = $2_1; 8448 $3_1 = $34($9_1, $3_1, $5_1, $2_1); 8449 if (!$3_1) { 8450 break block1 8451 } 8452 HEAP32[$1_1 + 4 >> 2] = $3_1; 8453 } 8454 HEAP32[$1_1 >> 2] = $2_1; 8455 } 8456 $5_1 = -1; 8457 } 8458 HEAP32[$8_1 + 4 >> 2] = $7_1; 8459 HEAP32[$8_1 >> 2] = $5_1; 8460 global$0 = $4_1 + 16 | 0; 8461 $2_1 = HEAP32[$6_1 + 8 >> 2]; 8462 if (($2_1 | 0) != -1) { 8463 break block2 8464 } 8465 $2_1 = HEAP32[$1_1 + 8 >> 2]; 8466 } 8467 HEAP32[$0_1 + 4 >> 2] = $2_1; 8468 HEAP32[$0_1 >> 2] = HEAP32[$1_1 + 4 >> 2]; 8469 global$0 = $6_1 + 16 | 0; 8470 return; 8471 } 8472 $120($2_1, HEAP32[$6_1 + 12 >> 2]); 8473 wasm2js_trap(); 8474 } 8475 8476 function $65($0_1) { 8477 var $1_1 = 0, $2_1 = 0, $3_1 = 0; 8478 $3_1 = HEAP32[$0_1 >> 2]; 8479 block : { 8480 if (($3_1 | 0) != 1) { 8481 break block 8482 } 8483 if (HEAP32[$0_1 + 4 >> 2]) { 8484 break block 8485 } 8486 $2_1 = HEAP32[$0_1 + 8 >> 2]; 8487 $1_1 = HEAP32[$0_1 + 12 >> 2]; 8488 if ($1_1) { 8489 while (1) { 8490 $2_1 = HEAP32[$2_1 + 408 >> 2]; 8491 $1_1 = $1_1 - 1 | 0; 8492 if ($1_1) { 8493 continue 8494 } 8495 break; 8496 } 8497 } 8498 HEAP32[$0_1 + 8 >> 2] = 0; 8499 HEAP32[$0_1 + 12 >> 2] = 0; 8500 HEAP32[$0_1 + 4 >> 2] = $2_1; 8501 HEAP32[$0_1 >> 2] = 1; 8502 } 8503 return $3_1 ? $0_1 + 4 | 0 : 0; 8504 } 8505 8506 function $66($0_1, $1_1) { 8507 var $2_1 = 0, $3_1 = 0, $4_1 = 0, $5_1 = 0, $6_1 = 0, $7_1 = 0, $8_1 = 0, $9_1 = 0, $10_1 = 0, $11_1 = 0; 8508 $5_1 = global$0 - 16 | 0; 8509 global$0 = $5_1; 8510 block8 : { 8511 block : { 8512 block1 : { 8513 block2 : { 8514 $2_1 = HEAP32[$1_1 + 32 >> 2]; 8515 if (!$2_1) { 8516 $2_1 = HEAP32[$1_1 >> 2]; 8517 HEAP32[$1_1 >> 2] = 0; 8518 if (($2_1 | 0) != 1) { 8519 break block 8520 } 8521 $6_1 = HEAP32[$1_1 + 12 >> 2]; 8522 $2_1 = HEAP32[$1_1 + 8 >> 2]; 8523 $1_1 = HEAP32[$1_1 + 4 >> 2]; 8524 if ($1_1) { 8525 $3_1 = $2_1; 8526 break block1; 8527 } 8528 if (!$6_1) { 8529 break block2 8530 } 8531 while (1) { 8532 $2_1 = HEAP32[$2_1 + 408 >> 2]; 8533 $6_1 = $6_1 - 1 | 0; 8534 if ($6_1) { 8535 continue 8536 } 8537 break; 8538 }; 8539 break block2; 8540 } 8541 HEAP32[$1_1 + 32 >> 2] = $2_1 - 1; 8542 $7_1 = $65($1_1); 8543 if ($7_1) { 8544 $11_1 = $5_1 + 4 | 0; 8545 $4_1 = global$0 - 48 | 0; 8546 global$0 = $4_1; 8547 $8_1 = $4_1 + 8 | 0; 8548 $3_1 = HEAP32[$7_1 + 4 >> 2]; 8549 block6 : { 8550 block4 : { 8551 $9_1 = HEAP32[$7_1 + 8 >> 2]; 8552 $2_1 = HEAP32[$7_1 >> 2]; 8553 block3 : { 8554 if ($9_1 >>> 0 < HEAPU16[$2_1 + 402 >> 1]) { 8555 $1_1 = $2_1; 8556 break block3; 8557 } 8558 while (1) { 8559 $1_1 = HEAP32[$2_1 + 264 >> 2]; 8560 if (!$1_1) { 8561 break block4 8562 } 8563 $9_1 = HEAPU16[$2_1 + 400 >> 1]; 8564 $99($2_1, $3_1 ? 456 : 408); 8565 $3_1 = $3_1 + 1 | 0; 8566 $2_1 = $1_1; 8567 if (HEAPU16[$1_1 + 402 >> 1] <= $9_1 >>> 0) { 8568 continue 8569 } 8570 break; 8571 }; 8572 } 8573 block5 : { 8574 if (!$3_1) { 8575 $6_1 = $1_1; 8576 $2_1 = $9_1 + 1 | 0; 8577 break block5; 8578 } 8579 $2_1 = (($9_1 << 2) + $1_1 | 0) + 412 | 0; 8580 $10_1 = $3_1; 8581 while (1) { 8582 $6_1 = HEAP32[$2_1 >> 2]; 8583 $2_1 = $6_1 + 408 | 0; 8584 $10_1 = $10_1 - 1 | 0; 8585 if ($10_1) { 8586 continue 8587 } 8588 break; 8589 }; 8590 $2_1 = 0; 8591 } 8592 HEAP32[$8_1 + 20 >> 2] = $9_1; 8593 HEAP32[$8_1 + 16 >> 2] = $3_1; 8594 HEAP32[$8_1 + 12 >> 2] = $1_1; 8595 HEAP32[$8_1 + 8 >> 2] = $2_1; 8596 HEAP32[$8_1 + 4 >> 2] = 0; 8597 HEAP32[$8_1 >> 2] = $6_1; 8598 break block6; 8599 } 8600 $99($2_1, $3_1 ? 456 : 408); 8601 HEAP32[$8_1 >> 2] = 0; 8602 } 8603 block7 : { 8604 if (HEAP32[$4_1 + 8 >> 2]) { 8605 $1_1 = HEAP32[$4_1 + 24 >> 2]; 8606 $2_1 = $11_1; 8607 HEAP32[$2_1 >> 2] = HEAP32[$4_1 + 20 >> 2]; 8608 HEAP32[$2_1 + 4 >> 2] = $1_1; 8609 HEAP32[$2_1 + 8 >> 2] = HEAP32[$4_1 + 28 >> 2]; 8610 $1_1 = HEAP32[$4_1 + 16 >> 2]; 8611 HEAP32[$4_1 + 40 >> 2] = $1_1; 8612 $2_1 = HEAP32[$4_1 + 12 >> 2]; 8613 $3_1 = HEAP32[$4_1 + 8 >> 2]; 8614 HEAP32[$4_1 + 32 >> 2] = $3_1; 8615 HEAP32[$4_1 + 36 >> 2] = $2_1; 8616 HEAP32[$7_1 + 8 >> 2] = $1_1; 8617 HEAP32[$7_1 >> 2] = $3_1; 8618 HEAP32[$7_1 + 4 >> 2] = $2_1; 8619 global$0 = $4_1 + 48 | 0; 8620 break block7; 8621 } 8622 $151(1053376); 8623 wasm2js_trap(); 8624 } 8625 HEAP32[$0_1 + 8 >> 2] = HEAP32[$5_1 + 12 >> 2]; 8626 $1_1 = HEAP32[$5_1 + 8 >> 2]; 8627 $2_1 = $0_1; 8628 HEAP32[$2_1 >> 2] = HEAP32[$5_1 + 4 >> 2]; 8629 HEAP32[$2_1 + 4 >> 2] = $1_1; 8630 break block8; 8631 } 8632 $151(1053772); 8633 wasm2js_trap(); 8634 } 8635 $6_1 = 0; 8636 $1_1 = $2_1; 8637 } 8638 HEAP32[$5_1 + 12 >> 2] = $6_1; 8639 HEAP32[$5_1 + 8 >> 2] = $3_1; 8640 HEAP32[$5_1 + 4 >> 2] = $1_1; 8641 $1_1 = $5_1 + 4 | 0; 8642 $3_1 = HEAP32[$1_1 + 4 >> 2]; 8643 $1_1 = HEAP32[$1_1 >> 2]; 8644 $2_1 = HEAP32[$1_1 + 264 >> 2]; 8645 if ($2_1) { 8646 while (1) { 8647 $99($1_1, $3_1 ? 456 : 408); 8648 $3_1 = $3_1 + 1 | 0; 8649 $1_1 = $2_1; 8650 $2_1 = HEAP32[$1_1 + 264 >> 2]; 8651 if ($2_1) { 8652 continue 8653 } 8654 break; 8655 } 8656 } 8657 $99($1_1, $3_1 ? 456 : 408); 8658 } 8659 HEAP32[$0_1 >> 2] = 0; 8660 } 8661 global$0 = $5_1 + 16 | 0; 8662 } 8663 8664 function $67($0_1, $1_1) { 8665 $0_1 = $0_1 | 0; 8666 $1_1 = $1_1 | 0; 8667 var $2_1 = 0; 8668 block23 : { 8669 switch (HEAP32[$0_1 >> 2] - 1 | 0) { 8670 default: 8671 return $145($1_1, HEAP32[$0_1 + 4 >> 2], HEAP32[$0_1 + 8 >> 2]) | 0; 8672 case 0: 8673 $2_1 = global$0 - 32 | 0; 8674 global$0 = $2_1; 8675 block29 : { 8676 block27 : { 8677 block26 : { 8678 block25 : { 8679 block28 : { 8680 $0_1 = $0_1 + 4 | 0; 8681 switch (HEAPU8[$0_1 | 0] - 1 | 0) { 8682 case 0: 8683 break block25; 8684 case 1: 8685 break block26; 8686 case 2: 8687 break block27; 8688 default: 8689 break block28; 8690 }; 8691 } 8692 HEAP32[$2_1 + 8 >> 2] = HEAP32[$0_1 + 4 >> 2]; 8693 $0_1 = $2_1 + 8 | 0; 8694 HEAP32[$2_1 + 12 >> 2] = $0_1; 8695 HEAP32[$2_1 + 24 >> 2] = $0_1; 8696 HEAP32[$2_1 + 28 >> 2] = 58; 8697 HEAP32[$2_1 + 16 >> 2] = $2_1 + 12; 8698 HEAP32[$2_1 + 20 >> 2] = 59; 8699 $0_1 = $133(HEAP32[$1_1 >> 2], HEAP32[$1_1 + 4 >> 2], 1051603, $2_1 + 16 | 0); 8700 break block29; 8701 } 8702 $0_1 = HEAPU8[$0_1 + 1 | 0]; 8703 $0_1 = FUNCTION_TABLE[HEAP32[HEAP32[$1_1 + 4 >> 2] + 12 >> 2]](HEAP32[$1_1 >> 2], HEAP32[($0_1 << 2) + 1067468 >> 2], HEAPU8[$0_1 + 1067424 | 0]) | 0; 8704 break block29; 8705 } 8706 $0_1 = HEAP32[$0_1 + 4 >> 2]; 8707 $0_1 = $144($1_1, HEAP32[$0_1 >> 2], HEAP32[$0_1 + 4 >> 2]); 8708 break block29; 8709 } 8710 $0_1 = HEAP32[$0_1 + 4 >> 2]; 8711 $0_1 = FUNCTION_TABLE[HEAP32[HEAP32[$0_1 + 4 >> 2] + 16 >> 2]](HEAP32[$0_1 >> 2], $1_1) | 0; 8712 } 8713 global$0 = $2_1 + 32 | 0; 8714 return $0_1 | 0; 8715 case 1: 8716 return $145($1_1, 1057404, 24) | 0; 8717 case 2: 8718 return $145($1_1, 1057428, 27) | 0; 8719 case 3: 8720 return $145($1_1, 1057455, 26) | 0; 8721 case 4: 8722 return $145($1_1, 1057481, 25) | 0; 8723 case 5: 8724 return $145($1_1, 1057506, 12) | 0; 8725 case 6: 8726 return $145($1_1, 1057518, 19) | 0; 8727 case 7: 8728 return $145($1_1, 1057537, 19) | 0; 8729 case 8: 8730 return $145($1_1, 1057556, 14) | 0; 8731 case 9: 8732 return $145($1_1, 1057570, 14) | 0; 8733 case 10: 8734 return $145($1_1, 1057584, 12) | 0; 8735 case 11: 8736 return $145($1_1, 1057596, 14) | 0; 8737 case 12: 8738 return $145($1_1, 1057610, 14) | 0; 8739 case 13: 8740 return $145($1_1, 1057624, 19) | 0; 8741 case 14: 8742 return $145($1_1, 1057643, 26) | 0; 8743 case 15: 8744 return $145($1_1, 1057669, 62) | 0; 8745 case 16: 8746 return $145($1_1, 1057731, 20) | 0; 8747 case 17: 8748 return $145($1_1, 1057751, 52) | 0; 8749 case 18: 8750 return $145($1_1, 1057803, 44) | 0; 8751 case 19: 8752 return $145($1_1, 1057847, 36) | 0; 8753 case 20: 8754 return $145($1_1, 1057883, 14) | 0; 8755 case 21: 8756 return $145($1_1, 1057897, 19) | 0; 8757 case 22: 8758 return $145($1_1, 1057916, 28) | 0; 8759 case 23: 8760 break block23; 8761 }; 8762 } 8763 return $145($1_1, 1057944, 24) | 0; 8764 } 8765 8766 function $68($0_1, $1_1) { 8767 $0_1 = $0_1 | 0; 8768 $1_1 = $1_1 | 0; 8769 return FUNCTION_TABLE[HEAP32[HEAP32[$0_1 + 4 >> 2] + 12 >> 2]](HEAP32[$0_1 >> 2], $1_1) | 0; 8770 } 8771 8772 function $69($0_1, $1_1) { 8773 $0_1 = $0_1 | 0; 8774 $1_1 = $1_1 | 0; 8775 var $2_1 = 0; 8776 $2_1 = HEAP32[$0_1 >> 2]; 8777 $0_1 = global$0 - 32 | 0; 8778 global$0 = $0_1; 8779 block : { 8780 if (!HEAP32[$2_1 + 12 >> 2]) { 8781 $1_1 = $67($2_1, $1_1); 8782 break block; 8783 } 8784 HEAP32[$0_1 + 28 >> 2] = 4; 8785 HEAP32[$0_1 + 20 >> 2] = 4; 8786 HEAP32[$0_1 + 16 >> 2] = $2_1 + 12; 8787 HEAP32[$0_1 + 12 >> 2] = 14; 8788 HEAP32[$0_1 + 8 >> 2] = $2_1; 8789 HEAP32[$0_1 + 24 >> 2] = $2_1 + 16; 8790 $1_1 = $133(HEAP32[$1_1 >> 2], HEAP32[$1_1 + 4 >> 2], 1048710, $0_1 + 8 | 0); 8791 } 8792 global$0 = $0_1 + 32 | 0; 8793 return $1_1 | 0; 8794 } 8795 8796 function $70($0_1) { 8797 var $1_1 = 0, $2_1 = 0, $3_1 = 0, $4_1 = 0, $5_1 = 0; 8798 $3_1 = global$0 - 16 | 0; 8799 global$0 = $3_1; 8800 block2 : { 8801 block1 : { 8802 while (1) { 8803 block : { 8804 $63($0_1); 8805 $1_1 = HEAP32[$0_1 + 8 >> 2]; 8806 $2_1 = HEAP32[$0_1 + 4 >> 2]; 8807 if (($1_1 | 0) == ($2_1 | 0)) { 8808 break block 8809 } 8810 if ($1_1 >>> 0 >= $2_1 >>> 0) { 8811 break block1 8812 } 8813 $2_1 = HEAPU8[$1_1 + HEAP32[$0_1 >> 2] | 0]; 8814 if (($2_1 | 0) != 92) { 8815 if (($2_1 | 0) != 34) { 8816 HEAP32[$3_1 + 4 >> 2] = 16; 8817 $1_1 = $51($0_1, $3_1 + 4 | 0); 8818 break block2; 8819 } 8820 HEAP32[$0_1 + 8 >> 2] = $1_1 + 1; 8821 $1_1 = 0; 8822 break block2; 8823 } 8824 HEAP32[$0_1 + 8 >> 2] = $1_1 + 1; 8825 $5_1 = 0; 8826 $1_1 = global$0 - 32 | 0; 8827 global$0 = $1_1; 8828 $47($1_1 + 20 | 0, $0_1); 8829 block3 : { 8830 if (HEAPU8[$1_1 + 20 | 0] == 1) { 8831 $5_1 = HEAP32[$1_1 + 24 >> 2]; 8832 break block3; 8833 } 8834 block4 : { 8835 $2_1 = HEAPU8[$1_1 + 21 | 0]; 8836 if ($2_1 >>> 0 <= 109) { 8837 if ($2_1 >>> 0 <= 97) { 8838 if (($2_1 | 0) == 34 | ($2_1 | 0) == 47 | ($2_1 | 0) == 92) { 8839 break block3 8840 } 8841 break block4; 8842 } 8843 switch ($2_1 - 98 | 0) { 8844 case 0: 8845 case 4: 8846 break block3; 8847 default: 8848 break block4; 8849 }; 8850 } 8851 block5 : { 8852 switch ($2_1 - 110 | 0) { 8853 case 0: 8854 case 4: 8855 case 6: 8856 break block3; 8857 case 7: 8858 break block5; 8859 default: 8860 break block4; 8861 }; 8862 } 8863 $2_1 = HEAP32[$0_1 + 4 >> 2]; 8864 $4_1 = HEAP32[$0_1 + 8 >> 2]; 8865 if ($2_1 >>> 0 >= $4_1 >>> 0) { 8866 block6 : { 8867 if ($2_1 - $4_1 >>> 0 <= 3) { 8868 HEAP32[$0_1 + 8 >> 2] = $2_1; 8869 HEAP32[$1_1 + 20 >> 2] = 4; 8870 $52($1_1 + 12 | 0, $0_1, $1_1 + 20 | 0); 8871 break block6; 8872 } 8873 HEAP32[$0_1 + 8 >> 2] = $4_1 + 4; 8874 $2_1 = $4_1 + HEAP32[$0_1 >> 2] | 0; 8875 if ((HEAPU16[(HEAPU8[$2_1 + 1 | 0] << 1) + 1056264 >> 1] | HEAPU16[(HEAPU8[$2_1 | 0] << 1) + 1056776 >> 1] | HEAPU16[(HEAPU8[$2_1 + 2 | 0] << 1) + 1056776 >> 1] | HEAPU16[(HEAPU8[$2_1 + 3 | 0] << 1) + 1056264 >> 1]) << 16 >> 16 >= 0) { 8876 HEAP16[$1_1 + 12 >> 1] = 0; 8877 break block6; 8878 } 8879 HEAP32[$1_1 + 20 >> 2] = 12; 8880 $52($1_1 + 12 | 0, $0_1, $1_1 + 20 | 0); 8881 } 8882 if (HEAPU16[$1_1 + 12 >> 1] != 1) { 8883 break block3 8884 } 8885 $5_1 = HEAP32[$1_1 + 16 >> 2]; 8886 break block3; 8887 } 8888 $135($4_1, $2_1, $2_1, 1057984); 8889 wasm2js_trap(); 8890 } 8891 HEAP32[$1_1 + 20 >> 2] = 12; 8892 $5_1 = $51($0_1, $1_1 + 20 | 0); 8893 } 8894 global$0 = $1_1 + 32 | 0; 8895 $1_1 = $5_1; 8896 if (!$1_1) { 8897 continue 8898 } 8899 break block2; 8900 } 8901 break; 8902 }; 8903 HEAP32[$3_1 + 4 >> 2] = 4; 8904 $1_1 = $51($0_1, $3_1 + 4 | 0); 8905 break block2; 8906 } 8907 $137($1_1, $2_1, 1057968); 8908 wasm2js_trap(); 8909 } 8910 global$0 = $3_1 + 16 | 0; 8911 return $1_1; 8912 } 8913 8914 function $71($0_1, $1_1) { 8915 var $2_1 = 0, $3_1 = 0, $4_1 = 0; 8916 $2_1 = global$0 - 16 | 0; 8917 global$0 = $2_1; 8918 $4_1 = $1_1; 8919 $3_1 = HEAP32[$1_1 + 8 >> 2] + 1 | 0; 8920 $1_1 = HEAP32[$1_1 + 4 >> 2]; 8921 $54($2_1 + 8 | 0, $4_1, $1_1 >>> 0 > $3_1 >>> 0 ? $3_1 : $1_1); 8922 $1_1 = HEAP32[$2_1 + 12 >> 2]; 8923 HEAP32[$0_1 >> 2] = HEAP32[$2_1 + 8 >> 2]; 8924 HEAP32[$0_1 + 4 >> 2] = $1_1; 8925 global$0 = $2_1 + 16 | 0; 8926 } 8927 8928 function $72($0_1, $1_1) { 8929 var $2_1 = 0; 8930 $2_1 = global$0 - 16 | 0; 8931 global$0 = $2_1; 8932 $54($2_1 + 8 | 0, $1_1, HEAP32[$1_1 + 8 >> 2]); 8933 $1_1 = HEAP32[$2_1 + 12 >> 2]; 8934 HEAP32[$0_1 >> 2] = HEAP32[$2_1 + 8 >> 2]; 8935 HEAP32[$0_1 + 4 >> 2] = $1_1; 8936 global$0 = $2_1 + 16 | 0; 8937 } 8938 8939 function $73($0_1, $1_1, $2_1) { 8940 var $3_1 = 0, $4_1 = 0, $5_1 = 0, $6_1 = 0, $7_1 = 0, $8_1 = 0, $9_1 = 0; 8941 $4_1 = global$0 - 16 | 0; 8942 global$0 = $4_1; 8943 block3 : { 8944 block7 : { 8945 block5 : { 8946 block4 : { 8947 block1 : { 8948 block : { 8949 block2 : { 8950 while (1) { 8951 $5_1 = HEAP32[$1_1 + 8 >> 2]; 8952 $63($1_1); 8953 $3_1 = HEAP32[$1_1 + 8 >> 2]; 8954 $6_1 = HEAP32[$1_1 + 4 >> 2]; 8955 if (($3_1 | 0) == ($6_1 | 0)) { 8956 break block 8957 } 8958 if ($3_1 >>> 0 >= $6_1 >>> 0) { 8959 break block1 8960 } 8961 $7_1 = HEAP32[$1_1 >> 2]; 8962 $8_1 = $3_1 + $7_1 | 0; 8963 $9_1 = HEAPU8[$8_1 | 0]; 8964 if (($9_1 | 0) != 92) { 8965 if (($9_1 | 0) == 34) { 8966 break block2 8967 } 8968 HEAP32[$1_1 + 8 >> 2] = $3_1 + 1; 8969 HEAP32[$4_1 + 4 >> 2] = 16; 8970 $53($0_1, $1_1, $4_1 + 4 | 0); 8971 break block3; 8972 } 8973 if ($3_1 >>> 0 < $5_1 >>> 0) { 8974 break block4 8975 } 8976 $61($2_1, $5_1 + $7_1 | 0, $8_1); 8977 HEAP32[$1_1 + 8 >> 2] = $3_1 + 1; 8978 $3_1 = $50($1_1, 1, $2_1); 8979 if (!$3_1) { 8980 continue 8981 } 8982 break; 8983 }; 8984 HEAP32[$0_1 >> 2] = 2; 8985 HEAP32[$0_1 + 4 >> 2] = $3_1; 8986 break block3; 8987 } 8988 if (HEAP32[$2_1 + 8 >> 2]) { 8989 if ($3_1 >>> 0 < $5_1 >>> 0) { 8990 break block5 8991 } 8992 $61($2_1, $5_1 + $7_1 | 0, $8_1); 8993 $5_1 = 1; 8994 HEAP32[$1_1 + 8 >> 2] = $3_1 + 1; 8995 $56($4_1 + 4 | 0, $1_1, HEAP32[$2_1 + 4 >> 2], HEAP32[$2_1 + 8 >> 2]); 8996 $1_1 = HEAP32[$4_1 + 4 >> 2]; 8997 block6 : { 8998 if (!$1_1) { 8999 $5_1 = 2; 9000 $1_1 = HEAP32[$4_1 + 8 >> 2]; 9001 break block6; 9002 } 9003 HEAP32[$0_1 + 8 >> 2] = HEAP32[$4_1 + 8 >> 2]; 9004 } 9005 HEAP32[$0_1 >> 2] = $5_1; 9006 HEAP32[$0_1 + 4 >> 2] = $1_1; 9007 break block3; 9008 } 9009 if ($3_1 >>> 0 < $5_1 >>> 0) { 9010 break block7 9011 } 9012 HEAP32[$1_1 + 8 >> 2] = $3_1 + 1; 9013 $56($4_1 + 4 | 0, $1_1, $5_1 + $7_1 | 0, $3_1 - $5_1 | 0); 9014 $1_1 = HEAP32[$4_1 + 4 >> 2]; 9015 block8 : { 9016 if (!$1_1) { 9017 $1_1 = HEAP32[$4_1 + 8 >> 2]; 9018 $2_1 = 2; 9019 break block8; 9020 } 9021 HEAP32[$0_1 + 8 >> 2] = HEAP32[$4_1 + 8 >> 2]; 9022 $2_1 = 0; 9023 } 9024 HEAP32[$0_1 >> 2] = $2_1; 9025 HEAP32[$0_1 + 4 >> 2] = $1_1; 9026 break block3; 9027 } 9028 HEAP32[$4_1 + 4 >> 2] = 4; 9029 $53($0_1, $1_1, $4_1 + 4 | 0); 9030 break block3; 9031 } 9032 $137($3_1, $6_1, 1053208); 9033 wasm2js_trap(); 9034 } 9035 $135($5_1, $3_1, $6_1, 1053256); 9036 wasm2js_trap(); 9037 } 9038 $135($5_1, $3_1, $6_1, 1053224); 9039 wasm2js_trap(); 9040 } 9041 $135($5_1, $3_1, $6_1, 1053240); 9042 wasm2js_trap(); 9043 } 9044 global$0 = $4_1 + 16 | 0; 9045 } 9046 9047 function $74($0_1, $1_1) { 9048 $0_1 = $0_1 | 0; 9049 $1_1 = $1_1 | 0; 9050 var $2_1 = 0, $3_1 = 0; 9051 $2_1 = global$0 + -64 | 0; 9052 global$0 = $2_1; 9053 $0_1 = HEAP32[$0_1 >> 2]; 9054 HEAP32[$2_1 + 56 >> 2] = 0; 9055 HEAP32[$2_1 + 48 >> 2] = 0; 9056 HEAP32[$2_1 + 52 >> 2] = 1; 9057 HEAP32[$2_1 + 28 >> 2] = 1058e3; 9058 HEAP32[$2_1 + 32 >> 2] = 1610612768; 9059 HEAP32[$2_1 + 36 >> 2] = 0; 9060 HEAP32[$2_1 + 24 >> 2] = $2_1 + 48; 9061 if ($67($0_1, $2_1 + 24 | 0)) { 9062 $152(1058040, 55, $2_1 + 63 | 0, 1058024, 1058096); 9063 wasm2js_trap(); 9064 } 9065 HEAP32[$2_1 + 16 >> 2] = HEAP32[$2_1 + 56 >> 2]; 9066 $3_1 = HEAP32[$2_1 + 52 >> 2]; 9067 HEAP32[$2_1 + 8 >> 2] = HEAP32[$2_1 + 48 >> 2]; 9068 HEAP32[$2_1 + 12 >> 2] = $3_1; 9069 HEAP32[$2_1 + 44 >> 2] = 4; 9070 HEAP32[$2_1 + 40 >> 2] = $0_1 + 16; 9071 HEAP32[$2_1 + 36 >> 2] = 4; 9072 HEAP32[$2_1 + 32 >> 2] = $0_1 + 12; 9073 HEAP32[$2_1 + 28 >> 2] = 15; 9074 $3_1 = $2_1 + 8 | 0; 9075 HEAP32[$2_1 + 24 >> 2] = $3_1; 9076 $0_1 = $133(HEAP32[$1_1 >> 2], HEAP32[$1_1 + 4 >> 2], 1051620, $2_1 + 24 | 0); 9077 $45($3_1, 1, 1); 9078 global$0 = $2_1 - -64 | 0; 9079 return $0_1 | 0; 9080 } 9081 9082 function $75($0_1, $1_1) { 9083 $0_1 = $0_1 | 0; 9084 $1_1 = $1_1 | 0; 9085 return $159(HEAP32[$0_1 + 4 >> 2], HEAP32[$0_1 + 8 >> 2], $1_1) | 0; 9086 } 9087 9088 function $76($0_1, $1_1) { 9089 $0_1 = $0_1 | 0; 9090 $1_1 = $1_1 | 0; 9091 var $2_1 = 0, $3_1 = 0, $4_1 = 0, $5_1 = 0, $6_1 = 0, $7_1 = 0, $8_1 = 0.0; 9092 $3_1 = global$0 - 48 | 0; 9093 global$0 = $3_1; 9094 block22 : { 9095 block2 : { 9096 switch (HEAPU8[$0_1 | 0] - 3 | 0) { 9097 default: 9098 $5_1 = HEAP32[$0_1 + 12 >> 2]; 9099 HEAP32[$3_1 + 24 >> 2] = HEAP32[$0_1 + 8 >> 2]; 9100 HEAP32[$3_1 + 28 >> 2] = $5_1; 9101 $4_1 = HEAP32[$0_1 + 4 >> 2]; 9102 HEAP32[$3_1 + 16 >> 2] = HEAP32[$0_1 >> 2]; 9103 HEAP32[$3_1 + 20 >> 2] = $4_1; 9104 $0_1 = global$0 - 16 | 0; 9105 global$0 = $0_1; 9106 block21 : { 9107 block19 : { 9108 block18 : { 9109 block17 : { 9110 block16 : { 9111 block15 : { 9112 block14 : { 9113 block13 : { 9114 block12 : { 9115 block11 : { 9116 block10 : { 9117 block9 : { 9118 block8 : { 9119 block7 : { 9120 block6 : { 9121 block5 : { 9122 block4 : { 9123 block3 : { 9124 block20 : { 9125 $2_1 = $3_1 + 16 | 0; 9126 switch (HEAPU8[$2_1 | 0] - 1 | 0) { 9127 case 7: 9128 break block10; 9129 case 8: 9130 break block11; 9131 case 9: 9132 break block12; 9133 case 10: 9134 break block13; 9135 case 11: 9136 break block14; 9137 case 12: 9138 break block15; 9139 case 13: 9140 break block16; 9141 case 14: 9142 break block17; 9143 case 15: 9144 break block18; 9145 case 16: 9146 break block19; 9147 case 0: 9148 break block3; 9149 case 1: 9150 break block4; 9151 case 2: 9152 break block5; 9153 case 3: 9154 break block6; 9155 case 4: 9156 break block7; 9157 case 5: 9158 break block8; 9159 case 6: 9160 break block9; 9161 default: 9162 break block20; 9163 }; 9164 } 9165 HEAP8[$0_1 | 0] = HEAPU8[$2_1 + 1 | 0]; 9166 HEAP32[$0_1 + 12 >> 2] = 21; 9167 HEAP32[$0_1 + 8 >> 2] = $0_1; 9168 $1_1 = $133(HEAP32[$1_1 >> 2], HEAP32[$1_1 + 4 >> 2], 1051379, $0_1 + 8 | 0); 9169 break block21; 9170 } 9171 $5_1 = HEAP32[$2_1 + 12 >> 2]; 9172 HEAP32[$0_1 >> 2] = HEAP32[$2_1 + 8 >> 2]; 9173 HEAP32[$0_1 + 4 >> 2] = $5_1; 9174 HEAP32[$0_1 + 12 >> 2] = 22; 9175 HEAP32[$0_1 + 8 >> 2] = $0_1; 9176 $1_1 = $133(HEAP32[$1_1 >> 2], HEAP32[$1_1 + 4 >> 2], 1051365, $0_1 + 8 | 0); 9177 break block21; 9178 } 9179 $4_1 = HEAP32[$2_1 + 12 >> 2]; 9180 HEAP32[$0_1 >> 2] = HEAP32[$2_1 + 8 >> 2]; 9181 HEAP32[$0_1 + 4 >> 2] = $4_1; 9182 HEAP32[$0_1 + 12 >> 2] = 23; 9183 HEAP32[$0_1 + 8 >> 2] = $0_1; 9184 $1_1 = $133(HEAP32[$1_1 >> 2], HEAP32[$1_1 + 4 >> 2], 1051365, $0_1 + 8 | 0); 9185 break block21; 9186 } 9187 HEAPF64[$0_1 >> 3] = HEAPF64[$2_1 + 8 >> 3]; 9188 HEAP32[$0_1 + 12 >> 2] = 24; 9189 HEAP32[$0_1 + 8 >> 2] = $0_1; 9190 $1_1 = $133(HEAP32[$1_1 >> 2], HEAP32[$1_1 + 4 >> 2], 1051314, $0_1 + 8 | 0); 9191 break block21; 9192 } 9193 HEAP32[$0_1 >> 2] = HEAP32[$2_1 + 4 >> 2]; 9194 HEAP32[$0_1 + 12 >> 2] = 25; 9195 HEAP32[$0_1 + 8 >> 2] = $0_1; 9196 $1_1 = $133(HEAP32[$1_1 >> 2], HEAP32[$1_1 + 4 >> 2], 1051349, $0_1 + 8 | 0); 9197 break block21; 9198 } 9199 $5_1 = HEAP32[$2_1 + 8 >> 2]; 9200 HEAP32[$0_1 >> 2] = HEAP32[$2_1 + 4 >> 2]; 9201 HEAP32[$0_1 + 4 >> 2] = $5_1; 9202 HEAP32[$0_1 + 12 >> 2] = 26; 9203 HEAP32[$0_1 + 8 >> 2] = $0_1; 9204 $1_1 = $133(HEAP32[$1_1 >> 2], HEAP32[$1_1 + 4 >> 2], 1048965, $0_1 + 8 | 0); 9205 break block21; 9206 } 9207 $1_1 = $145($1_1, 1059268, 10); 9208 break block21; 9209 } 9210 $1_1 = $145($1_1, 1059278, 10); 9211 break block21; 9212 } 9213 $1_1 = $145($1_1, 1059288, 12); 9214 break block21; 9215 } 9216 $1_1 = $145($1_1, 1059300, 14); 9217 break block21; 9218 } 9219 $1_1 = $145($1_1, 1059314, 8); 9220 break block21; 9221 } 9222 $1_1 = $145($1_1, 1059322, 3); 9223 break block21; 9224 } 9225 $1_1 = $145($1_1, 1059325, 4); 9226 break block21; 9227 } 9228 $1_1 = $145($1_1, 1059329, 12); 9229 break block21; 9230 } 9231 $1_1 = $145($1_1, 1059341, 15); 9232 break block21; 9233 } 9234 $1_1 = $145($1_1, 1059356, 13); 9235 break block21; 9236 } 9237 $1_1 = $145($1_1, 1059369, 14); 9238 break block21; 9239 } 9240 $1_1 = $145($1_1, HEAP32[$2_1 + 4 >> 2], HEAP32[$2_1 + 8 >> 2]); 9241 } 9242 global$0 = $0_1 + 16 | 0; 9243 break block22; 9244 case 0: 9245 $2_1 = $3_1 + 16 | 0; 9246 $8_1 = HEAPF64[$0_1 + 8 >> 3]; 9247 $0_1 = global$0 - 16 | 0; 9248 global$0 = $0_1; 9249 wasm2js_scratch_store_f64(+$8_1); 9250 $5_1 = wasm2js_scratch_load_i32(1) | 0; 9251 $6_1 = wasm2js_scratch_load_i32(0) | 0; 9252 $4_1 = 1; 9253 $7_1 = 1; 9254 if (($4_1 & 63) >>> 0 >= 32) { 9255 $4_1 = $6_1 << $7_1; 9256 $5_1 = 0; 9257 } else { 9258 $4_1 = (1 << $7_1) - 1 & $6_1 >>> 32 - $7_1 | $5_1 << $7_1; 9259 $5_1 = $6_1 << $7_1; 9260 } 9261 $6_1 = -2097153; 9262 block23 : { 9263 if (($4_1 | 0) == ($6_1 | 0) | $4_1 >>> 0 < $6_1 >>> 0) { 9264 $6_1 = $84($8_1, $2_1) - $2_1 | 0; 9265 break block23; 9266 } 9267 wasm2js_scratch_store_f64(+$8_1); 9268 $5_1 = wasm2js_scratch_load_i32(1) | 0; 9269 $2_1 = $0_1 + 8 | 0; 9270 $6_1 = wasm2js_scratch_load_i32(0) | 0; 9271 HEAP32[$2_1 + 4 >> 2] = !$6_1 & ($5_1 & -2146435073) == -2147483648 ? 4 : 3; 9272 $4_1 = 0; 9273 if (($5_1 | 0) < ($4_1 | 0)) { 9274 $4_1 = 1 9275 } else { 9276 $4_1 = ($5_1 | 0) <= ($4_1 | 0) & $4_1 >>> 0 > $6_1 >>> 0 9277 } 9278 HEAP32[$2_1 >> 2] = $5_1 & 1048575 | $6_1 ? 1059247 : $4_1 ? 1059243 : 1059240; 9279 $2_1 = HEAP32[$0_1 + 8 >> 2]; 9280 $6_1 = HEAP32[$0_1 + 12 >> 2]; 9281 } 9282 HEAP32[$3_1 >> 2] = $2_1; 9283 HEAP32[$3_1 + 4 >> 2] = $6_1; 9284 global$0 = $0_1 + 16 | 0; 9285 $4_1 = HEAP32[$3_1 + 4 >> 2]; 9286 HEAP32[$3_1 + 8 >> 2] = HEAP32[$3_1 >> 2]; 9287 HEAP32[$3_1 + 12 >> 2] = $4_1; 9288 HEAP32[$3_1 + 44 >> 2] = 1; 9289 HEAP32[$3_1 + 40 >> 2] = $3_1 + 8; 9290 $1_1 = $133(HEAP32[$1_1 >> 2], HEAP32[$1_1 + 4 >> 2], 1051314, $3_1 + 40 | 0); 9291 break block22; 9292 case 4: 9293 break block2; 9294 }; 9295 } 9296 $1_1 = $145($1_1, 1053480, 4); 9297 } 9298 global$0 = $3_1 + 48 | 0; 9299 return $1_1 | 0; 9300 } 9301 9302 function $77($0_1, $1_1) { 9303 $0_1 = $0_1 | 0; 9304 $1_1 = $1_1 | 0; 9305 return $145($1_1, 1058112, 5) | 0; 9306 } 9307 9308 function $78($0_1, $1_1) { 9309 $0_1 = $0_1 | 0; 9310 $1_1 = $1_1 | 0; 9311 var $2_1 = 0, $3_1 = 0, $4_1 = 0, $5_1 = 0, $6_1 = 0, $7_1 = 0; 9312 $5_1 = HEAP32[$0_1 + 8 >> 2]; 9313 $3_1 = 1; 9314 block : { 9315 if ($1_1 >>> 0 < 128) { 9316 break block 9317 } 9318 $3_1 = 2; 9319 if ($1_1 >>> 0 < 2048) { 9320 break block 9321 } 9322 $3_1 = $1_1 >>> 0 < 65536 ? 3 : 4; 9323 } 9324 if ($3_1 >>> 0 > HEAP32[$0_1 >> 2] - $5_1 >>> 0) { 9325 $38($0_1, $5_1, $3_1, 1, 1) 9326 } 9327 $2_1 = $5_1 + HEAP32[$0_1 + 4 >> 2] | 0; 9328 block1 : { 9329 if ($1_1 >>> 0 >= 128) { 9330 $6_1 = $1_1 & 63 | -128; 9331 $4_1 = $1_1 >>> 6 | 0; 9332 if ($1_1 >>> 0 < 2048) { 9333 HEAP8[$2_1 + 1 | 0] = $6_1; 9334 HEAP8[$2_1 | 0] = $4_1 | 192; 9335 break block1; 9336 } 9337 $7_1 = $1_1 >>> 12 | 0; 9338 $4_1 = $4_1 & 63 | -128; 9339 if ($1_1 >>> 0 <= 65535) { 9340 HEAP8[$2_1 + 2 | 0] = $6_1; 9341 HEAP8[$2_1 + 1 | 0] = $4_1; 9342 HEAP8[$2_1 | 0] = $7_1 | 224; 9343 break block1; 9344 } 9345 HEAP8[$2_1 + 3 | 0] = $6_1; 9346 HEAP8[$2_1 + 2 | 0] = $4_1; 9347 HEAP8[$2_1 + 1 | 0] = $7_1 & 63 | -128; 9348 HEAP8[$2_1 | 0] = $1_1 >>> 18 | -16; 9349 break block1; 9350 } 9351 HEAP8[$2_1 | 0] = $1_1; 9352 } 9353 HEAP32[$0_1 + 8 >> 2] = $5_1 + $3_1; 9354 return 0; 9355 } 9356 9357 function $79($0_1, $1_1, $2_1) { 9358 $0_1 = $0_1 | 0; 9359 $1_1 = $1_1 | 0; 9360 $2_1 = $2_1 | 0; 9361 var $3_1 = 0; 9362 $3_1 = HEAP32[$0_1 + 8 >> 2]; 9363 block1 : { 9364 block : { 9365 if ($2_1 >>> 0 > HEAP32[$0_1 >> 2] - $3_1 >>> 0) { 9366 $38($0_1, $3_1, $2_1, 1, 1); 9367 $3_1 = HEAP32[$0_1 + 8 >> 2]; 9368 break block; 9369 } 9370 if (!$2_1) { 9371 break block1 9372 } 9373 } 9374 if (!$2_1) { 9375 break block1 9376 } 9377 wasm2js_memory_copy($3_1 + HEAP32[$0_1 + 4 >> 2] | 0, $1_1, $2_1); 9378 } 9379 HEAP32[$0_1 + 8 >> 2] = $2_1 + $3_1; 9380 return 0; 9381 } 9382 9383 function $80($0_1, $1_1) { 9384 $0_1 = $0_1 | 0; 9385 $1_1 = $1_1 | 0; 9386 return $145($1_1, 1059383, 4) | 0; 9387 } 9388 9389 function $81($0_1, $1_1, $2_1) { 9390 $0_1 = $0_1 | 0; 9391 $1_1 = $1_1 | 0; 9392 $2_1 = $2_1 | 0; 9393 return $133($0_1, 1058e3, $1_1, $2_1) | 0; 9394 } 9395 9396 function $82($0_1, $1_1, $2_1) { 9397 HEAP32[$0_1 + 4 >> 2] = 20 - $2_1; 9398 HEAP32[$0_1 >> 2] = $1_1 + $2_1; 9399 } 9400 9401 function $83($0_1, $1_1, $2_1) { 9402 var $3_1 = 0, $4_1 = 0, $5_1 = 0, $6_1 = 0, $7_1 = 0, $8_1 = 0, $9_1 = 0, $10_1 = 0, $11_1 = 0; 9403 $4_1 = 20; 9404 block : { 9405 $6_1 = $1_1; 9406 $7_1 = $0_1; 9407 if (($6_1 | 0) == 0 & $7_1 >>> 0 < 1e3 | $5_1 >>> 0 > $6_1 >>> 0) { 9408 break block 9409 } 9410 $4_1 = 16; 9411 $9_1 = $7_1; 9412 $8_1 = $6_1; 9413 while (1) { 9414 $7_1 = __wasm_i64_udiv($9_1, $8_1, 1e4, 0); 9415 $6_1 = i64toi32_i32$HIGH_BITS; 9416 $5_1 = __wasm_i64_mul($7_1, $6_1, 1e4, 0); 9417 $3_1 = $2_1 + $4_1 | 0; 9418 $5_1 = $9_1 - $5_1 | 0; 9419 $10_1 = Math_imul($5_1, 5243) >>> 19 | 0; 9420 $11_1 = HEAPU16[($10_1 << 1) + 1058152 >> 1]; 9421 HEAP8[$3_1 | 0] = $11_1; 9422 HEAP8[$3_1 + 1 | 0] = $11_1 >>> 8; 9423 $3_1 = $3_1 + 2 | 0; 9424 $5_1 = HEAPU16[($5_1 + Math_imul($10_1, -100) << 1) + 1058152 >> 1]; 9425 HEAP8[$3_1 | 0] = $5_1; 9426 HEAP8[$3_1 + 1 | 0] = $5_1 >>> 8; 9427 $5_1 = 0; 9428 if (($8_1 | 0) == ($5_1 | 0) & $9_1 >>> 0 <= 9999999 | $5_1 >>> 0 > $8_1 >>> 0) { 9429 break block 9430 } 9431 $9_1 = $7_1; 9432 $8_1 = $6_1; 9433 $4_1 = $4_1 - 4 | 0; 9434 if ($4_1 >>> 0 < 20) { 9435 continue 9436 } 9437 break; 9438 }; 9439 $137(-4, 20, 1058352); 9440 wasm2js_trap(); 9441 } 9442 block1 : { 9443 $8_1 = 0; 9444 if (($8_1 | 0) == ($6_1 | 0) & $7_1 >>> 0 < 10 | $6_1 >>> 0 < $8_1 >>> 0) { 9445 $3_1 = $4_1; 9446 break block1; 9447 } 9448 $3_1 = $4_1 - 2 | 0; 9449 if ($3_1 >>> 0 < 20) { 9450 $6_1 = ($2_1 + $4_1 | 0) - 1 | 0; 9451 $4_1 = $7_1; 9452 $5_1 = Math_imul($4_1, 5243) >>> 19 | 0; 9453 $4_1 = Math_imul($5_1, -100) + $4_1 << 1; 9454 HEAP8[$6_1 | 0] = HEAPU8[$4_1 + 1058153 | 0]; 9455 HEAP8[$2_1 + $3_1 | 0] = HEAPU8[$4_1 + 1058152 | 0]; 9456 $7_1 = $5_1; 9457 $6_1 = 0; 9458 break block1; 9459 } 9460 $137($3_1, 20, 1058352); 9461 wasm2js_trap(); 9462 } 9463 block2 : { 9464 if (!(!($6_1 | $7_1) & ($0_1 | $1_1) != 0)) { 9465 $3_1 = $3_1 - 1 | 0; 9466 if ($3_1 >>> 0 >= 20) { 9467 break block2 9468 } 9469 HEAP8[$2_1 + $3_1 | 0] = $7_1 | 48; 9470 } 9471 return $3_1; 9472 } 9473 $137(-1, 20, 1058352); 9474 wasm2js_trap(); 9475 } 9476 9477 function $84($0_1, $1_1) { 9478 var $2_1 = 0, $3_1 = 0, $4_1 = 0, $5_1 = 0, $6_1 = 0, $7_1 = 0, $8_1 = 0, $9_1 = 0, $10_1 = 0, $11_1 = 0, $12_1 = 0, $13_1 = 0, $14_1 = 0, $15_1 = 0, $16_1 = 0, $17_1 = 0, $18_1 = 0, $19_1 = 0, $20_1 = 0, $21_1 = 0, $22_1 = 0, $23_1 = 0, $24_1 = 0, $25_1 = 0; 9479 $16_1 = global$0 - 240 | 0; 9480 global$0 = $16_1; 9481 HEAP8[$1_1 | 0] = 45; 9482 wasm2js_scratch_store_f64(+$0_1); 9483 $2_1 = wasm2js_scratch_load_i32(1) | 0; 9484 $17_1 = wasm2js_scratch_load_i32(0) | 0; 9485 $8_1 = $17_1; 9486 $19_1 = $2_1; 9487 $9_1 = $2_1 & 1048575; 9488 $6_1 = $2_1; 9489 $2_1 = $8_1; 9490 $5_1 = 63; 9491 $4_1 = 31; 9492 if (($5_1 & 63) >>> 0 >= 32) { 9493 $2_1 = $6_1 >>> $4_1 | 0 9494 } else { 9495 $2_1 = ((1 << $4_1) - 1 & $6_1) << 32 - $4_1 | $2_1 >>> $4_1 9496 } 9497 $15_1 = $2_1 + $1_1 | 0; 9498 $3_1 = $19_1; 9499 $6_1 = $17_1; 9500 $5_1 = 52; 9501 $4_1 = 20; 9502 block5 : { 9503 block4 : { 9504 block3 : { 9505 block : { 9506 if (($5_1 & 63) >>> 0 >= 32) { 9507 $1_1 = $3_1 >>> $4_1 | 0 9508 } else { 9509 $1_1 = ((1 << $4_1) - 1 & $3_1) << 32 - $4_1 | $6_1 >>> $4_1 9510 } 9511 $11_1 = $1_1 & 2047; 9512 block1 : { 9513 if (!$11_1) { 9514 $6_1 = $9_1; 9515 if (!($6_1 | $8_1)) { 9516 break block 9517 } 9518 $2_1 = $8_1; 9519 $5_1 = 5; 9520 $4_1 = 5; 9521 $1_1 = $16_1 + 48 | 0; 9522 if (($5_1 & 63) >>> 0 >= 32) { 9523 $3_1 = $2_1 << $4_1; 9524 $8_1 = 0; 9525 } else { 9526 $3_1 = (1 << $4_1) - 1 & $2_1 >>> 32 - $4_1 | $6_1 << $4_1; 9527 $8_1 = $2_1 << $4_1; 9528 } 9529 $169($1_1, $8_1, $3_1, -298308542, -50975715); 9530 $169($16_1 + 32 | 0, $8_1, $3_1, -576792651, 1181916675); 9531 $13_1 = $16_1 + 16 | 0; 9532 $6_1 = $16_1; 9533 $20_1 = HEAP32[$6_1 + 56 >> 2]; 9534 $18_1 = HEAP32[$6_1 + 60 >> 2]; 9535 $9_1 = HEAP32[$6_1 + 44 >> 2]; 9536 $7_1 = $9_1 + HEAP32[$6_1 + 52 >> 2] | 0; 9537 $8_1 = HEAP32[$6_1 + 40 >> 2]; 9538 $5_1 = HEAP32[$6_1 + 48 >> 2]; 9539 $4_1 = $8_1 + $5_1 | 0; 9540 $11_1 = $4_1; 9541 $6_1 = $9_1; 9542 $7_1 = $4_1 >>> 0 < $5_1 >>> 0 ? $7_1 + 1 | 0 : $7_1; 9543 $10_1 = $7_1; 9544 $6_1 = ($6_1 | 0) == ($7_1 | 0) & $4_1 >>> 0 < $8_1 >>> 0 | $6_1 >>> 0 > $7_1 >>> 0; 9545 $4_1 = $18_1; 9546 $3_1 = $6_1 + $20_1 | 0; 9547 $4_1 = $3_1 >>> 0 < $6_1 >>> 0 ? $4_1 + 1 | 0 : $4_1; 9548 $21_1 = $3_1; 9549 $18_1 = $4_1; 9550 $2_1 = $3_1; 9551 $6_1 = 58; 9552 $7_1 = 26; 9553 if (($6_1 & 63) >>> 0 >= 32) { 9554 $5_1 = $2_1 << $7_1; 9555 $3_1 = 0; 9556 } else { 9557 $5_1 = (1 << $7_1) - 1 & $2_1 >>> 32 - $7_1 | $4_1 << $7_1; 9558 $3_1 = $2_1 << $7_1; 9559 } 9560 $1_1 = $5_1; 9561 $5_1 = $10_1; 9562 $4_1 = $11_1; 9563 $6_1 = 6; 9564 $7_1 = 6; 9565 if (($6_1 & 63) >>> 0 >= 32) { 9566 $2_1 = 0; 9567 $5_1 = $5_1 >>> $7_1 | 0; 9568 } else { 9569 $2_1 = $5_1 >>> $7_1 | 0; 9570 $5_1 = ((1 << $7_1) - 1 & $5_1) << 32 - $7_1 | $4_1 >>> $7_1; 9571 } 9572 $8_1 = $5_1 | $3_1; 9573 $9_1 = $1_1 | $2_1; 9574 $169($13_1, $8_1, $9_1, 10, 0); 9575 $1_1 = -324; 9576 $2_1 = $16_1; 9577 $4_1 = HEAP32[$2_1 + 24 >> 2]; 9578 $20_1 = HEAP32[$2_1 + 28 >> 2]; 9579 $5_1 = HEAP32[$2_1 + 20 >> 2]; 9580 $11_1 = HEAP32[$2_1 + 16 >> 2]; 9581 $2_1 = $11_1; 9582 $6_1 = -6; 9583 $7_1 = $2_1 - $6_1 | 0; 9584 $3_1 = $5_1 - (($2_1 >>> 0 < $6_1 >>> 0) + 2147483647 | 0) | 0; 9585 $2_1 = $5_1; 9586 $2_1 = ($3_1 | 0) == ($2_1 | 0) & $7_1 >>> 0 < $11_1 >>> 0 | $3_1 >>> 0 < $2_1 >>> 0; 9587 $4_1 = $4_1 + $2_1 | 0; 9588 $7_1 = $20_1; 9589 $7_1 = $2_1 >>> 0 > $4_1 >>> 0 ? $7_1 + 1 | 0 : $7_1; 9590 $3_1 = !$8_1 & ($9_1 | 0) == 1073741824; 9591 $2_1 = $3_1 ? 2 : $4_1; 9592 $7_1 = $3_1 ? 0 : $7_1; 9593 $6_1 = $2_1; 9594 $2_1 = $9_1; 9595 $10_1 = 1060997895; 9596 $3_1 = $10_1; 9597 $11_1 = $17_1 & 1 ^ 2072906513; 9598 $5_1 = ($2_1 | 0) == ($3_1 | 0) & $8_1 >>> 0 >= $11_1 >>> 0 | $3_1 >>> 0 < $2_1 >>> 0; 9599 $6_1 = $5_1 ? $6_1 : 0; 9600 $7_1 = $5_1 ? $7_1 : 0; 9601 $4_1 = $6_1; 9602 $2_1 = $3_1; 9603 $5_1 = $9_1 ^ -1; 9604 $14_1 = ($2_1 | 0) == ($5_1 | 0) & $11_1 >>> 0 > ($8_1 ^ -1) >>> 0 | $2_1 >>> 0 > $5_1 >>> 0; 9605 $6_1 = $14_1; 9606 $8_1 = $6_1 ? 0 : $4_1; 9607 $10_1 = $6_1 ? 0 : $7_1; 9608 $9_1 = $6_1; 9609 $4_1 = 0; 9610 $3_1 = $18_1; 9611 $6_1 = $21_1; 9612 $2_1 = 6; 9613 $7_1 = 6; 9614 if (($2_1 & 63) >>> 0 >= 32) { 9615 $5_1 = 0; 9616 $2_1 = $3_1 >>> $7_1 | 0; 9617 } else { 9618 $5_1 = $3_1 >>> $7_1 | 0; 9619 $2_1 = ((1 << $7_1) - 1 & $3_1) << 32 - $7_1 | $6_1 >>> $7_1; 9620 } 9621 $7_1 = $9_1 + $2_1 | 0; 9622 $4_1 = $4_1 + $5_1 | 0; 9623 $2_1 = __wasm_i64_mul($7_1, $2_1 >>> 0 > $7_1 >>> 0 ? $4_1 + 1 | 0 : $4_1, 10, 0); 9624 $6_1 = $8_1 + $2_1 | 0; 9625 $7_1 = $10_1 + i64toi32_i32$HIGH_BITS | 0; 9626 $8_1 = $6_1; 9627 $4_1 = $6_1; 9628 $5_1 = 232830; 9629 $7_1 = $2_1 >>> 0 > $4_1 >>> 0 ? $7_1 + 1 | 0 : $7_1; 9630 $9_1 = $7_1; 9631 if (($5_1 | 0) == ($7_1 | 0) & $4_1 >>> 0 <= 2764472319 | $5_1 >>> 0 > $7_1 >>> 0) { 9632 while (1) { 9633 $1_1 = $1_1 - 1 | 0; 9634 $8_1 = __wasm_i64_mul($8_1, $9_1, 10, 0); 9635 $2_1 = $8_1; 9636 $5_1 = -1530494976; 9637 $4_1 = i64toi32_i32$HIGH_BITS; 9638 $9_1 = $4_1; 9639 $7_1 = 232830; 9640 if (($4_1 | 0) < ($7_1 | 0)) { 9641 $2_1 = 1 9642 } else { 9643 $2_1 = $2_1 >>> 0 < $5_1 >>> 0 & ($4_1 | 0) <= ($7_1 | 0) 9644 } 9645 if ($2_1) { 9646 continue 9647 } 9648 break; 9649 } 9650 } 9651 $169($16_1, $8_1, $9_1, -1717986918, 429496729); 9652 $5_1 = $16_1; 9653 $11_1 = HEAP32[$5_1 + 8 >> 2]; 9654 $10_1 = HEAP32[$5_1 + 12 >> 2]; 9655 $5_1 = __wasm_i64_mul($11_1, $10_1, -10, -1); 9656 $6_1 = $9_1 + i64toi32_i32$HIGH_BITS | 0; 9657 $7_1 = $8_1; 9658 $3_1 = $7_1 + $5_1 | 0; 9659 $6_1 = $3_1 >>> 0 < $7_1 >>> 0 ? $6_1 + 1 | 0 : $6_1; 9660 $12_1 = ($3_1 | $6_1) != 0; 9661 $14_1 = $3_1; 9662 break block1; 9663 } 9664 $7_1 = $8_1; 9665 $23_1 = $7_1; 9666 $2_1 = $9_1; 9667 $20_1 = $2_1 | 1048576; 9668 $14_1 = $11_1 - 1075 | 0; 9669 $1_1 = Math_imul($14_1, 315653); 9670 block2 : { 9671 if (!($2_1 | $7_1)) { 9672 $1_1 = $1_1 - 131072 >> 20; 9673 $12_1 = 302 - $1_1 | 0; 9674 $13_1 = (($12_1 & 65535) >>> 0) / 28 | 0; 9675 $10_1 = $13_1 << 4; 9676 $2_1 = $10_1; 9677 $21_1 = HEAP32[$2_1 + 1058800 >> 2]; 9678 $18_1 = HEAP32[$2_1 + 1058804 >> 2]; 9679 $2_1 = ($12_1 - Math_imul($13_1, 28) & 65535) << 3; 9680 $17_1 = HEAP32[$2_1 + 1058568 >> 2]; 9681 $19_1 = HEAP32[$2_1 + 1058572 >> 2]; 9682 $169($16_1 + 128 | 0, $21_1, $18_1, $17_1, $19_1); 9683 $2_1 = $10_1; 9684 $8_1 = HEAP32[$2_1 + 1058792 >> 2]; 9685 $9_1 = HEAP32[$2_1 + 1058796 >> 2]; 9686 $169($16_1 + 144 | 0, $8_1, $9_1, $17_1, $19_1); 9687 $14_1 = $14_1 + (Math_imul($1_1, 16559509) + 16559509 >>> 16 | 0) | 0; 9688 $12_1 = $14_1 + 7 | 0; 9689 $2_1 = $16_1; 9690 $22_1 = HEAP32[$2_1 + 152 >> 2]; 9691 $13_1 = HEAP32[$2_1 + 156 >> 2]; 9692 $8_1 = __wasm_i64_mul($8_1, $9_1, $17_1, $19_1); 9693 $5_1 = HEAP32[$2_1 + 136 >> 2]; 9694 $4_1 = $8_1 + $5_1 | 0; 9695 $9_1 = i64toi32_i32$HIGH_BITS; 9696 $3_1 = $9_1 + HEAP32[$2_1 + 140 >> 2] | 0; 9697 $11_1 = $4_1; 9698 $2_1 = $9_1; 9699 $3_1 = $4_1 >>> 0 < $5_1 >>> 0 ? $3_1 + 1 | 0 : $3_1; 9700 $10_1 = $3_1; 9701 $2_1 = ($2_1 | 0) == ($3_1 | 0) & $4_1 >>> 0 < $8_1 >>> 0 | $3_1 >>> 0 < $2_1 >>> 0; 9702 $6_1 = $22_1 + $2_1 | 0; 9703 $4_1 = $13_1; 9704 $4_1 = $2_1 >>> 0 > $6_1 >>> 0 ? $4_1 + 1 | 0 : $4_1; 9705 $8_1 = $6_1; 9706 $7_1 = $6_1; 9707 $2_1 = 0; 9708 $5_1 = 0; 9709 $9_1 = $4_1; 9710 if (($5_1 | 0) < ($4_1 | 0)) { 9711 $2_1 = 1 9712 } else { 9713 $2_1 = $2_1 >>> 0 <= $7_1 >>> 0 & ($4_1 | 0) >= ($5_1 | 0) 9714 } 9715 if ($2_1) { 9716 $7_1 = $9_1; 9717 $2_1 = $8_1; 9718 $5_1 = 1; 9719 $3_1 = 1; 9720 if (($5_1 & 63) >>> 0 >= 32) { 9721 $4_1 = $2_1 << $3_1; 9722 $9_1 = 0; 9723 } else { 9724 $4_1 = (1 << $3_1) - 1 & $2_1 >>> 32 - $3_1 | $7_1 << $3_1; 9725 $9_1 = $2_1 << $3_1; 9726 } 9727 $6_1 = $4_1; 9728 $4_1 = $10_1; 9729 $7_1 = $11_1; 9730 $5_1 = 63; 9731 $3_1 = 31; 9732 if (($5_1 & 63) >>> 0 >= 32) { 9733 $2_1 = 0; 9734 $5_1 = $4_1 >>> $3_1 | 0; 9735 } else { 9736 $2_1 = $4_1 >>> $3_1 | 0; 9737 $5_1 = ((1 << $3_1) - 1 & $4_1) << 32 - $3_1 | $7_1 >>> $3_1; 9738 } 9739 $8_1 = $5_1 | $9_1; 9740 $9_1 = $2_1 | $6_1; 9741 $7_1 = $10_1; 9742 $2_1 = $11_1; 9743 $5_1 = 1; 9744 $3_1 = 1; 9745 if (($5_1 & 63) >>> 0 >= 32) { 9746 $4_1 = $2_1 << $3_1; 9747 $10_1 = 0; 9748 } else { 9749 $4_1 = (1 << $3_1) - 1 & $2_1 >>> 32 - $3_1 | $7_1 << $3_1; 9750 $10_1 = $2_1 << $3_1; 9751 } 9752 $6_1 = $4_1; 9753 $5_1 = __wasm_i64_mul($17_1, $19_1, $21_1, $18_1); 9754 $4_1 = i64toi32_i32$HIGH_BITS; 9755 $7_1 = $5_1; 9756 $5_1 = 63; 9757 $3_1 = 31; 9758 if (($5_1 & 63) >>> 0 >= 32) { 9759 $2_1 = 0; 9760 $5_1 = $4_1 >>> $3_1 | 0; 9761 } else { 9762 $2_1 = $4_1 >>> $3_1 | 0; 9763 $5_1 = ((1 << $3_1) - 1 & $4_1) << 32 - $3_1 | $7_1 >>> $3_1; 9764 } 9765 $11_1 = $5_1 | $10_1; 9766 $10_1 = $2_1 | $6_1; 9767 } 9768 $7_1 = $20_1; 9769 $2_1 = $23_1; 9770 $5_1 = $12_1; 9771 $3_1 = $5_1 & 31; 9772 $6_1 = $16_1 + 96 | 0; 9773 if (($5_1 & 63) >>> 0 >= 32) { 9774 $4_1 = $2_1 << $3_1; 9775 $17_1 = 0; 9776 } else { 9777 $4_1 = (1 << $3_1) - 1 & $2_1 >>> 32 - $3_1 | $7_1 << $3_1; 9778 $17_1 = $2_1 << $3_1; 9779 } 9780 $169($6_1, $8_1, $9_1, $17_1, $4_1); 9781 $7_1 = $11_1; 9782 $12_1 = 292 - $1_1 | 0; 9783 $5_1 = HEAP32[($12_1 >>> 3 & 536870908) + 1059160 >> 2] >>> $12_1 & 1; 9784 $169($16_1 + 112 | 0, $7_1 - $5_1 | 0, $10_1 - ($5_1 >>> 0 > $7_1 >>> 0) | 0, $17_1, $4_1); 9785 $13_1 = $16_1 + 80 | 0; 9786 $2_1 = $16_1; 9787 $20_1 = HEAP32[$2_1 + 104 >> 2]; 9788 $18_1 = HEAP32[$2_1 + 108 >> 2]; 9789 $11_1 = HEAP32[$2_1 + 120 >> 2]; 9790 $5_1 = HEAP32[$2_1 + 96 >> 2]; 9791 $4_1 = $11_1 + $5_1 | 0; 9792 $10_1 = HEAP32[$2_1 + 124 >> 2]; 9793 $3_1 = $10_1 + HEAP32[$2_1 + 100 >> 2] | 0; 9794 $17_1 = $4_1; 9795 $2_1 = $10_1; 9796 $3_1 = $4_1 >>> 0 < $5_1 >>> 0 ? $3_1 + 1 | 0 : $3_1; 9797 $19_1 = $3_1; 9798 $2_1 = ($2_1 | 0) == ($3_1 | 0) & $4_1 >>> 0 < $11_1 >>> 0 | $3_1 >>> 0 < $2_1 >>> 0; 9799 $4_1 = $18_1; 9800 $7_1 = $2_1 + $20_1 | 0; 9801 $4_1 = $7_1 >>> 0 < $2_1 >>> 0 ? $4_1 + 1 | 0 : $4_1; 9802 $21_1 = $7_1; 9803 $18_1 = $4_1; 9804 $6_1 = $7_1; 9805 $2_1 = 58; 9806 $3_1 = 26; 9807 if (($2_1 & 63) >>> 0 >= 32) { 9808 $5_1 = $6_1 << $3_1; 9809 $10_1 = 0; 9810 } else { 9811 $5_1 = (1 << $3_1) - 1 & $6_1 >>> 32 - $3_1 | $4_1 << $3_1; 9812 $10_1 = $6_1 << $3_1; 9813 } 9814 $7_1 = $5_1; 9815 $5_1 = $19_1; 9816 $4_1 = $17_1; 9817 $2_1 = 6; 9818 $3_1 = 6; 9819 if (($2_1 & 63) >>> 0 >= 32) { 9820 $6_1 = 0; 9821 $2_1 = $5_1 >>> $3_1 | 0; 9822 } else { 9823 $6_1 = $5_1 >>> $3_1 | 0; 9824 $2_1 = ((1 << $3_1) - 1 & $5_1) << 32 - $3_1 | $4_1 >>> $3_1; 9825 } 9826 $11_1 = $2_1 | $10_1; 9827 $10_1 = $6_1 | $7_1; 9828 $169($13_1, $11_1, $10_1, 10, 0); 9829 $20_1 = $16_1 - -64 | 0; 9830 $7_1 = $10_1; 9831 $5_1 = $9_1; 9832 $6_1 = $8_1; 9833 $2_1 = 0 - $14_1 | 0; 9834 $3_1 = $2_1 & 31; 9835 if (($2_1 & 63) >>> 0 >= 32) { 9836 $4_1 = 0; 9837 $8_1 = $5_1 >>> $3_1 | 0; 9838 } else { 9839 $4_1 = $5_1 >>> $3_1 | 0; 9840 $8_1 = ((1 << $3_1) - 1 & $5_1) << 32 - $3_1 | $6_1 >>> $3_1; 9841 } 9842 $5_1 = $8_1; 9843 $9_1 = $4_1; 9844 $2_1 = 1; 9845 $3_1 = 1; 9846 if (($2_1 & 63) >>> 0 >= 32) { 9847 $6_1 = 0; 9848 $17_1 = $4_1 >>> $3_1 | 0; 9849 } else { 9850 $6_1 = $4_1 >>> $3_1 | 0; 9851 $17_1 = ((1 << $3_1) - 1 & $4_1) << 32 - $3_1 | $5_1 >>> $3_1; 9852 } 9853 $2_1 = $17_1; 9854 $4_1 = $11_1; 9855 $5_1 = $6_1; 9856 $169($20_1, $4_1 - $2_1 | 0, $7_1 - ($6_1 + ($2_1 >>> 0 > $4_1 >>> 0) | 0) | 0, 10, 0); 9857 $6_1 = $10_1 ^ -1; 9858 $7_1 = $9_1; 9859 $13_1 = ($6_1 | 0) == ($7_1 | 0) & $8_1 >>> 0 > ($4_1 ^ -1) >>> 0 | $6_1 >>> 0 < $7_1 >>> 0; 9860 $4_1 = $10_1; 9861 $12_1 = $13_1 | (($5_1 | 0) == ($4_1 | 0) & $11_1 >>> 0 < $2_1 >>> 0 | $4_1 >>> 0 < $5_1 >>> 0); 9862 $6_1 = $16_1; 9863 $4_1 = HEAP32[$6_1 + 88 >> 2]; 9864 $2_1 = HEAP32[$6_1 + 84 >> 2]; 9865 $8_1 = HEAP32[$6_1 + 80 >> 2]; 9866 $7_1 = -2; 9867 $5_1 = $8_1 + $7_1 | 0; 9868 $3_1 = $2_1 + 2147483647 | 0; 9869 $3_1 = $5_1 >>> 0 < $7_1 >>> 0 ? $3_1 + 1 | 0 : $3_1; 9870 $6_1 = ($2_1 | 0) == ($3_1 | 0) & $5_1 >>> 0 < $8_1 >>> 0 | $3_1 >>> 0 < $2_1 >>> 0; 9871 $4_1 = $4_1 + $6_1 | 0; 9872 $14_1 = $4_1 & 255; 9873 $2_1 = $16_1; 9874 $10_1 = HEAP32[$2_1 + 72 >> 2]; 9875 $5_1 = HEAP32[$2_1 + 68 >> 2]; 9876 $8_1 = HEAP32[$2_1 + 64 >> 2]; 9877 $2_1 = $8_1; 9878 $6_1 = 2; 9879 $7_1 = $2_1 - $6_1 | 0; 9880 $4_1 = $5_1 - ($2_1 >>> 0 < $6_1 >>> 0) | 0; 9881 $2_1 = $5_1; 9882 $2_1 = ($4_1 | 0) == ($2_1 | 0) & $7_1 >>> 0 < $8_1 >>> 0 | $2_1 >>> 0 > $4_1 >>> 0; 9883 $7_1 = $2_1 + $10_1 | 0; 9884 $10_1 = $7_1 & 255; 9885 $14_1 = $10_1 >>> 0 < $14_1 >>> 0 ? $14_1 : $10_1; 9886 $7_1 = $13_1; 9887 $9_1 = 0; 9888 $3_1 = $18_1; 9889 $5_1 = $21_1; 9890 $2_1 = 6; 9891 $4_1 = 6; 9892 if (($2_1 & 63) >>> 0 >= 32) { 9893 $6_1 = 0; 9894 $2_1 = $3_1 >>> $4_1 | 0; 9895 } else { 9896 $6_1 = $3_1 >>> $4_1 | 0; 9897 $2_1 = ((1 << $4_1) - 1 & $3_1) << 32 - $4_1 | $5_1 >>> $4_1; 9898 } 9899 $4_1 = $7_1 + $2_1 | 0; 9900 $7_1 = $6_1 + $9_1 | 0; 9901 $11_1 = $4_1; 9902 $3_1 = $2_1 >>> 0 > $4_1 >>> 0 ? $7_1 + 1 | 0 : $7_1; 9903 break block2; 9904 } 9905 $1_1 = $1_1 >> 20; 9906 $12_1 = 302 - $1_1 | 0; 9907 $13_1 = (($12_1 & 65535) >>> 0) / 28 | 0; 9908 $10_1 = $13_1 << 4; 9909 $6_1 = $10_1; 9910 $24_1 = HEAP32[$6_1 + 1058800 >> 2]; 9911 $25_1 = HEAP32[$6_1 + 1058804 >> 2]; 9912 $6_1 = ($12_1 - Math_imul($13_1, 28) & 65535) << 3; 9913 $21_1 = HEAP32[$6_1 + 1058568 >> 2]; 9914 $18_1 = HEAP32[$6_1 + 1058572 >> 2]; 9915 $169($16_1 + 208 | 0, $24_1, $25_1, $21_1, $18_1); 9916 $6_1 = $10_1; 9917 $8_1 = HEAP32[$6_1 + 1058792 >> 2]; 9918 $9_1 = HEAP32[$6_1 + 1058796 >> 2]; 9919 $169($16_1 + 224 | 0, $8_1, $9_1, $21_1, $18_1); 9920 $14_1 = $14_1 + (Math_imul($1_1, 16559509) + 16559509 >>> 16 | 0) | 0; 9921 $12_1 = $14_1 + 7 | 0; 9922 $6_1 = $16_1; 9923 $22_1 = HEAP32[$6_1 + 232 >> 2]; 9924 $13_1 = HEAP32[$6_1 + 236 >> 2]; 9925 $8_1 = __wasm_i64_mul($8_1, $9_1, $21_1, $18_1); 9926 $5_1 = $8_1; 9927 $9_1 = i64toi32_i32$HIGH_BITS; 9928 $4_1 = $9_1 + HEAP32[$6_1 + 220 >> 2] | 0; 9929 $2_1 = HEAP32[$6_1 + 216 >> 2]; 9930 $5_1 = $5_1 + $2_1 | 0; 9931 $11_1 = $5_1; 9932 $6_1 = $9_1; 9933 $4_1 = $2_1 >>> 0 > $5_1 >>> 0 ? $4_1 + 1 | 0 : $4_1; 9934 $10_1 = $4_1; 9935 $6_1 = ($6_1 | 0) == ($4_1 | 0) & $5_1 >>> 0 < $8_1 >>> 0 | $4_1 >>> 0 < $6_1 >>> 0; 9936 $5_1 = $13_1; 9937 $7_1 = $6_1 + $22_1 | 0; 9938 $5_1 = $7_1 >>> 0 < $6_1 >>> 0 ? $5_1 + 1 | 0 : $5_1; 9939 $8_1 = $7_1; 9940 $3_1 = $7_1; 9941 $6_1 = 0; 9942 $2_1 = 0; 9943 $9_1 = $5_1; 9944 if (($2_1 | 0) < ($5_1 | 0)) { 9945 $2_1 = 1 9946 } else { 9947 $2_1 = ($2_1 | 0) <= ($5_1 | 0) & $3_1 >>> 0 >= $6_1 >>> 0 9948 } 9949 if ($2_1) { 9950 $3_1 = $9_1; 9951 $6_1 = $8_1; 9952 $2_1 = 1; 9953 $4_1 = 1; 9954 if (($2_1 & 63) >>> 0 >= 32) { 9955 $5_1 = $6_1 << $4_1; 9956 $9_1 = 0; 9957 } else { 9958 $5_1 = (1 << $4_1) - 1 & $6_1 >>> 32 - $4_1 | $3_1 << $4_1; 9959 $9_1 = $6_1 << $4_1; 9960 } 9961 $7_1 = $5_1; 9962 $5_1 = $10_1; 9963 $3_1 = $11_1; 9964 $2_1 = 63; 9965 $4_1 = 31; 9966 if (($2_1 & 63) >>> 0 >= 32) { 9967 $6_1 = 0; 9968 $2_1 = $5_1 >>> $4_1 | 0; 9969 } else { 9970 $6_1 = $5_1 >>> $4_1 | 0; 9971 $2_1 = ((1 << $4_1) - 1 & $5_1) << 32 - $4_1 | $3_1 >>> $4_1; 9972 } 9973 $8_1 = $2_1 | $9_1; 9974 $9_1 = $6_1 | $7_1; 9975 $3_1 = $10_1; 9976 $6_1 = $11_1; 9977 $2_1 = 1; 9978 $4_1 = 1; 9979 if (($2_1 & 63) >>> 0 >= 32) { 9980 $5_1 = $6_1 << $4_1; 9981 $10_1 = 0; 9982 } else { 9983 $5_1 = (1 << $4_1) - 1 & $6_1 >>> 32 - $4_1 | $3_1 << $4_1; 9984 $10_1 = $6_1 << $4_1; 9985 } 9986 $7_1 = $5_1; 9987 $6_1 = __wasm_i64_mul($21_1, $18_1, $24_1, $25_1); 9988 $5_1 = i64toi32_i32$HIGH_BITS; 9989 $3_1 = $6_1; 9990 $2_1 = 63; 9991 $4_1 = 31; 9992 if (($2_1 & 63) >>> 0 >= 32) { 9993 $6_1 = 0; 9994 $2_1 = $5_1 >>> $4_1 | 0; 9995 } else { 9996 $6_1 = $5_1 >>> $4_1 | 0; 9997 $2_1 = ((1 << $4_1) - 1 & $5_1) << 32 - $4_1 | $3_1 >>> $4_1; 9998 } 9999 $11_1 = $2_1 | $10_1; 10000 $10_1 = $6_1 | $7_1; 10001 } 10002 $3_1 = $20_1; 10003 $6_1 = $23_1; 10004 $2_1 = $12_1; 10005 $4_1 = $2_1 & 31; 10006 $7_1 = $16_1 + 176 | 0; 10007 if (($2_1 & 63) >>> 0 >= 32) { 10008 $5_1 = $6_1 << $4_1; 10009 $21_1 = 0; 10010 } else { 10011 $5_1 = (1 << $4_1) - 1 & $6_1 >>> 32 - $4_1 | $3_1 << $4_1; 10012 $21_1 = $6_1 << $4_1; 10013 } 10014 $169($7_1, $8_1, $9_1, $21_1, $5_1); 10015 $3_1 = $11_1; 10016 $12_1 = 292 - $1_1 | 0; 10017 $2_1 = HEAP32[($12_1 >>> 3 & 536870908) + 1059160 >> 2] >>> $12_1 & 1; 10018 $169($16_1 + 192 | 0, $3_1 - $2_1 | 0, $10_1 - ($3_1 >>> 0 < $2_1 >>> 0) | 0, $21_1, $5_1); 10019 $22_1 = $16_1 + 160 | 0; 10020 $6_1 = $16_1; 10021 $13_1 = HEAP32[$6_1 + 184 >> 2]; 10022 $20_1 = HEAP32[$6_1 + 188 >> 2]; 10023 $10_1 = HEAP32[$6_1 + 204 >> 2]; 10024 $4_1 = $10_1 + HEAP32[$6_1 + 180 >> 2] | 0; 10025 $2_1 = HEAP32[$6_1 + 176 >> 2]; 10026 $11_1 = HEAP32[$6_1 + 200 >> 2]; 10027 $5_1 = $2_1 + $11_1 | 0; 10028 $21_1 = $5_1; 10029 $6_1 = $10_1; 10030 $4_1 = $2_1 >>> 0 > $5_1 >>> 0 ? $4_1 + 1 | 0 : $4_1; 10031 $18_1 = $4_1; 10032 $6_1 = ($6_1 | 0) == ($4_1 | 0) & $5_1 >>> 0 < $11_1 >>> 0 | $4_1 >>> 0 < $6_1 >>> 0; 10033 $3_1 = $6_1 + $13_1 | 0; 10034 $5_1 = $20_1; 10035 $23_1 = $3_1; 10036 $5_1 = $3_1 >>> 0 < $6_1 >>> 0 ? $5_1 + 1 | 0 : $5_1; 10037 $20_1 = $5_1; 10038 $7_1 = $3_1; 10039 $6_1 = 58; 10040 $4_1 = 26; 10041 if (($6_1 & 63) >>> 0 >= 32) { 10042 $2_1 = $3_1 << $4_1; 10043 $10_1 = 0; 10044 } else { 10045 $2_1 = (1 << $4_1) - 1 & $7_1 >>> 32 - $4_1 | $5_1 << $4_1; 10046 $10_1 = $7_1 << $4_1; 10047 } 10048 $3_1 = $2_1; 10049 $2_1 = $18_1; 10050 $5_1 = $21_1; 10051 $6_1 = 6; 10052 $4_1 = 6; 10053 $18_1 = $22_1; 10054 if (($6_1 & 63) >>> 0 >= 32) { 10055 $7_1 = 0; 10056 $2_1 = $2_1 >>> $4_1 | 0; 10057 } else { 10058 $7_1 = $2_1 >>> $4_1 | 0; 10059 $2_1 = ((1 << $4_1) - 1 & $2_1) << 32 - $4_1 | $5_1 >>> $4_1; 10060 } 10061 $11_1 = $2_1 | $10_1; 10062 $10_1 = $3_1 | $7_1; 10063 $169($18_1, $11_1, $10_1, 10, 0); 10064 $19_1 = ($17_1 ^ -1) & 1; 10065 $3_1 = 0; 10066 $7_1 = $9_1; 10067 $5_1 = $8_1; 10068 $6_1 = 0 - $14_1 | 0; 10069 $4_1 = $6_1 & 31; 10070 if (($6_1 & 63) >>> 0 >= 32) { 10071 $2_1 = 0; 10072 $6_1 = $7_1 >>> $4_1 | 0; 10073 } else { 10074 $2_1 = $7_1 >>> $4_1 | 0; 10075 $6_1 = ((1 << $4_1) - 1 & $7_1) << 32 - $4_1 | $5_1 >>> $4_1; 10076 } 10077 $3_1 = $3_1 + $2_1 | 0; 10078 $4_1 = $6_1 + $19_1 | 0; 10079 $3_1 = $4_1 >>> 0 < $6_1 >>> 0 ? $3_1 + 1 | 0 : $3_1; 10080 $2_1 = $10_1 ^ -1; 10081 $13_1 = ($3_1 | 0) == ($2_1 | 0) & $4_1 >>> 0 > ($11_1 ^ -1) >>> 0 | $3_1 >>> 0 > $2_1 >>> 0; 10082 $7_1 = $10_1; 10083 $12_1 = $13_1 | (($7_1 | 0) == ($3_1 | 0) & $4_1 >>> 0 > $11_1 >>> 0 | $3_1 >>> 0 > $7_1 >>> 0); 10084 $2_1 = $16_1; 10085 $3_1 = HEAP32[$2_1 + 168 >> 2]; 10086 $6_1 = HEAP32[$2_1 + 164 >> 2]; 10087 $8_1 = HEAP32[$2_1 + 160 >> 2]; 10088 $2_1 = $8_1; 10089 $7_1 = -6; 10090 $5_1 = $2_1 - $7_1 | 0; 10091 $4_1 = $6_1 - (($2_1 >>> 0 < $7_1 >>> 0) + 2147483647 | 0) | 0; 10092 $2_1 = $6_1; 10093 $2_1 = ($4_1 | 0) == ($2_1 | 0) & $5_1 >>> 0 < $8_1 >>> 0 | $2_1 >>> 0 > $4_1 >>> 0; 10094 $3_1 = $3_1 + $2_1 | 0; 10095 $14_1 = !$11_1 & ($10_1 | 0) == 1073741824 ? 2 : $3_1; 10096 $9_1 = $13_1; 10097 $3_1 = 0; 10098 $6_1 = $20_1; 10099 $2_1 = $23_1; 10100 $7_1 = 6; 10101 $4_1 = 6; 10102 if (($7_1 & 63) >>> 0 >= 32) { 10103 $5_1 = 0; 10104 $7_1 = $6_1 >>> $4_1 | 0; 10105 } else { 10106 $5_1 = $6_1 >>> $4_1 | 0; 10107 $7_1 = ((1 << $4_1) - 1 & $6_1) << 32 - $4_1 | $2_1 >>> $4_1; 10108 } 10109 $3_1 = $3_1 + $5_1 | 0; 10110 $4_1 = $7_1 + $9_1 | 0; 10111 $3_1 = $7_1 >>> 0 > $4_1 >>> 0 ? $3_1 + 1 | 0 : $3_1; 10112 $11_1 = $4_1; 10113 } 10114 $10_1 = $3_1; 10115 $12_1 = !$12_1; 10116 } 10117 $21_1 = __wasm_i64_udiv($11_1, $10_1, 1e8, 0); 10118 $8_1 = $21_1; 10119 $18_1 = i64toi32_i32$HIGH_BITS; 10120 $9_1 = 0; 10121 $5_1 = __wasm_i64_mul($8_1, $9_1, 109951163, 0); 10122 $6_1 = i64toi32_i32$HIGH_BITS; 10123 $3_1 = $5_1; 10124 $7_1 = 40; 10125 $2_1 = 8; 10126 if (($7_1 & 63) >>> 0 >= 32) { 10127 $5_1 = 0; 10128 $2_1 = $6_1 >>> $2_1 | 0; 10129 } else { 10130 $5_1 = $6_1 >>> $2_1 | 0; 10131 $2_1 = ((1 << $2_1) - 1 & $6_1) << 32 - $2_1 | $3_1 >>> $2_1; 10132 } 10133 $6_1 = __wasm_i64_mul($2_1, $5_1, -1e4, 0); 10134 $4_1 = i64toi32_i32$HIGH_BITS + $9_1 | 0; 10135 $7_1 = $8_1; 10136 $2_1 = $7_1 + $6_1 | 0; 10137 $4_1 = $2_1 >>> 0 < $7_1 >>> 0 ? $4_1 + 1 | 0 : $4_1; 10138 $8_1 = $2_1; 10139 $9_1 = $4_1; 10140 $5_1 = __wasm_i64_mul($2_1, $4_1, 5243, 0); 10141 $4_1 = i64toi32_i32$HIGH_BITS; 10142 $7_1 = 19; 10143 $3_1 = 19; 10144 if (($7_1 & 63) >>> 0 >= 32) { 10145 $6_1 = 0; 10146 $2_1 = $4_1 >>> $3_1 | 0; 10147 } else { 10148 $6_1 = $4_1 >>> $3_1 | 0; 10149 $2_1 = ((1 << $3_1) - 1 & $4_1) << 32 - $3_1 | $5_1 >>> $3_1; 10150 } 10151 $6_1 = __wasm_i64_mul($2_1 & 127, $6_1 & 127, 65436, 0); 10152 $2_1 = $9_1 + i64toi32_i32$HIGH_BITS | 0; 10153 $7_1 = $8_1; 10154 $3_1 = $7_1 + $6_1 | 0; 10155 $2_1 = $3_1 >>> 0 < $7_1 >>> 0 ? $2_1 + 1 | 0 : $2_1; 10156 $8_1 = $3_1; 10157 $9_1 = $2_1; 10158 $5_1 = __wasm_i64_mul($3_1, $2_1, 103, 0); 10159 $2_1 = i64toi32_i32$HIGH_BITS; 10160 $7_1 = 10; 10161 $4_1 = 10; 10162 if (($7_1 & 63) >>> 0 >= 32) { 10163 $6_1 = 0; 10164 $2_1 = $2_1 >>> $4_1 | 0; 10165 } else { 10166 $6_1 = $2_1 >>> $4_1 | 0; 10167 $2_1 = ((1 << $4_1) - 1 & $2_1) << 32 - $4_1 | $5_1 >>> $4_1; 10168 } 10169 $6_1 = __wasm_i64_mul($2_1 & 983055, $6_1 & 983055, 246, 0); 10170 $3_1 = i64toi32_i32$HIGH_BITS + $9_1 | 0; 10171 $7_1 = $8_1; 10172 $4_1 = $7_1 + $6_1 | 0; 10173 $3_1 = $4_1 >>> 0 < $7_1 >>> 0 ? $3_1 + 1 | 0 : $3_1; 10174 $8_1 = $4_1; 10175 $9_1 = $3_1; 10176 $5_1 = $4_1; 10177 $7_1 = 56; 10178 $2_1 = 24; 10179 if (($7_1 & 63) >>> 0 >= 32) { 10180 $6_1 = $4_1 << $2_1; 10181 $19_1 = 0; 10182 } else { 10183 $6_1 = (1 << $2_1) - 1 & $5_1 >>> 32 - $2_1 | $3_1 << $2_1; 10184 $19_1 = $5_1 << $2_1; 10185 } 10186 $4_1 = $6_1; 10187 $5_1 = 0; 10188 $6_1 = $8_1 & 65280; 10189 $7_1 = 40; 10190 $2_1 = 8; 10191 if (($7_1 & 63) >>> 0 >= 32) { 10192 $3_1 = $6_1 << $2_1; 10193 $2_1 = 0; 10194 } else { 10195 $3_1 = (1 << $2_1) - 1 & $6_1 >>> 32 - $2_1 | $5_1 << $2_1; 10196 $2_1 = $6_1 << $2_1; 10197 } 10198 $17_1 = $2_1 | $19_1; 10199 $20_1 = $3_1 | $4_1; 10200 $6_1 = $8_1 & 16711680; 10201 $7_1 = 24; 10202 $2_1 = 24; 10203 if (($7_1 & 63) >>> 0 >= 32) { 10204 $3_1 = $6_1 << $2_1; 10205 $19_1 = 0; 10206 } else { 10207 $3_1 = (1 << $2_1) - 1 & $6_1 >>> 32 - $2_1 | $5_1 << $2_1; 10208 $19_1 = $6_1 << $2_1; 10209 } 10210 $4_1 = $3_1; 10211 $6_1 = 0; 10212 $3_1 = $8_1 & -16777216; 10213 $7_1 = 8; 10214 $2_1 = 8; 10215 if (($7_1 & 63) >>> 0 >= 32) { 10216 $5_1 = $3_1 << $2_1; 10217 $6_1 = 0; 10218 } else { 10219 $5_1 = (1 << $2_1) - 1 & $3_1 >>> 32 - $2_1 | $6_1 << $2_1; 10220 $6_1 = $3_1 << $2_1; 10221 } 10222 $22_1 = $6_1 | $19_1 | $17_1; 10223 $13_1 = $20_1 | ($4_1 | $5_1); 10224 $6_1 = $9_1; 10225 $3_1 = $8_1; 10226 if (($7_1 & 63) >>> 0 >= 32) { 10227 $2_1 = $6_1 >>> $2_1 | 0 10228 } else { 10229 $2_1 = ((1 << $2_1) - 1 & $6_1) << 32 - $2_1 | $3_1 >>> $2_1 10230 } 10231 $19_1 = $2_1 & -16777216; 10232 $4_1 = 0; 10233 $3_1 = $9_1; 10234 $5_1 = $8_1; 10235 $7_1 = 24; 10236 $2_1 = 24; 10237 if (($7_1 & 63) >>> 0 >= 32) { 10238 $2_1 = $3_1 >>> $2_1 | 0 10239 } else { 10240 $2_1 = ((1 << $2_1) - 1 & $3_1) << 32 - $2_1 | $5_1 >>> $2_1 10241 } 10242 $17_1 = $2_1 & 16711680 | $19_1; 10243 $20_1 = $4_1; 10244 $7_1 = 40; 10245 $2_1 = 8; 10246 if (($7_1 & 63) >>> 0 >= 32) { 10247 $2_1 = $3_1 >>> $2_1 | 0 10248 } else { 10249 $2_1 = ((1 << $2_1) - 1 & $3_1) << 32 - $2_1 | $5_1 >>> $2_1 10250 } 10251 $19_1 = $2_1 & 65280; 10252 $5_1 = $9_1; 10253 $6_1 = $8_1; 10254 $7_1 = 56; 10255 $2_1 = 24; 10256 if (($7_1 & 63) >>> 0 >= 32) { 10257 $3_1 = 0; 10258 $2_1 = $5_1 >>> $2_1 | 0; 10259 } else { 10260 $3_1 = $5_1 >>> $2_1 | 0; 10261 $2_1 = ((1 << $2_1) - 1 & $5_1) << 32 - $2_1 | $6_1 >>> $2_1; 10262 } 10263 $17_1 = $2_1 | $19_1 | $17_1 | $22_1; 10264 $19_1 = $13_1 | ($3_1 | $4_1 | $20_1); 10265 $6_1 = 232830; 10266 $3_1 = $10_1; 10267 $13_1 = ($6_1 | 0) == ($3_1 | 0) & $11_1 >>> 0 > 2764472319 | $3_1 >>> 0 > $6_1 >>> 0; 10268 $1_1 = ($13_1 + $1_1 | 0) + 15 | 0; 10269 $7_1 = $11_1; 10270 $6_1 = __wasm_i64_mul($21_1, $18_1, 1e8, 0); 10271 $8_1 = $7_1 - $6_1 | 0; 10272 $5_1 = $8_1; 10273 $4_1 = $3_1 - (i64toi32_i32$HIGH_BITS + ($6_1 >>> 0 > $7_1 >>> 0) | 0) | 0; 10274 $9_1 = $4_1; 10275 if ($5_1 | $4_1) { 10276 break block3 10277 } 10278 $8_1 = 808464432; 10279 $9_1 = 808464432; 10280 $5_1 = $19_1; 10281 $6_1 = $17_1; 10282 $7_1 = 1; 10283 $3_1 = 1; 10284 if (($7_1 & 63) >>> 0 >= 32) { 10285 $4_1 = $6_1 << $3_1; 10286 $2_1 = 0; 10287 } else { 10288 $4_1 = (1 << $3_1) - 1 & $6_1 >>> 32 - $3_1 | $5_1 << $3_1; 10289 $2_1 = $6_1 << $3_1; 10290 } 10291 $7_1 = Math_clz32($4_1); 10292 $10_1 = 70 - (($7_1 | 0) == 32 ? Math_clz32($2_1 | 1) + 32 | 0 : $7_1) >>> 3 | 0; 10293 break block4; 10294 } 10295 HEAP8[$15_1 + 2 | 0] = 48; 10296 $1_1 = 11824; 10297 HEAP8[$15_1 | 0] = $1_1; 10298 HEAP8[$15_1 + 1 | 0] = $1_1 >>> 8; 10299 $1_1 = $15_1 + 3 | 0; 10300 break block5; 10301 } 10302 $5_1 = __wasm_i64_mul($8_1, $9_1, 109951163, 0); 10303 $4_1 = i64toi32_i32$HIGH_BITS; 10304 $7_1 = 40; 10305 $3_1 = 8; 10306 if (($7_1 & 63) >>> 0 >= 32) { 10307 $6_1 = 0; 10308 $2_1 = $4_1 >>> $3_1 | 0; 10309 } else { 10310 $6_1 = $4_1 >>> $3_1 | 0; 10311 $2_1 = ((1 << $3_1) - 1 & $4_1) << 32 - $3_1 | $5_1 >>> $3_1; 10312 } 10313 $4_1 = __wasm_i64_mul($2_1, $6_1, -1e4, 0); 10314 $2_1 = $9_1 + i64toi32_i32$HIGH_BITS | 0; 10315 $7_1 = $8_1; 10316 $3_1 = $7_1 + $4_1 | 0; 10317 $2_1 = $3_1 >>> 0 < $7_1 >>> 0 ? $2_1 + 1 | 0 : $2_1; 10318 $8_1 = $3_1; 10319 $9_1 = $2_1; 10320 $5_1 = __wasm_i64_mul($3_1, $2_1, 5243, 0); 10321 $2_1 = i64toi32_i32$HIGH_BITS; 10322 $6_1 = $5_1; 10323 $7_1 = 19; 10324 $5_1 = 19; 10325 if (($7_1 & 63) >>> 0 >= 32) { 10326 $4_1 = 0; 10327 $2_1 = $2_1 >>> $5_1 | 0; 10328 } else { 10329 $4_1 = $2_1 >>> $5_1 | 0; 10330 $2_1 = ((1 << $5_1) - 1 & $2_1) << 32 - $5_1 | $6_1 >>> $5_1; 10331 } 10332 $4_1 = __wasm_i64_mul($2_1 & 127, $4_1 & 127, 65436, 0); 10333 $3_1 = i64toi32_i32$HIGH_BITS + $9_1 | 0; 10334 $7_1 = $8_1; 10335 $5_1 = $7_1 + $4_1 | 0; 10336 $3_1 = $5_1 >>> 0 < $7_1 >>> 0 ? $3_1 + 1 | 0 : $3_1; 10337 $8_1 = $5_1; 10338 $9_1 = $3_1; 10339 $5_1 = __wasm_i64_mul($5_1, $3_1, 103, 0); 10340 $3_1 = i64toi32_i32$HIGH_BITS; 10341 $6_1 = $5_1; 10342 $7_1 = 10; 10343 $2_1 = 10; 10344 if (($7_1 & 63) >>> 0 >= 32) { 10345 $4_1 = 0; 10346 $2_1 = $3_1 >>> $2_1 | 0; 10347 } else { 10348 $4_1 = $3_1 >>> $2_1 | 0; 10349 $2_1 = ((1 << $2_1) - 1 & $3_1) << 32 - $2_1 | $6_1 >>> $2_1; 10350 } 10351 $4_1 = __wasm_i64_mul($2_1 & 983055, $4_1 & 983055, 246, 0); 10352 $5_1 = $9_1 + i64toi32_i32$HIGH_BITS | 0; 10353 $7_1 = $8_1; 10354 $2_1 = $7_1 + $4_1 | 0; 10355 $5_1 = $2_1 >>> 0 < $7_1 >>> 0 ? $5_1 + 1 | 0 : $5_1; 10356 $8_1 = $2_1; 10357 $9_1 = $5_1; 10358 $6_1 = $2_1; 10359 $7_1 = 56; 10360 $3_1 = 24; 10361 if (($7_1 & 63) >>> 0 >= 32) { 10362 $4_1 = $2_1 << $3_1; 10363 $10_1 = 0; 10364 } else { 10365 $4_1 = (1 << $3_1) - 1 & $6_1 >>> 32 - $3_1 | $5_1 << $3_1; 10366 $10_1 = $6_1 << $3_1; 10367 } 10368 $2_1 = $4_1; 10369 $6_1 = 0; 10370 $4_1 = $8_1 & 65280; 10371 $7_1 = 40; 10372 $3_1 = 8; 10373 if (($7_1 & 63) >>> 0 >= 32) { 10374 $5_1 = $4_1 << $3_1; 10375 $7_1 = 0; 10376 } else { 10377 $5_1 = (1 << $3_1) - 1 & $4_1 >>> 32 - $3_1 | $6_1 << $3_1; 10378 $7_1 = $4_1 << $3_1; 10379 } 10380 $11_1 = $7_1 | $10_1; 10381 $18_1 = $2_1 | $5_1; 10382 $4_1 = $8_1 & 16711680; 10383 $7_1 = 24; 10384 $3_1 = 24; 10385 if (($7_1 & 63) >>> 0 >= 32) { 10386 $5_1 = $4_1 << $3_1; 10387 $10_1 = 0; 10388 } else { 10389 $5_1 = (1 << $3_1) - 1 & $4_1 >>> 32 - $3_1 | $6_1 << $3_1; 10390 $10_1 = $4_1 << $3_1; 10391 } 10392 $2_1 = $5_1; 10393 $4_1 = 0; 10394 $5_1 = $8_1 & -16777216; 10395 $7_1 = 8; 10396 $3_1 = 8; 10397 if (($7_1 & 63) >>> 0 >= 32) { 10398 $6_1 = $5_1 << $3_1; 10399 $5_1 = 0; 10400 } else { 10401 $6_1 = (1 << $3_1) - 1 & $5_1 >>> 32 - $3_1 | $4_1 << $3_1; 10402 $5_1 = $5_1 << $3_1; 10403 } 10404 $22_1 = $5_1 | $10_1 | $11_1; 10405 $20_1 = $2_1 | $6_1 | $18_1; 10406 $4_1 = $9_1; 10407 $5_1 = $8_1; 10408 if (($7_1 & 63) >>> 0 >= 32) { 10409 $2_1 = $4_1 >>> $3_1 | 0 10410 } else { 10411 $2_1 = ((1 << $3_1) - 1 & $4_1) << 32 - $3_1 | $5_1 >>> $3_1 10412 } 10413 $10_1 = $2_1 & -16777216; 10414 $2_1 = 0; 10415 $5_1 = $9_1; 10416 $6_1 = $8_1; 10417 $7_1 = 24; 10418 $3_1 = 24; 10419 if (($7_1 & 63) >>> 0 >= 32) { 10420 $7_1 = $5_1 >>> $3_1 | 0 10421 } else { 10422 $7_1 = ((1 << $3_1) - 1 & $5_1) << 32 - $3_1 | $6_1 >>> $3_1 10423 } 10424 $11_1 = $7_1 & 16711680 | $10_1; 10425 $18_1 = $2_1; 10426 $7_1 = 40; 10427 $3_1 = 8; 10428 if (($7_1 & 63) >>> 0 >= 32) { 10429 $5_1 = $5_1 >>> $3_1 | 0 10430 } else { 10431 $5_1 = ((1 << $3_1) - 1 & $5_1) << 32 - $3_1 | $6_1 >>> $3_1 10432 } 10433 $10_1 = $5_1 & 65280; 10434 $6_1 = $9_1; 10435 $4_1 = $8_1; 10436 $7_1 = 56; 10437 $3_1 = 24; 10438 if (($7_1 & 63) >>> 0 >= 32) { 10439 $5_1 = 0; 10440 $6_1 = $6_1 >>> $3_1 | 0; 10441 } else { 10442 $5_1 = $6_1 >>> $3_1 | 0; 10443 $6_1 = ((1 << $3_1) - 1 & $6_1) << 32 - $3_1 | $4_1 >>> $3_1; 10444 } 10445 $7_1 = $6_1 | $10_1 | $11_1; 10446 $5_1 = $18_1 | ($2_1 | $5_1) | $20_1; 10447 $11_1 = $7_1 | $22_1; 10448 $7_1 = 808464432; 10449 $3_1 = $11_1 + $7_1 | 0; 10450 $2_1 = $5_1 + 808464432 | 0; 10451 $8_1 = $3_1; 10452 $9_1 = $3_1 >>> 0 < $7_1 >>> 0 ? $2_1 + 1 | 0 : $2_1; 10453 $2_1 = $5_1; 10454 $5_1 = $11_1; 10455 $7_1 = 1; 10456 $4_1 = 1; 10457 if (($7_1 & 63) >>> 0 >= 32) { 10458 $6_1 = $5_1 << $4_1; 10459 $2_1 = 0; 10460 } else { 10461 $6_1 = (1 << $4_1) - 1 & $5_1 >>> 32 - $4_1 | $2_1 << $4_1; 10462 $2_1 = $5_1 << $4_1; 10463 } 10464 $7_1 = Math_clz32($6_1); 10465 $10_1 = (70 - (($7_1 | 0) == 32 ? Math_clz32($2_1 | 1) + 32 | 0 : $7_1) >>> 3 | 0) + 8 | 0; 10466 } 10467 $5_1 = $13_1 + $15_1 | 0; 10468 HEAP8[$5_1 + 16 | 0] = $14_1 + 48; 10469 HEAP8[$5_1 + 8 | 0] = $8_1; 10470 HEAP8[$5_1 + 9 | 0] = $8_1 >>> 8; 10471 HEAP8[$5_1 + 10 | 0] = $8_1 >>> 16; 10472 HEAP8[$5_1 + 11 | 0] = $8_1 >>> 24; 10473 $6_1 = $9_1; 10474 HEAP8[$5_1 + 12 | 0] = $6_1; 10475 HEAP8[$5_1 + 13 | 0] = $6_1 >>> 8; 10476 HEAP8[$5_1 + 14 | 0] = $6_1 >>> 16; 10477 HEAP8[$5_1 + 15 | 0] = $6_1 >>> 24; 10478 $3_1 = $19_1 + 808464432 | 0; 10479 $7_1 = 808464432; 10480 $4_1 = $7_1 + $17_1 | 0; 10481 $3_1 = $4_1 >>> 0 < $7_1 >>> 0 ? $3_1 + 1 | 0 : $3_1; 10482 $2_1 = $5_1; 10483 HEAP8[$2_1 | 0] = $4_1; 10484 HEAP8[$2_1 + 1 | 0] = $4_1 >>> 8; 10485 HEAP8[$2_1 + 2 | 0] = $4_1 >>> 16; 10486 HEAP8[$2_1 + 3 | 0] = $4_1 >>> 24; 10487 HEAP8[$2_1 + 4 | 0] = $3_1; 10488 HEAP8[$2_1 + 5 | 0] = $3_1 >>> 8; 10489 HEAP8[$2_1 + 6 | 0] = $3_1 >>> 16; 10490 HEAP8[$2_1 + 7 | 0] = $3_1 >>> 24; 10491 $12_1 = $13_1 + ($12_1 ? 17 : $10_1) | 0; 10492 $14_1 = $12_1 - 1 | 0; 10493 if ($1_1 + 5 >>> 0 >= 21) { 10494 $12_1 = HEAPU8[$15_1 + 1 | 0]; 10495 HEAP8[$15_1 + 1 | 0] = 46; 10496 HEAP8[$15_1 | 0] = $12_1; 10497 $14_1 = ($15_1 + $14_1 | 0) + ($14_1 >>> 0 > 1) | 0; 10498 $15_1 = $1_1 >> 31; 10499 $15_1 = ($15_1 ^ $1_1) - $15_1 | 0; 10500 $12_1 = $14_1 + (($15_1 | 0) > 9) | 0; 10501 $13_1 = Math_imul($15_1, 5243) >>> 19 | 0; 10502 HEAP8[$12_1 + 1 | 0] = $13_1 + 48; 10503 $12_1 = ($12_1 + 1 | 0) + (($15_1 | 0) > 99) | 0; 10504 $6_1 = $12_1; 10505 $5_1 = HEAPU16[(Math_imul($13_1, -200) + ($15_1 << 1) | 0) + 1058368 >> 1]; 10506 HEAP8[$6_1 | 0] = $5_1; 10507 HEAP8[$6_1 + 1 | 0] = $5_1 >>> 8; 10508 $1_1 = ($1_1 | 0) >= 0 ? 11109 : 11621; 10509 HEAP8[$14_1 | 0] = $1_1; 10510 HEAP8[$14_1 + 1 | 0] = $1_1 >>> 8; 10511 $1_1 = $6_1 + 2 | 0; 10512 break block5; 10513 } 10514 block6 : { 10515 if (($12_1 - 2 | 0) > ($1_1 | 0)) { 10516 $13_1 = $15_1 + 1 | 0; 10517 if (($1_1 | 0) >= 0) { 10518 break block6 10519 } 10520 $1_1 = 1 - $1_1 | 0; 10521 $12_1 = $1_1 + $15_1 | 0; 10522 if ($14_1) { 10523 wasm2js_memory_copy($12_1, $13_1, $14_1) 10524 } 10525 if ($1_1) { 10526 wasm2js_memory_fill($15_1, 48, $1_1) 10527 } 10528 HEAP8[$15_1 + 1 | 0] = 46; 10529 $1_1 = $12_1 + $14_1 | 0; 10530 break block5; 10531 } 10532 if ($14_1) { 10533 wasm2js_memory_copy($15_1, $15_1 + 1 | 0, $14_1) 10534 } 10535 $12_1 = $1_1 + 3 | 0; 10536 $13_1 = $12_1 - $14_1 | 0; 10537 if ($13_1) { 10538 wasm2js_memory_fill($15_1 + $14_1 | 0, 48, $13_1) 10539 } 10540 HEAP8[($1_1 + $15_1 | 0) + 1 | 0] = 46; 10541 $1_1 = $12_1 + $15_1 | 0; 10542 break block5; 10543 } 10544 $1_1 = $1_1 + 1 | 0; 10545 if ($1_1) { 10546 wasm2js_memory_copy($15_1, $13_1, $1_1) 10547 } 10548 HEAP8[$1_1 + $15_1 | 0] = 46; 10549 $1_1 = $12_1 + $15_1 | 0; 10550 } 10551 global$0 = $16_1 + 240 | 0; 10552 return $1_1; 10553 } 10554 10555 function $85($0_1, $1_1) { 10556 $0_1 = $0_1 | 0; 10557 $1_1 = $1_1 | 0; 10558 var $2_1 = 0, $3_1 = 0, $4_1 = 0, $5_1 = 0; 10559 $2_1 = global$0 - 16 | 0; 10560 global$0 = $2_1; 10561 $4_1 = 1; 10562 $3_1 = HEAP32[$0_1 >> 2]; 10563 $5_1 = 1 & $3_1 >>> 32 - $4_1 | HEAP32[$0_1 + 4 >> 2] << $4_1; 10564 $3_1 = -2097152; 10565 block : { 10566 if (($5_1 | 0) == ($3_1 | 0) | $3_1 >>> 0 < $5_1 >>> 0) { 10567 HEAP32[$2_1 + 12 >> 2] = 27; 10568 HEAP32[$2_1 + 8 >> 2] = $0_1; 10569 $0_1 = $133(HEAP32[$1_1 >> 2], HEAP32[$1_1 + 4 >> 2], 1049203, $2_1 + 8 | 0); 10570 break block; 10571 } 10572 HEAP8[$2_1 + 4 | 0] = 0; 10573 HEAP32[$2_1 >> 2] = $1_1; 10574 HEAP32[$2_1 + 12 >> 2] = 27; 10575 HEAP32[$2_1 + 8 >> 2] = $0_1; 10576 block1 : { 10577 if ($133($2_1, 1059440, 1049203, $2_1 + 8 | 0)) { 10578 break block1 10579 } 10580 if (!HEAPU8[$2_1 + 4 | 0]) { 10581 if ($145($1_1, 1059437, 2)) { 10582 break block1 10583 } 10584 } 10585 $0_1 = 0; 10586 break block; 10587 } 10588 $0_1 = 1; 10589 } 10590 global$0 = $2_1 + 16 | 0; 10591 return $0_1 | 0; 10592 } 10593 10594 function $86($0_1, $1_1) { 10595 $0_1 = $0_1 | 0; 10596 $1_1 = $1_1 | 0; 10597 HEAP8[$0_1 + 4 | 0] = HEAPU8[$0_1 + 4 | 0] | ($1_1 | 0) == 46; 10598 $0_1 = HEAP32[$0_1 >> 2]; 10599 return FUNCTION_TABLE[HEAP32[HEAP32[$0_1 + 4 >> 2] + 16 >> 2]](HEAP32[$0_1 >> 2], $1_1) | 0; 10600 } 10601 10602 function $87($0_1, $1_1, $2_1) { 10603 $0_1 = $0_1 | 0; 10604 $1_1 = $1_1 | 0; 10605 $2_1 = $2_1 | 0; 10606 var $3_1 = 0, $4_1 = 0; 10607 $4_1 = global$0 - 16 | 0; 10608 global$0 = $4_1; 10609 block2 : { 10610 block : { 10611 block1 : { 10612 if ($2_1 >>> 0 <= 7) { 10613 if (!$2_1) { 10614 break block 10615 } 10616 while (1) { 10617 if (HEAPU8[$1_1 + $3_1 | 0] == 46) { 10618 break block1 10619 } 10620 $3_1 = $3_1 + 1 | 0; 10621 if (($3_1 | 0) != ($2_1 | 0)) { 10622 continue 10623 } 10624 break; 10625 }; 10626 break block; 10627 } 10628 $154($4_1 + 8 | 0, 46, $1_1, $2_1); 10629 if (HEAP32[$4_1 + 8 >> 2] != 1) { 10630 break block 10631 } 10632 } 10633 $3_1 = 1; 10634 break block2; 10635 } 10636 $3_1 = 0; 10637 } 10638 HEAP8[$0_1 + 4 | 0] = $3_1 | HEAPU8[$0_1 + 4 | 0]; 10639 $0_1 = $145(HEAP32[$0_1 >> 2], $1_1, $2_1); 10640 global$0 = $4_1 + 16 | 0; 10641 return $0_1 | 0; 10642 } 10643 10644 function $88($0_1, $1_1) { 10645 $0_1 = $0_1 | 0; 10646 $1_1 = $1_1 | 0; 10647 return $145($1_1, HEAP32[$0_1 >> 2], HEAP32[$0_1 + 4 >> 2]) | 0; 10648 } 10649 10650 function $89($0_1, $1_1) { 10651 $0_1 = $0_1 | 0; 10652 $1_1 = $1_1 | 0; 10653 return $118(HEAP32[$0_1 >> 2], $1_1) | 0; 10654 } 10655 10656 function $90($0_1, $1_1) { 10657 $0_1 = $0_1 | 0; 10658 $1_1 = $1_1 | 0; 10659 var $2_1 = 0, $3_1 = 0, $4_1 = 0, $5_1 = 0; 10660 $2_1 = global$0 - 32 | 0; 10661 global$0 = $2_1; 10662 block : { 10663 block4 : { 10664 block2 : { 10665 block1 : { 10666 block3 : { 10667 $3_1 = HEAP32[$0_1 + 4 >> 2]; 10668 switch ($3_1 | 0) { 10669 case 0: 10670 break block; 10671 case 1: 10672 break block1; 10673 case 2: 10674 break block2; 10675 default: 10676 break block3; 10677 }; 10678 } 10679 $4_1 = 1; 10680 if ($145($1_1, 1059428, 7)) { 10681 break block4 10682 } 10683 $5_1 = $3_1 << 3; 10684 $0_1 = HEAP32[$0_1 >> 2]; 10685 $3_1 = 0; 10686 while (1) { 10687 HEAP32[$2_1 + 28 >> 2] = $0_1; 10688 if ($3_1) { 10689 if ($145($1_1, 1059435, 2)) { 10690 break block4 10691 } 10692 } 10693 HEAP32[$2_1 + 16 >> 2] = 28; 10694 HEAP32[$2_1 + 12 >> 2] = $2_1 + 28; 10695 if ($133(HEAP32[$1_1 >> 2], HEAP32[$1_1 + 4 >> 2], 1051435, $2_1 + 12 | 0)) { 10696 break block4 10697 } 10698 $0_1 = $0_1 + 8 | 0; 10699 $3_1 = $3_1 - 1 | 0; 10700 $5_1 = $5_1 - 8 | 0; 10701 if ($5_1) { 10702 continue 10703 } 10704 break; 10705 }; 10706 $4_1 = 0; 10707 break block4; 10708 } 10709 $0_1 = HEAP32[$0_1 >> 2]; 10710 HEAP32[$2_1 + 16 >> 2] = 1; 10711 HEAP32[$2_1 + 12 >> 2] = $0_1; 10712 $4_1 = $133(HEAP32[$1_1 >> 2], HEAP32[$1_1 + 4 >> 2], 1051435, $2_1 + 12 | 0); 10713 break block4; 10714 } 10715 $0_1 = HEAP32[$0_1 >> 2]; 10716 HEAP32[$2_1 + 24 >> 2] = 1; 10717 HEAP32[$2_1 + 20 >> 2] = $0_1 + 8; 10718 HEAP32[$2_1 + 16 >> 2] = 1; 10719 HEAP32[$2_1 + 12 >> 2] = $0_1; 10720 $4_1 = $133(HEAP32[$1_1 >> 2], HEAP32[$1_1 + 4 >> 2], 1051335, $2_1 + 12 | 0); 10721 } 10722 global$0 = $2_1 + 32 | 0; 10723 return $4_1 | 0; 10724 } 10725 $129(1059395, 14, 1059412); 10726 wasm2js_trap(); 10727 } 10728 10729 function $91($0_1, $1_1, $2_1) { 10730 $0_1 = $0_1 | 0; 10731 $1_1 = $1_1 | 0; 10732 $2_1 = $2_1 | 0; 10733 return $133($0_1, 1059440, $1_1, $2_1) | 0; 10734 } 10735 10736 function $92($0_1) { 10737 $0_1 = $0_1 | 0; 10738 var $1_1 = 0; 10739 $1_1 = HEAP32[$0_1 >> 2]; 10740 if ($1_1) { 10741 $99(HEAP32[$0_1 + 4 >> 2], $1_1) 10742 } 10743 } 10744 10745 function $93($0_1) { 10746 $0_1 = $0_1 | 0; 10747 var $1_1 = 0; 10748 $1_1 = HEAP32[$0_1 >> 2]; 10749 if (($1_1 | 0) > 0) { 10750 $99(HEAP32[$0_1 + 4 >> 2], $1_1) 10751 } 10752 } 10753 10754 function $94($0_1, $1_1, $2_1) { 10755 var $3_1 = 0, $4_1 = 0, $5_1 = 0, $6_1 = 0, $7_1 = 0, $8_1 = 0; 10756 $3_1 = global$0 - 16 | 0; 10757 global$0 = $3_1; 10758 $4_1 = $1_1 + $2_1 | 0; 10759 if ($4_1 >>> 0 < $2_1 >>> 0) { 10760 $120(0, 0); 10761 wasm2js_trap(); 10762 } 10763 $5_1 = $3_1 + 4 | 0; 10764 $2_1 = HEAP32[$0_1 >> 2]; 10765 $6_1 = $2_1; 10766 $8_1 = HEAP32[$0_1 + 4 >> 2]; 10767 $7_1 = 1; 10768 $1_1 = 4; 10769 $2_1 = $2_1 << 1; 10770 $2_1 = $2_1 >>> 0 < $4_1 >>> 0 ? $4_1 : $2_1; 10771 $4_1 = $2_1 >>> 0 <= 8 ? 8 : $2_1; 10772 $2_1 = $4_1; 10773 block : { 10774 if ($2_1 >>> 0 > 2147483647) { 10775 $2_1 = 0; 10776 break block; 10777 } 10778 block3 : { 10779 block2 : { 10780 block1 : { 10781 if ($6_1) { 10782 $1_1 = $34($8_1, $6_1, 1, $2_1); 10783 break block1; 10784 } 10785 if (!$2_1) { 10786 $1_1 = 1; 10787 break block2; 10788 } 10789 $1_1 = $33($2_1, 1); 10790 } 10791 if ($1_1) { 10792 break block2 10793 } 10794 HEAP32[$5_1 + 4 >> 2] = 1; 10795 break block3; 10796 } 10797 HEAP32[$5_1 + 4 >> 2] = $1_1; 10798 $7_1 = 0; 10799 } 10800 $1_1 = 8; 10801 } 10802 HEAP32[$1_1 + $5_1 >> 2] = $2_1; 10803 HEAP32[$5_1 >> 2] = $7_1; 10804 if (HEAP32[$3_1 + 4 >> 2] == 1) { 10805 $120(HEAP32[$3_1 + 8 >> 2], HEAP32[$3_1 + 12 >> 2]); 10806 wasm2js_trap(); 10807 } 10808 $1_1 = HEAP32[$3_1 + 8 >> 2]; 10809 HEAP32[$0_1 >> 2] = $4_1; 10810 HEAP32[$0_1 + 4 >> 2] = $1_1; 10811 global$0 = $3_1 + 16 | 0; 10812 } 10813 10814 function $95($0_1, $1_1, $2_1, $3_1, $4_1) { 10815 var $5_1 = 0, $6_1 = 0, $7_1 = 0; 10816 $5_1 = global$0 - 32 | 0; 10817 global$0 = $5_1; 10818 $6_1 = HEAP32[267034]; 10819 HEAP32[267034] = $6_1 + 1; 10820 block8 : { 10821 block7 : { 10822 block4 : { 10823 block1 : { 10824 block6 : { 10825 block5 : { 10826 block2 : { 10827 block3 : { 10828 $7_1 = 0; 10829 block : { 10830 if (($6_1 | 0) < 0) { 10831 break block 10832 } 10833 $7_1 = 1; 10834 if (HEAPU8[1068116]) { 10835 break block 10836 } 10837 HEAP8[1068116] = 1; 10838 HEAP32[267028] = HEAP32[267028] + 1; 10839 $7_1 = 2; 10840 } 10841 switch ($7_1 & 255) { 10842 case 0: 10843 break block1; 10844 case 2: 10845 break block3; 10846 default: 10847 break block2; 10848 }; 10849 } 10850 $6_1 = HEAP32[267031]; 10851 if (($6_1 | 0) < 0) { 10852 break block1 10853 } 10854 $7_1 = $6_1; 10855 $6_1 = $6_1 + 1 | 0; 10856 if (($7_1 | 0) > ($6_1 | 0)) { 10857 break block4 10858 } 10859 HEAP32[267031] = $6_1; 10860 if (HEAP32[267032]) { 10861 break block5 10862 } 10863 HEAP32[267031] = $6_1 - 1; 10864 break block6; 10865 } 10866 FUNCTION_TABLE[HEAP32[$1_1 + 24 >> 2]]($5_1, $0_1); 10867 wasm2js_trap(); 10868 } 10869 FUNCTION_TABLE[HEAP32[$1_1 + 20 >> 2]]($5_1 + 8 | 0, $0_1); 10870 HEAP8[$5_1 + 29 | 0] = $4_1; 10871 HEAP8[$5_1 + 28 | 0] = $3_1; 10872 HEAP32[$5_1 + 24 >> 2] = $2_1; 10873 $0_1 = HEAP32[$5_1 + 12 >> 2]; 10874 HEAP32[$5_1 + 16 >> 2] = HEAP32[$5_1 + 8 >> 2]; 10875 HEAP32[$5_1 + 20 >> 2] = $0_1; 10876 FUNCTION_TABLE[HEAP32[HEAP32[267033] + 20 >> 2]](HEAP32[267032], $5_1 + 16 | 0); 10877 $0_1 = HEAP32[267031]; 10878 HEAP32[267031] = $0_1 - 1; 10879 if (($0_1 | 0) <= 0) { 10880 break block7 10881 } 10882 } 10883 HEAP8[1068116] = 0; 10884 if ($3_1) { 10885 break block8 10886 } 10887 } 10888 wasm2js_trap(); 10889 } 10890 $0_1 = global$0 - 16 | 0; 10891 global$0 = $0_1; 10892 HEAP32[$0_1 + 4 >> 2] = 28; 10893 HEAP32[$0_1 >> 2] = 1059720; 10894 HEAP32[$0_1 + 8 >> 2] = $0_1; 10895 HEAP32[$0_1 + 12 >> 2] = 55; 10896 $134(1049203, $0_1 + 8 | 0, 1059748); 10897 wasm2js_trap(); 10898 } 10899 $134(1059796, 77, 1059836); 10900 wasm2js_trap(); 10901 } 10902 wasm2js_trap(); 10903 } 10904 10905 function $96($0_1, $1_1) { 10906 $0_1 = $0_1 | 0; 10907 $1_1 = $1_1 | 0; 10908 HEAP8[1068140] = 1; 10909 } 10910 10911 function $97($0_1, $1_1) { 10912 var $2_1 = 0, $3_1 = 0, $4_1 = 0, $5_1 = 0, $6_1 = 0; 10913 $4_1 = (-48 - HEAP32[267024] & -9) - 3 | 0; 10914 $0_1 = $0_1 >>> 0 <= 16 ? 16 : $0_1; 10915 block : { 10916 if (($4_1 >>> 0 >= 4294967232 ? -64 : $4_1) - $0_1 >>> 0 <= $1_1 >>> 0) { 10917 break block 10918 } 10919 $4_1 = $1_1 >>> 0 < 11 ? 16 : $1_1 + 11 & -8; 10920 $2_1 = $98(($4_1 + $0_1 | 0) + 12 | 0); 10921 if (!$2_1) { 10922 break block 10923 } 10924 $1_1 = $2_1 - 8 | 0; 10925 $3_1 = $0_1 - 1 | 0; 10926 block1 : { 10927 if (!($2_1 & $3_1)) { 10928 $0_1 = $1_1; 10929 break block1; 10930 } 10931 $5_1 = $2_1 - 4 | 0; 10932 $6_1 = HEAP32[$5_1 >> 2]; 10933 $2_1 = ($2_1 + $3_1 & 0 - $0_1) - 8 | 0; 10934 $0_1 = $2_1 + ($2_1 - $1_1 >>> 0 <= 16 ? $0_1 : 0) | 0; 10935 $2_1 = $0_1 - $1_1 | 0; 10936 $3_1 = ($6_1 & -8) - $2_1 | 0; 10937 if ($6_1 & 3) { 10938 HEAP32[$0_1 + 4 >> 2] = HEAP32[$0_1 + 4 >> 2] & 1 | $3_1 | 2; 10939 $3_1 = $0_1 + $3_1 | 0; 10940 HEAP32[$3_1 + 4 >> 2] = HEAP32[$3_1 + 4 >> 2] | 1; 10941 HEAP32[$5_1 >> 2] = HEAP32[$5_1 >> 2] & 1 | $2_1 | 2; 10942 $3_1 = $1_1 + $2_1 | 0; 10943 HEAP32[$3_1 + 4 >> 2] = HEAP32[$3_1 + 4 >> 2] | 1; 10944 $102($1_1, $2_1); 10945 break block1; 10946 } 10947 $1_1 = HEAP32[$1_1 >> 2]; 10948 HEAP32[$0_1 + 4 >> 2] = $3_1; 10949 HEAP32[$0_1 >> 2] = $1_1 + $2_1; 10950 } 10951 $1_1 = HEAP32[$0_1 + 4 >> 2]; 10952 block2 : { 10953 if (!($1_1 & 3)) { 10954 break block2 10955 } 10956 $2_1 = $1_1 & -8; 10957 if ($2_1 >>> 0 <= $4_1 + 16 >>> 0) { 10958 break block2 10959 } 10960 HEAP32[$0_1 + 4 >> 2] = $1_1 & 1 | $4_1 | 2; 10961 $1_1 = $0_1 + $4_1 | 0; 10962 $4_1 = $2_1 - $4_1 | 0; 10963 HEAP32[$1_1 + 4 >> 2] = $4_1 | 3; 10964 $2_1 = $0_1 + $2_1 | 0; 10965 HEAP32[$2_1 + 4 >> 2] = HEAP32[$2_1 + 4 >> 2] | 1; 10966 $102($1_1, $4_1); 10967 } 10968 $3_1 = $0_1 + 8 | 0; 10969 } 10970 return $3_1; 10971 } 10972 10973 function $98($0_1) { 10974 var $1_1 = 0, $2_1 = 0, $3_1 = 0, $4_1 = 0, $5_1 = 0, $6_1 = 0, $7_1 = 0, $8_1 = 0, $9_1 = 0, $10_1 = 0, $11_1 = 0, $12_1 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; 10975 $9_1 = global$0 - 16 | 0; 10976 global$0 = $9_1; 10977 block : { 10978 block1 : { 10979 block2 : { 10980 if ($0_1 >>> 0 >= 245) { 10981 $1_1 = (-48 - HEAP32[267024] & -9) - 3 | 0; 10982 if (($1_1 >>> 0 >= 4294967232 ? -64 : $1_1) >>> 0 <= $0_1 >>> 0) { 10983 break block 10984 } 10985 $1_1 = $0_1 + 11 | 0; 10986 $5_1 = $1_1 & -8; 10987 $8_1 = HEAP32[267014]; 10988 if (!$8_1) { 10989 break block1 10990 } 10991 $7_1 = 31; 10992 if ($0_1 >>> 0 >= 16777205) { 10993 break block2 10994 } 10995 $0_1 = Math_clz32($1_1 >>> 8 | 0); 10996 $7_1 = ($5_1 >>> 38 - $0_1 & 1 | $0_1 << 1) ^ 62; 10997 break block2; 10998 } 10999 block8 : { 11000 block10 : { 11001 block12 : { 11002 block4 : { 11003 block3 : { 11004 $2_1 = HEAP32[267013]; 11005 $5_1 = $0_1 >>> 0 < 11 ? 16 : $0_1 + 11 & 504; 11006 $0_1 = $5_1 >>> 3 | 0; 11007 $1_1 = $2_1 >>> $0_1 | 0; 11008 if ($1_1 & 3) { 11009 $6_1 = $0_1 + (($1_1 ^ -1) & 1) | 0; 11010 $0_1 = $6_1 << 3; 11011 $4_1 = $0_1 + 1067788 | 0; 11012 $1_1 = HEAP32[$0_1 + 1067796 >> 2]; 11013 $3_1 = HEAP32[$1_1 + 8 >> 2]; 11014 if (($4_1 | 0) == ($3_1 | 0)) { 11015 break block3 11016 } 11017 HEAP32[$3_1 + 12 >> 2] = $4_1; 11018 HEAP32[$4_1 + 8 >> 2] = $3_1; 11019 break block4; 11020 } 11021 if (HEAPU32[267015] >= $5_1 >>> 0) { 11022 break block1 11023 } 11024 if (!$1_1) { 11025 $0_1 = HEAP32[267014]; 11026 if (!$0_1) { 11027 break block1 11028 } 11029 $1_1 = HEAP32[(__wasm_ctz_i32($0_1) << 2) + 1067644 >> 2]; 11030 $3_1 = (HEAP32[$1_1 + 4 >> 2] & -8) - $5_1 | 0; 11031 $2_1 = $1_1; 11032 while (1) { 11033 block5 : { 11034 $0_1 = HEAP32[$1_1 + 16 >> 2]; 11035 if (!$0_1) { 11036 $0_1 = HEAP32[$1_1 + 20 >> 2]; 11037 if (!$0_1) { 11038 break block5 11039 } 11040 } 11041 $1_1 = (HEAP32[$0_1 + 4 >> 2] & -8) - $5_1 | 0; 11042 $4_1 = $1_1; 11043 $1_1 = $1_1 >>> 0 < $3_1 >>> 0; 11044 $3_1 = $1_1 ? $4_1 : $3_1; 11045 $2_1 = $1_1 ? $0_1 : $2_1; 11046 $1_1 = $0_1; 11047 continue; 11048 } 11049 break; 11050 }; 11051 $7_1 = HEAP32[$2_1 + 24 >> 2]; 11052 block7 : { 11053 block6 : { 11054 $0_1 = HEAP32[$2_1 + 12 >> 2]; 11055 if (($0_1 | 0) == ($2_1 | 0)) { 11056 $0_1 = HEAP32[$2_1 + 20 >> 2]; 11057 $1_1 = HEAP32[($0_1 ? 20 : 16) + $2_1 >> 2]; 11058 if ($1_1) { 11059 break block6 11060 } 11061 $0_1 = 0; 11062 break block7; 11063 } 11064 $1_1 = HEAP32[$2_1 + 8 >> 2]; 11065 HEAP32[$1_1 + 12 >> 2] = $0_1; 11066 HEAP32[$0_1 + 8 >> 2] = $1_1; 11067 break block7; 11068 } 11069 $4_1 = $0_1 ? $2_1 + 20 | 0 : $2_1 + 16 | 0; 11070 while (1) { 11071 $6_1 = $4_1; 11072 $0_1 = $1_1; 11073 $1_1 = HEAP32[$0_1 + 20 >> 2]; 11074 $4_1 = $1_1 ? $0_1 + 20 | 0 : $0_1 + 16 | 0; 11075 $1_1 = HEAP32[($1_1 ? 20 : 16) + $0_1 >> 2]; 11076 if ($1_1) { 11077 continue 11078 } 11079 break; 11080 }; 11081 HEAP32[$6_1 >> 2] = 0; 11082 } 11083 if (!$7_1) { 11084 break block8 11085 } 11086 $1_1 = (HEAP32[$2_1 + 28 >> 2] << 2) + 1067644 | 0; 11087 block9 : { 11088 if (($2_1 | 0) != HEAP32[$1_1 >> 2]) { 11089 if (HEAP32[$7_1 + 16 >> 2] != ($2_1 | 0)) { 11090 HEAP32[$7_1 + 20 >> 2] = $0_1; 11091 if ($0_1) { 11092 break block9 11093 } 11094 break block8; 11095 } 11096 HEAP32[$7_1 + 16 >> 2] = $0_1; 11097 if ($0_1) { 11098 break block9 11099 } 11100 break block8; 11101 } 11102 HEAP32[$1_1 >> 2] = $0_1; 11103 if (!$0_1) { 11104 break block10 11105 } 11106 } 11107 HEAP32[$0_1 + 24 >> 2] = $7_1; 11108 $1_1 = HEAP32[$2_1 + 16 >> 2]; 11109 if ($1_1) { 11110 HEAP32[$0_1 + 16 >> 2] = $1_1; 11111 HEAP32[$1_1 + 24 >> 2] = $0_1; 11112 } 11113 $1_1 = HEAP32[$2_1 + 20 >> 2]; 11114 if (!$1_1) { 11115 break block8 11116 } 11117 HEAP32[$0_1 + 20 >> 2] = $1_1; 11118 HEAP32[$1_1 + 24 >> 2] = $0_1; 11119 break block8; 11120 } 11121 $4_1 = 2 << $0_1; 11122 $6_1 = __wasm_ctz_i32(($4_1 | 0 - $4_1) & $1_1 << $0_1); 11123 $1_1 = $6_1 << 3; 11124 $4_1 = $1_1 + 1067788 | 0; 11125 $0_1 = HEAP32[$1_1 + 1067796 >> 2]; 11126 $3_1 = HEAP32[$0_1 + 8 >> 2]; 11127 block11 : { 11128 if (($4_1 | 0) != ($3_1 | 0)) { 11129 HEAP32[$3_1 + 12 >> 2] = $4_1; 11130 HEAP32[$4_1 + 8 >> 2] = $3_1; 11131 break block11; 11132 } 11133 (wasm2js_i32$0 = 1068052, wasm2js_i32$1 = __wasm_rotl_i32($6_1) & $2_1), HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1; 11134 } 11135 HEAP32[$0_1 + 4 >> 2] = $5_1 | 3; 11136 $6_1 = $1_1 - $5_1 | 0; 11137 HEAP32[$0_1 + $1_1 >> 2] = $6_1; 11138 $7_1 = $0_1 + $5_1 | 0; 11139 HEAP32[$7_1 + 4 >> 2] = $6_1 | 1; 11140 $2_1 = HEAP32[267015]; 11141 if (!$2_1) { 11142 break block12 11143 } 11144 $1_1 = HEAP32[267017]; 11145 $4_1 = HEAP32[267013]; 11146 $3_1 = 1 << ($2_1 >>> 3); 11147 block13 : { 11148 if (!($4_1 & $3_1)) { 11149 HEAP32[267013] = $3_1 | $4_1; 11150 $5_1 = ($2_1 & -8) + 1067788 | 0; 11151 $4_1 = $5_1; 11152 break block13; 11153 } 11154 $2_1 = $2_1 & -8; 11155 $4_1 = $2_1 + 1067788 | 0; 11156 $5_1 = HEAP32[$2_1 + 1067796 >> 2]; 11157 } 11158 HEAP32[$4_1 + 8 >> 2] = $1_1; 11159 HEAP32[$5_1 + 12 >> 2] = $1_1; 11160 HEAP32[$1_1 + 12 >> 2] = $4_1; 11161 HEAP32[$1_1 + 8 >> 2] = $5_1; 11162 break block12; 11163 } 11164 (wasm2js_i32$0 = 1068052, wasm2js_i32$1 = __wasm_rotl_i32($6_1) & $2_1), HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1; 11165 } 11166 $3_1 = $1_1 + 8 | 0; 11167 HEAP32[$1_1 + 4 >> 2] = $0_1 | 3; 11168 $0_1 = $0_1 + $1_1 | 0; 11169 HEAP32[$0_1 + 4 >> 2] = HEAP32[$0_1 + 4 >> 2] | 1; 11170 break block; 11171 } 11172 $3_1 = $0_1 + 8 | 0; 11173 HEAP32[267017] = $7_1; 11174 HEAP32[267015] = $6_1; 11175 break block; 11176 } 11177 (wasm2js_i32$0 = 1068056, wasm2js_i32$1 = HEAP32[267014] & __wasm_rotl_i32(HEAP32[$2_1 + 28 >> 2])), HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1; 11178 } 11179 block16 : { 11180 block14 : { 11181 if ($3_1 >>> 0 >= 16) { 11182 HEAP32[$2_1 + 4 >> 2] = $5_1 | 3; 11183 $6_1 = $2_1 + $5_1 | 0; 11184 HEAP32[$6_1 + 4 >> 2] = $3_1 | 1; 11185 HEAP32[$3_1 + $6_1 >> 2] = $3_1; 11186 $1_1 = HEAP32[267015]; 11187 if (!$1_1) { 11188 break block14 11189 } 11190 $0_1 = HEAP32[267017]; 11191 $4_1 = HEAP32[267013]; 11192 $7_1 = 1 << ($1_1 >>> 3); 11193 block15 : { 11194 if (!($4_1 & $7_1)) { 11195 HEAP32[267013] = $4_1 | $7_1; 11196 $4_1 = ($1_1 & -8) + 1067788 | 0; 11197 $1_1 = $4_1; 11198 break block15; 11199 } 11200 $4_1 = $1_1 & -8; 11201 $1_1 = $4_1 + 1067788 | 0; 11202 $4_1 = HEAP32[$4_1 + 1067796 >> 2]; 11203 } 11204 HEAP32[$1_1 + 8 >> 2] = $0_1; 11205 HEAP32[$4_1 + 12 >> 2] = $0_1; 11206 HEAP32[$0_1 + 12 >> 2] = $1_1; 11207 HEAP32[$0_1 + 8 >> 2] = $4_1; 11208 break block14; 11209 } 11210 $0_1 = $3_1 + $5_1 | 0; 11211 HEAP32[$2_1 + 4 >> 2] = $0_1 | 3; 11212 $0_1 = $0_1 + $2_1 | 0; 11213 HEAP32[$0_1 + 4 >> 2] = HEAP32[$0_1 + 4 >> 2] | 1; 11214 break block16; 11215 } 11216 HEAP32[267017] = $6_1; 11217 HEAP32[267015] = $3_1; 11218 } 11219 $3_1 = $2_1 + 8 | 0; 11220 if (!$3_1) { 11221 break block1 11222 } 11223 break block; 11224 } 11225 $3_1 = 0 - $5_1 | 0; 11226 $2_1 = HEAP32[($7_1 << 2) + 1067644 >> 2]; 11227 block20 : { 11228 block19 : { 11229 block17 : { 11230 if (!$2_1) { 11231 $1_1 = 0; 11232 $0_1 = 0; 11233 break block17; 11234 } 11235 $1_1 = 0; 11236 $4_1 = $5_1 << (($7_1 | 0) != 31 ? 25 - ($7_1 >>> 1 | 0) | 0 : 0); 11237 $0_1 = 0; 11238 while (1) { 11239 block18 : { 11240 $6_1 = HEAP32[$2_1 + 4 >> 2] & -8; 11241 if ($5_1 >>> 0 > $6_1 >>> 0) { 11242 break block18 11243 } 11244 $6_1 = $6_1 - $5_1 | 0; 11245 if ($3_1 >>> 0 <= $6_1 >>> 0) { 11246 break block18 11247 } 11248 $1_1 = $2_1; 11249 $3_1 = $6_1; 11250 if ($3_1) { 11251 break block18 11252 } 11253 $3_1 = 0; 11254 $0_1 = $1_1; 11255 break block19; 11256 } 11257 $6_1 = HEAP32[$2_1 + 20 >> 2]; 11258 $2_1 = HEAP32[(($4_1 >>> 29 & 4) + $2_1 | 0) + 16 >> 2]; 11259 $0_1 = $6_1 ? (($2_1 | 0) != ($6_1 | 0) ? $6_1 : $0_1) : $0_1; 11260 $4_1 = $4_1 << 1; 11261 if ($2_1) { 11262 continue 11263 } 11264 break; 11265 }; 11266 } 11267 if (!($0_1 | $1_1)) { 11268 $1_1 = 0; 11269 $0_1 = 2 << $7_1; 11270 $0_1 = $8_1 & ($0_1 | 0 - $0_1); 11271 if (!$0_1) { 11272 break block1 11273 } 11274 $0_1 = HEAP32[(__wasm_ctz_i32($0_1) << 2) + 1067644 >> 2]; 11275 } 11276 if (!$0_1) { 11277 break block20 11278 } 11279 } 11280 while (1) { 11281 $6_1 = HEAP32[$0_1 + 4 >> 2] & -8; 11282 $4_1 = $6_1 - $5_1 | 0; 11283 $7_1 = $3_1 >>> 0 > $4_1 >>> 0 ? $4_1 : $3_1; 11284 $2_1 = HEAP32[$0_1 + 16 >> 2]; 11285 if (!$2_1) { 11286 $2_1 = HEAP32[$0_1 + 20 >> 2] 11287 } 11288 $0_1 = $3_1 >>> 0 <= $4_1 >>> 0 ? $1_1 : $0_1; 11289 $4_1 = $5_1 >>> 0 > $6_1 >>> 0; 11290 $3_1 = $4_1 ? $3_1 : $7_1; 11291 $1_1 = $4_1 ? $1_1 : $0_1; 11292 $0_1 = $2_1; 11293 if ($0_1) { 11294 continue 11295 } 11296 break; 11297 }; 11298 } 11299 if (!$1_1) { 11300 break block1 11301 } 11302 $0_1 = HEAP32[267015]; 11303 if ($0_1 >>> 0 >= $5_1 >>> 0 & $0_1 - $5_1 >>> 0 <= $3_1 >>> 0) { 11304 break block1 11305 } 11306 $7_1 = HEAP32[$1_1 + 24 >> 2]; 11307 block22 : { 11308 block21 : { 11309 $0_1 = HEAP32[$1_1 + 12 >> 2]; 11310 if (($0_1 | 0) == ($1_1 | 0)) { 11311 $0_1 = HEAP32[$1_1 + 20 >> 2]; 11312 $2_1 = HEAP32[($0_1 ? 20 : 16) + $1_1 >> 2]; 11313 if ($2_1) { 11314 break block21 11315 } 11316 $0_1 = 0; 11317 break block22; 11318 } 11319 $2_1 = HEAP32[$1_1 + 8 >> 2]; 11320 HEAP32[$2_1 + 12 >> 2] = $0_1; 11321 HEAP32[$0_1 + 8 >> 2] = $2_1; 11322 break block22; 11323 } 11324 $4_1 = $0_1 ? $1_1 + 20 | 0 : $1_1 + 16 | 0; 11325 while (1) { 11326 $6_1 = $4_1; 11327 $0_1 = $2_1; 11328 $2_1 = HEAP32[$0_1 + 20 >> 2]; 11329 $4_1 = $2_1 ? $0_1 + 20 | 0 : $0_1 + 16 | 0; 11330 $2_1 = HEAP32[($2_1 ? 20 : 16) + $0_1 >> 2]; 11331 if ($2_1) { 11332 continue 11333 } 11334 break; 11335 }; 11336 HEAP32[$6_1 >> 2] = 0; 11337 } 11338 block23 : { 11339 if (!$7_1) { 11340 break block23 11341 } 11342 block25 : { 11343 $2_1 = (HEAP32[$1_1 + 28 >> 2] << 2) + 1067644 | 0; 11344 block24 : { 11345 if (($1_1 | 0) != HEAP32[$2_1 >> 2]) { 11346 if (HEAP32[$7_1 + 16 >> 2] != ($1_1 | 0)) { 11347 HEAP32[$7_1 + 20 >> 2] = $0_1; 11348 if ($0_1) { 11349 break block24 11350 } 11351 break block23; 11352 } 11353 HEAP32[$7_1 + 16 >> 2] = $0_1; 11354 if ($0_1) { 11355 break block24 11356 } 11357 break block23; 11358 } 11359 HEAP32[$2_1 >> 2] = $0_1; 11360 if (!$0_1) { 11361 break block25 11362 } 11363 } 11364 HEAP32[$0_1 + 24 >> 2] = $7_1; 11365 $2_1 = HEAP32[$1_1 + 16 >> 2]; 11366 if ($2_1) { 11367 HEAP32[$0_1 + 16 >> 2] = $2_1; 11368 HEAP32[$2_1 + 24 >> 2] = $0_1; 11369 } 11370 $2_1 = HEAP32[$1_1 + 20 >> 2]; 11371 if (!$2_1) { 11372 break block23 11373 } 11374 HEAP32[$0_1 + 20 >> 2] = $2_1; 11375 HEAP32[$2_1 + 24 >> 2] = $0_1; 11376 break block23; 11377 } 11378 (wasm2js_i32$0 = 1068056, wasm2js_i32$1 = HEAP32[267014] & __wasm_rotl_i32(HEAP32[$1_1 + 28 >> 2])), HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1; 11379 } 11380 block26 : { 11381 if ($3_1 >>> 0 >= 16) { 11382 HEAP32[$1_1 + 4 >> 2] = $5_1 | 3; 11383 $0_1 = $1_1 + $5_1 | 0; 11384 HEAP32[$0_1 + 4 >> 2] = $3_1 | 1; 11385 HEAP32[$0_1 + $3_1 >> 2] = $3_1; 11386 if ($3_1 >>> 0 >= 256) { 11387 $103($0_1, $3_1); 11388 break block26; 11389 } 11390 $2_1 = HEAP32[267013]; 11391 $4_1 = 1 << ($3_1 >>> 3); 11392 block27 : { 11393 if (!($2_1 & $4_1)) { 11394 HEAP32[267013] = $2_1 | $4_1; 11395 $3_1 = ($3_1 & 248) + 1067788 | 0; 11396 $2_1 = $3_1; 11397 break block27; 11398 } 11399 $4_1 = $3_1 & 248; 11400 $2_1 = $4_1 + 1067788 | 0; 11401 $3_1 = HEAP32[$4_1 + 1067796 >> 2]; 11402 } 11403 HEAP32[$2_1 + 8 >> 2] = $0_1; 11404 HEAP32[$3_1 + 12 >> 2] = $0_1; 11405 HEAP32[$0_1 + 12 >> 2] = $2_1; 11406 HEAP32[$0_1 + 8 >> 2] = $3_1; 11407 break block26; 11408 } 11409 $0_1 = $3_1 + $5_1 | 0; 11410 HEAP32[$1_1 + 4 >> 2] = $0_1 | 3; 11411 $0_1 = $0_1 + $1_1 | 0; 11412 HEAP32[$0_1 + 4 >> 2] = HEAP32[$0_1 + 4 >> 2] | 1; 11413 } 11414 $3_1 = $1_1 + 8 | 0; 11415 if ($3_1) { 11416 break block 11417 } 11418 } 11419 block42 : { 11420 block33 : { 11421 block40 : { 11422 block32 : { 11423 block39 : { 11424 block38 : { 11425 block34 : { 11426 $1_1 = HEAP32[267015]; 11427 if ($1_1 >>> 0 < $5_1 >>> 0) { 11428 $0_1 = HEAP32[267016]; 11429 if ($0_1 >>> 0 <= $5_1 >>> 0) { 11430 $3_1 = 0; 11431 $0_1 = $9_1 + 4 | 0; 11432 block29 : { 11433 block28 : { 11434 $1_1 = HEAP32[267024]; 11435 $1_1 = ($1_1 + $5_1 | 0) + 47 & 0 - $1_1; 11436 if (!$1_1) { 11437 break block28 11438 } 11439 $6_1 = HEAPU8[1068141]; 11440 HEAP8[1068141] = 1; 11441 $2_1 = 1068144; 11442 if ($1_1 >>> 0 > 45968 | $6_1) { 11443 break block28 11444 } 11445 $6_1 = 45968; 11446 break block29; 11447 } 11448 $2_1 = 0; 11449 $1_1 = ($1_1 >>> 16 | 0) + (($1_1 & 65535) != 0) | 0; 11450 $4_1 = __wasm_memory_grow($1_1 | 0); 11451 $6_1 = 0; 11452 if (($4_1 | 0) == -1) { 11453 break block29 11454 } 11455 $1_1 = $1_1 << 16; 11456 $2_1 = $4_1 << 16; 11457 $6_1 = ($2_1 | 0) == (0 - $1_1 | 0) ? $1_1 - 16 | 0 : $1_1; 11458 } 11459 HEAP32[$0_1 + 8 >> 2] = 0; 11460 HEAP32[$0_1 + 4 >> 2] = $6_1; 11461 HEAP32[$0_1 >> 2] = $2_1; 11462 $1_1 = HEAP32[$9_1 + 4 >> 2]; 11463 if (!$1_1) { 11464 break block 11465 } 11466 $6_1 = HEAP32[$9_1 + 12 >> 2]; 11467 $4_1 = HEAP32[$9_1 + 8 >> 2]; 11468 $0_1 = $4_1 + HEAP32[267019] | 0; 11469 HEAP32[267019] = $0_1; 11470 $2_1 = HEAP32[267020]; 11471 HEAP32[267020] = $0_1 >>> 0 > $2_1 >>> 0 ? $0_1 : $2_1; 11472 block31 : { 11473 block30 : { 11474 $2_1 = HEAP32[267018]; 11475 if ($2_1) { 11476 $0_1 = 1067772; 11477 while (1) { 11478 $3_1 = HEAP32[$0_1 >> 2]; 11479 $7_1 = HEAP32[$0_1 + 4 >> 2]; 11480 if (($3_1 + $7_1 | 0) == ($1_1 | 0)) { 11481 break block30 11482 } 11483 $0_1 = HEAP32[$0_1 + 8 >> 2]; 11484 if ($0_1) { 11485 continue 11486 } 11487 break; 11488 }; 11489 break block31; 11490 } 11491 $0_1 = HEAP32[267022]; 11492 if (!$0_1 | $0_1 >>> 0 > $1_1 >>> 0) { 11493 break block32 11494 } 11495 break block33; 11496 } 11497 if ($2_1 >>> 0 < $3_1 >>> 0 | $1_1 >>> 0 <= $2_1 >>> 0) { 11498 break block31 11499 } 11500 $3_1 = HEAP32[$0_1 + 12 >> 2]; 11501 if ($3_1 & 1) { 11502 break block31 11503 } 11504 if (($6_1 | 0) == ($3_1 >>> 1 | 0)) { 11505 break block34 11506 } 11507 } 11508 $0_1 = HEAP32[267022]; 11509 HEAP32[267022] = $0_1 >>> 0 < $1_1 >>> 0 ? $0_1 : $1_1; 11510 $3_1 = $1_1 + $4_1 | 0; 11511 $0_1 = 1067772; 11512 block37 : { 11513 block36 : { 11514 block35 : { 11515 while (1) { 11516 $7_1 = HEAP32[$0_1 >> 2]; 11517 if (($7_1 | 0) != ($3_1 | 0)) { 11518 $0_1 = HEAP32[$0_1 + 8 >> 2]; 11519 if ($0_1) { 11520 continue 11521 } 11522 break block35; 11523 } 11524 break; 11525 }; 11526 $3_1 = HEAP32[$0_1 + 12 >> 2]; 11527 if ($3_1 & 1) { 11528 break block35 11529 } 11530 if (($6_1 | 0) == ($3_1 >>> 1 | 0)) { 11531 break block36 11532 } 11533 } 11534 $0_1 = 1067772; 11535 while (1) { 11536 $3_1 = HEAP32[$0_1 >> 2]; 11537 if ($3_1 >>> 0 <= $2_1 >>> 0) { 11538 $7_1 = HEAP32[$0_1 + 4 >> 2] + $3_1 | 0; 11539 if ($7_1 >>> 0 > $2_1 >>> 0) { 11540 break block37 11541 } 11542 } 11543 $0_1 = HEAP32[$0_1 + 8 >> 2]; 11544 continue; 11545 }; 11546 } 11547 HEAP32[$0_1 >> 2] = $1_1; 11548 HEAP32[$0_1 + 4 >> 2] = $4_1 + HEAP32[$0_1 + 4 >> 2]; 11549 $2_1 = ($1_1 + 15 & -8) - 8 | 0; 11550 HEAP32[$2_1 + 4 >> 2] = $5_1 | 3; 11551 $1_1 = ($7_1 + 15 & -8) - 8 | 0; 11552 $0_1 = $2_1 + $5_1 | 0; 11553 $3_1 = $1_1 - $0_1 | 0; 11554 if (HEAP32[267018] == ($1_1 | 0)) { 11555 break block38 11556 } 11557 if (HEAP32[267017] == ($1_1 | 0)) { 11558 break block39 11559 } 11560 $5_1 = HEAP32[$1_1 + 4 >> 2]; 11561 if (($5_1 & 3) == 1) { 11562 $4_1 = $5_1 & -8; 11563 $101($1_1, $4_1); 11564 $1_1 = $1_1 + $4_1 | 0; 11565 $5_1 = HEAP32[$1_1 + 4 >> 2]; 11566 $3_1 = $3_1 + $4_1 | 0; 11567 } 11568 HEAP32[$1_1 + 4 >> 2] = $5_1 & -2; 11569 HEAP32[$0_1 + 4 >> 2] = $3_1 | 1; 11570 HEAP32[$0_1 + $3_1 >> 2] = $3_1; 11571 if ($3_1 >>> 0 >= 256) { 11572 $103($0_1, $3_1); 11573 break block40; 11574 } 11575 $1_1 = HEAP32[267013]; 11576 $4_1 = 1 << ($3_1 >>> 3); 11577 block41 : { 11578 if (!($1_1 & $4_1)) { 11579 HEAP32[267013] = $1_1 | $4_1; 11580 $3_1 = ($3_1 & 248) + 1067788 | 0; 11581 $5_1 = $3_1; 11582 break block41; 11583 } 11584 $1_1 = $3_1 & 248; 11585 $5_1 = $1_1 + 1067788 | 0; 11586 $3_1 = HEAP32[$1_1 + 1067796 >> 2]; 11587 } 11588 HEAP32[$5_1 + 8 >> 2] = $0_1; 11589 HEAP32[$3_1 + 12 >> 2] = $0_1; 11590 HEAP32[$0_1 + 12 >> 2] = $5_1; 11591 HEAP32[$0_1 + 8 >> 2] = $3_1; 11592 break block40; 11593 } 11594 $0_1 = $1_1 + 15 & -8; 11595 $3_1 = $0_1 - 8 | 0; 11596 HEAP32[267018] = $3_1; 11597 $8_1 = $4_1 - 40 | 0; 11598 $0_1 = ($8_1 + ($1_1 - $0_1 | 0) | 0) + 8 | 0; 11599 HEAP32[267016] = $0_1; 11600 HEAP32[$3_1 + 4 >> 2] = $0_1 | 1; 11601 HEAP32[($1_1 + $8_1 | 0) + 4 >> 2] = 40; 11602 HEAP32[267021] = 2097152; 11603 $0_1 = ($7_1 - 32 & -8) - 8 | 0; 11604 $3_1 = $2_1 + 16 >>> 0 > $0_1 >>> 0 ? $2_1 : $0_1; 11605 HEAP32[$3_1 + 4 >> 2] = 27; 11606 $0_1 = 1067772; 11607 $11_1 = HEAP32[$0_1 >> 2]; 11608 $8_1 = HEAP32[$0_1 + 4 >> 2]; 11609 $0_1 = 1067780; 11610 $12_1 = HEAP32[$0_1 >> 2]; 11611 $0_1 = HEAP32[$0_1 + 4 >> 2]; 11612 $10_1 = $3_1 + 16 | 0; 11613 HEAP32[$10_1 >> 2] = $12_1; 11614 HEAP32[$10_1 + 4 >> 2] = $0_1; 11615 $0_1 = $3_1 + 8 | 0; 11616 HEAP32[$0_1 >> 2] = $11_1; 11617 HEAP32[$0_1 + 4 >> 2] = $8_1; 11618 HEAP32[266946] = $6_1; 11619 HEAP32[266944] = $4_1; 11620 HEAP32[266943] = $1_1; 11621 HEAP32[266945] = $0_1; 11622 $0_1 = $3_1 + 28 | 0; 11623 while (1) { 11624 HEAP32[$0_1 >> 2] = 7; 11625 $0_1 = $0_1 + 4 | 0; 11626 if ($7_1 >>> 0 > $0_1 >>> 0) { 11627 continue 11628 } 11629 break; 11630 }; 11631 if (($2_1 | 0) == ($3_1 | 0)) { 11632 break block42 11633 } 11634 HEAP32[$3_1 + 4 >> 2] = HEAP32[$3_1 + 4 >> 2] & -2; 11635 $0_1 = $3_1 - $2_1 | 0; 11636 HEAP32[$2_1 + 4 >> 2] = $0_1 | 1; 11637 HEAP32[$3_1 >> 2] = $0_1; 11638 if ($0_1 >>> 0 >= 256) { 11639 $103($2_1, $0_1); 11640 break block42; 11641 } 11642 $1_1 = HEAP32[267013]; 11643 $4_1 = 1 << ($0_1 >>> 3); 11644 block43 : { 11645 if (!($1_1 & $4_1)) { 11646 HEAP32[267013] = $1_1 | $4_1; 11647 $0_1 = ($0_1 & 248) + 1067788 | 0; 11648 $1_1 = $0_1; 11649 break block43; 11650 } 11651 $0_1 = $0_1 & 248; 11652 $1_1 = $0_1 + 1067788 | 0; 11653 $0_1 = HEAP32[$0_1 + 1067796 >> 2]; 11654 } 11655 HEAP32[$1_1 + 8 >> 2] = $2_1; 11656 HEAP32[$0_1 + 12 >> 2] = $2_1; 11657 HEAP32[$2_1 + 12 >> 2] = $1_1; 11658 HEAP32[$2_1 + 8 >> 2] = $0_1; 11659 break block42; 11660 } 11661 $1_1 = $0_1 - $5_1 | 0; 11662 HEAP32[267016] = $1_1; 11663 $0_1 = HEAP32[267018]; 11664 $2_1 = $5_1 + $0_1 | 0; 11665 HEAP32[267018] = $2_1; 11666 HEAP32[$2_1 + 4 >> 2] = $1_1 | 1; 11667 HEAP32[$0_1 + 4 >> 2] = $5_1 | 3; 11668 $3_1 = $0_1 + 8 | 0; 11669 break block; 11670 } 11671 $0_1 = HEAP32[267017]; 11672 $2_1 = $1_1 - $5_1 | 0; 11673 block44 : { 11674 if ($2_1 >>> 0 <= 15) { 11675 HEAP32[267017] = 0; 11676 HEAP32[267015] = 0; 11677 HEAP32[$0_1 + 4 >> 2] = $1_1 | 3; 11678 $1_1 = $0_1 + $1_1 | 0; 11679 HEAP32[$1_1 + 4 >> 2] = HEAP32[$1_1 + 4 >> 2] | 1; 11680 break block44; 11681 } 11682 HEAP32[267015] = $2_1; 11683 $4_1 = $0_1 + $5_1 | 0; 11684 HEAP32[267017] = $4_1; 11685 HEAP32[$4_1 + 4 >> 2] = $2_1 | 1; 11686 HEAP32[$0_1 + $1_1 >> 2] = $2_1; 11687 HEAP32[$0_1 + 4 >> 2] = $5_1 | 3; 11688 } 11689 $3_1 = $0_1 + 8 | 0; 11690 break block; 11691 } 11692 HEAP32[$0_1 + 4 >> 2] = $4_1 + $7_1; 11693 $0_1 = HEAP32[267018]; 11694 $1_1 = $0_1 + 15 & -8; 11695 $2_1 = $1_1 - 8 | 0; 11696 HEAP32[267018] = $2_1; 11697 $4_1 = $4_1 + HEAP32[267016] | 0; 11698 $1_1 = ($4_1 + ($0_1 - $1_1 | 0) | 0) + 8 | 0; 11699 HEAP32[267016] = $1_1; 11700 HEAP32[$2_1 + 4 >> 2] = $1_1 | 1; 11701 HEAP32[($0_1 + $4_1 | 0) + 4 >> 2] = 40; 11702 HEAP32[267021] = 2097152; 11703 break block42; 11704 } 11705 HEAP32[267018] = $0_1; 11706 $1_1 = $3_1 + HEAP32[267016] | 0; 11707 HEAP32[267016] = $1_1; 11708 HEAP32[$0_1 + 4 >> 2] = $1_1 | 1; 11709 break block40; 11710 } 11711 HEAP32[267017] = $0_1; 11712 $1_1 = $3_1 + HEAP32[267015] | 0; 11713 HEAP32[267015] = $1_1; 11714 HEAP32[$0_1 + 4 >> 2] = $1_1 | 1; 11715 HEAP32[$0_1 + $1_1 >> 2] = $1_1; 11716 break block40; 11717 } 11718 HEAP32[267022] = $1_1; 11719 break block33; 11720 } 11721 $3_1 = $2_1 + 8 | 0; 11722 break block; 11723 } 11724 HEAP32[266946] = $6_1; 11725 HEAP32[266944] = $4_1; 11726 HEAP32[266943] = $1_1; 11727 HEAP32[266950] = 1067788; 11728 HEAP32[266952] = 1067796; 11729 HEAP32[266949] = 1067788; 11730 HEAP32[266954] = 1067804; 11731 HEAP32[266951] = 1067796; 11732 HEAP32[266956] = 1067812; 11733 HEAP32[266953] = 1067804; 11734 HEAP32[266958] = 1067820; 11735 HEAP32[266955] = 1067812; 11736 HEAP32[266960] = 1067828; 11737 HEAP32[266957] = 1067820; 11738 HEAP32[266962] = 1067836; 11739 HEAP32[266959] = 1067828; 11740 HEAP32[266964] = 1067844; 11741 HEAP32[266961] = 1067836; 11742 $0_1 = HEAP32[267025]; 11743 HEAP32[267023] = $0_1 ? $0_1 : -1; 11744 HEAP32[266966] = 1067852; 11745 HEAP32[266963] = 1067844; 11746 HEAP32[266965] = 1067852; 11747 HEAP32[266968] = 1067860; 11748 HEAP32[266967] = 1067860; 11749 HEAP32[266970] = 1067868; 11750 HEAP32[266969] = 1067868; 11751 HEAP32[266972] = 1067876; 11752 HEAP32[266971] = 1067876; 11753 HEAP32[266974] = 1067884; 11754 HEAP32[266973] = 1067884; 11755 HEAP32[266976] = 1067892; 11756 HEAP32[266975] = 1067892; 11757 HEAP32[266978] = 1067900; 11758 HEAP32[266980] = 1067908; 11759 HEAP32[266977] = 1067900; 11760 HEAP32[266979] = 1067908; 11761 HEAP32[266982] = 1067916; 11762 HEAP32[266984] = 1067924; 11763 HEAP32[266981] = 1067916; 11764 HEAP32[266983] = 1067924; 11765 HEAP32[266986] = 1067932; 11766 HEAP32[266985] = 1067932; 11767 HEAP32[266988] = 1067940; 11768 HEAP32[266987] = 1067940; 11769 HEAP32[266990] = 1067948; 11770 HEAP32[266989] = 1067948; 11771 HEAP32[266992] = 1067956; 11772 HEAP32[266991] = 1067956; 11773 HEAP32[266994] = 1067964; 11774 HEAP32[266993] = 1067964; 11775 HEAP32[266996] = 1067972; 11776 HEAP32[266995] = 1067972; 11777 HEAP32[266998] = 1067980; 11778 HEAP32[266997] = 1067980; 11779 HEAP32[267e3] = 1067988; 11780 HEAP32[267002] = 1067996; 11781 HEAP32[266999] = 1067988; 11782 HEAP32[267004] = 1068004; 11783 HEAP32[267001] = 1067996; 11784 HEAP32[267006] = 1068012; 11785 HEAP32[267003] = 1068004; 11786 HEAP32[267008] = 1068020; 11787 HEAP32[267005] = 1068012; 11788 HEAP32[267010] = 1068028; 11789 HEAP32[267007] = 1068020; 11790 HEAP32[267012] = 1068036; 11791 HEAP32[267009] = 1068028; 11792 $0_1 = $1_1 + 15 & -8; 11793 $2_1 = $0_1 - 8 | 0; 11794 HEAP32[267018] = $2_1; 11795 HEAP32[267011] = 1068036; 11796 $4_1 = $4_1 - 40 | 0; 11797 $0_1 = ($4_1 + ($1_1 - $0_1 | 0) | 0) + 8 | 0; 11798 HEAP32[267016] = $0_1; 11799 HEAP32[$2_1 + 4 >> 2] = $0_1 | 1; 11800 HEAP32[($1_1 + $4_1 | 0) + 4 >> 2] = 40; 11801 HEAP32[267021] = 2097152; 11802 } 11803 $3_1 = 0; 11804 $0_1 = HEAP32[267016]; 11805 if ($5_1 >>> 0 >= $0_1 >>> 0) { 11806 break block 11807 } 11808 $1_1 = $0_1 - $5_1 | 0; 11809 HEAP32[267016] = $1_1; 11810 $0_1 = HEAP32[267018]; 11811 $2_1 = $5_1 + $0_1 | 0; 11812 HEAP32[267018] = $2_1; 11813 HEAP32[$2_1 + 4 >> 2] = $1_1 | 1; 11814 HEAP32[$0_1 + 4 >> 2] = $5_1 | 3; 11815 $3_1 = $0_1 + 8 | 0; 11816 } 11817 global$0 = $9_1 + 16 | 0; 11818 return $3_1; 11819 } 11820 11821 function $99($0_1, $1_1) { 11822 var $2_1 = 0, $3_1 = 0; 11823 block : { 11824 $2_1 = HEAP32[$0_1 - 4 >> 2]; 11825 $3_1 = $2_1 & -8; 11826 $2_1 = $2_1 & 3; 11827 if ($3_1 >>> 0 >= $1_1 + ($2_1 ? 4 : 8) >>> 0) { 11828 if ($1_1 + 39 >>> 0 < $3_1 >>> 0 ? $2_1 : 0) { 11829 break block 11830 } 11831 $100($0_1); 11832 return; 11833 } 11834 $129(1059576, 46, 1059624); 11835 wasm2js_trap(); 11836 } 11837 $129(1059640, 46, 1059688); 11838 wasm2js_trap(); 11839 } 11840 11841 function $100($0_1) { 11842 var $1_1 = 0, $2_1 = 0, $3_1 = 0, $4_1 = 0; 11843 $1_1 = $0_1 - 8 | 0; 11844 $3_1 = HEAP32[$0_1 - 4 >> 2]; 11845 $0_1 = $3_1 & -8; 11846 $2_1 = $1_1 + $0_1 | 0; 11847 block1 : { 11848 block : { 11849 if ($3_1 & 1) { 11850 break block 11851 } 11852 if (!($3_1 & 2)) { 11853 break block1 11854 } 11855 $3_1 = HEAP32[$1_1 >> 2]; 11856 $0_1 = $0_1 + $3_1 | 0; 11857 $1_1 = $1_1 - $3_1 | 0; 11858 if (($1_1 | 0) == HEAP32[267017]) { 11859 if ((HEAP32[$2_1 + 4 >> 2] & 3) != 3) { 11860 break block 11861 } 11862 HEAP32[267015] = $0_1; 11863 HEAP32[$2_1 + 4 >> 2] = HEAP32[$2_1 + 4 >> 2] & -2; 11864 HEAP32[$1_1 + 4 >> 2] = $0_1 | 1; 11865 HEAP32[$2_1 >> 2] = $0_1; 11866 return; 11867 } 11868 $101($1_1, $3_1); 11869 } 11870 block7 : { 11871 block8 : { 11872 block3 : { 11873 block6 : { 11874 block5 : { 11875 block2 : { 11876 $3_1 = HEAP32[$2_1 + 4 >> 2]; 11877 block4 : { 11878 if (!($3_1 & 2)) { 11879 if (HEAP32[267018] == ($2_1 | 0)) { 11880 break block2 11881 } 11882 if (HEAP32[267017] == ($2_1 | 0)) { 11883 break block3 11884 } 11885 $4_1 = $2_1; 11886 $2_1 = $3_1 & -8; 11887 $101($4_1, $2_1); 11888 $0_1 = $0_1 + $2_1 | 0; 11889 HEAP32[$1_1 + 4 >> 2] = $0_1 | 1; 11890 HEAP32[$0_1 + $1_1 >> 2] = $0_1; 11891 if (HEAP32[267017] != ($1_1 | 0)) { 11892 break block4 11893 } 11894 HEAP32[267015] = $0_1; 11895 return; 11896 } 11897 HEAP32[$2_1 + 4 >> 2] = $3_1 & -2; 11898 HEAP32[$1_1 + 4 >> 2] = $0_1 | 1; 11899 HEAP32[$0_1 + $1_1 >> 2] = $0_1; 11900 } 11901 if ($0_1 >>> 0 < 256) { 11902 break block5 11903 } 11904 $103($1_1, $0_1); 11905 $1_1 = 0; 11906 $0_1 = HEAP32[267023] - 1 | 0; 11907 HEAP32[267023] = $0_1; 11908 if (!$0_1) { 11909 break block6 11910 } 11911 break block1; 11912 } 11913 HEAP32[267018] = $1_1; 11914 $0_1 = $0_1 + HEAP32[267016] | 0; 11915 HEAP32[267016] = $0_1; 11916 HEAP32[$1_1 + 4 >> 2] = $0_1 | 1; 11917 if (($1_1 | 0) == HEAP32[267017]) { 11918 HEAP32[267015] = 0; 11919 HEAP32[267017] = 0; 11920 } 11921 $2_1 = HEAP32[267021]; 11922 if ($2_1 >>> 0 >= $0_1 >>> 0) { 11923 break block1 11924 } 11925 $1_1 = HEAP32[267024]; 11926 if ((-48 - $1_1 & -9) == 3) { 11927 break block1 11928 } 11929 $0_1 = HEAP32[267018]; 11930 if (!$0_1) { 11931 break block1 11932 } 11933 $3_1 = HEAP32[267016]; 11934 if ($3_1 >>> 0 < 41) { 11935 break block7 11936 } 11937 if (!$1_1) { 11938 break block8 11939 } 11940 $1_1 = 1067772; 11941 while (1) { 11942 $4_1 = HEAP32[$1_1 >> 2]; 11943 if ($4_1 >>> 0 <= $0_1 >>> 0 & HEAP32[$1_1 + 4 >> 2] + $4_1 >>> 0 > $0_1 >>> 0) { 11944 break block7 11945 } 11946 $1_1 = HEAP32[$1_1 + 8 >> 2]; 11947 continue; 11948 }; 11949 } 11950 $2_1 = HEAP32[267013]; 11951 $3_1 = 1 << ($0_1 >>> 3); 11952 block9 : { 11953 if (!($2_1 & $3_1)) { 11954 HEAP32[267013] = $2_1 | $3_1; 11955 $0_1 = ($0_1 & 248) + 1067788 | 0; 11956 $2_1 = $0_1; 11957 break block9; 11958 } 11959 $0_1 = $0_1 & 248; 11960 $2_1 = $0_1 + 1067788 | 0; 11961 $0_1 = HEAP32[$0_1 + 1067796 >> 2]; 11962 } 11963 HEAP32[$2_1 + 8 >> 2] = $1_1; 11964 HEAP32[$0_1 + 12 >> 2] = $1_1; 11965 HEAP32[$1_1 + 12 >> 2] = $2_1; 11966 HEAP32[$1_1 + 8 >> 2] = $0_1; 11967 return; 11968 } 11969 $0_1 = HEAP32[266945]; 11970 if ($0_1) { 11971 while (1) { 11972 $1_1 = $1_1 + 1 | 0; 11973 $0_1 = HEAP32[$0_1 + 8 >> 2]; 11974 if ($0_1) { 11975 continue 11976 } 11977 break; 11978 } 11979 } 11980 $0_1 = HEAP32[267025]; 11981 HEAP32[267023] = $0_1 ? ($0_1 >>> 0 > $1_1 >>> 0 ? $0_1 : $1_1) : -1; 11982 return; 11983 } 11984 HEAP32[267017] = $1_1; 11985 $0_1 = $0_1 + HEAP32[267015] | 0; 11986 HEAP32[267015] = $0_1; 11987 HEAP32[$1_1 + 4 >> 2] = $0_1 | 1; 11988 HEAP32[$0_1 + $1_1 >> 2] = $0_1; 11989 return; 11990 } 11991 $155(1059704); 11992 wasm2js_trap(); 11993 } 11994 $1_1 = 0; 11995 $0_1 = HEAP32[266945]; 11996 if ($0_1) { 11997 while (1) { 11998 $1_1 = $1_1 + 1 | 0; 11999 $0_1 = HEAP32[$0_1 + 8 >> 2]; 12000 if ($0_1) { 12001 continue 12002 } 12003 break; 12004 } 12005 } 12006 $0_1 = HEAP32[267025]; 12007 HEAP32[267023] = $0_1 ? ($0_1 >>> 0 > $1_1 >>> 0 ? $0_1 : $1_1) : -1; 12008 if ($2_1 >>> 0 >= $3_1 >>> 0) { 12009 break block1 12010 } 12011 HEAP32[267021] = -1; 12012 } 12013 } 12014 12015 function $101($0_1, $1_1) { 12016 var $2_1 = 0, $3_1 = 0, $4_1 = 0, $5_1 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; 12017 $2_1 = HEAP32[$0_1 + 12 >> 2]; 12018 block5 : { 12019 block2 : { 12020 block4 : { 12021 if ($1_1 >>> 0 >= 256) { 12022 $3_1 = HEAP32[$0_1 + 24 >> 2]; 12023 block1 : { 12024 block : { 12025 if (($0_1 | 0) == ($2_1 | 0)) { 12026 $2_1 = HEAP32[$0_1 + 20 >> 2]; 12027 $1_1 = HEAP32[($2_1 ? 20 : 16) + $0_1 >> 2]; 12028 if ($1_1) { 12029 break block 12030 } 12031 $2_1 = 0; 12032 break block1; 12033 } 12034 $1_1 = HEAP32[$0_1 + 8 >> 2]; 12035 HEAP32[$1_1 + 12 >> 2] = $2_1; 12036 HEAP32[$2_1 + 8 >> 2] = $1_1; 12037 break block1; 12038 } 12039 $4_1 = $2_1 ? $0_1 + 20 | 0 : $0_1 + 16 | 0; 12040 while (1) { 12041 $5_1 = $4_1; 12042 $2_1 = $1_1; 12043 $1_1 = HEAP32[$2_1 + 20 >> 2]; 12044 $4_1 = $1_1 ? $2_1 + 20 | 0 : $2_1 + 16 | 0; 12045 $1_1 = HEAP32[($1_1 ? 20 : 16) + $2_1 >> 2]; 12046 if ($1_1) { 12047 continue 12048 } 12049 break; 12050 }; 12051 HEAP32[$5_1 >> 2] = 0; 12052 } 12053 if (!$3_1) { 12054 break block2 12055 } 12056 block3 : { 12057 $1_1 = (HEAP32[$0_1 + 28 >> 2] << 2) + 1067644 | 0; 12058 if (($0_1 | 0) != HEAP32[$1_1 >> 2]) { 12059 if (($0_1 | 0) == HEAP32[$3_1 + 16 >> 2]) { 12060 break block3 12061 } 12062 HEAP32[$3_1 + 20 >> 2] = $2_1; 12063 if ($2_1) { 12064 break block4 12065 } 12066 break block2; 12067 } 12068 HEAP32[$1_1 >> 2] = $2_1; 12069 if (!$2_1) { 12070 break block5 12071 } 12072 break block4; 12073 } 12074 HEAP32[$3_1 + 16 >> 2] = $2_1; 12075 if ($2_1) { 12076 break block4 12077 } 12078 break block2; 12079 } 12080 $0_1 = HEAP32[$0_1 + 8 >> 2]; 12081 if (($2_1 | 0) != ($0_1 | 0)) { 12082 HEAP32[$0_1 + 12 >> 2] = $2_1; 12083 HEAP32[$2_1 + 8 >> 2] = $0_1; 12084 return; 12085 } 12086 (wasm2js_i32$0 = 1068052, wasm2js_i32$1 = HEAP32[267013] & __wasm_rotl_i32($1_1 >>> 3 | 0)), HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1; 12087 return; 12088 } 12089 HEAP32[$2_1 + 24 >> 2] = $3_1; 12090 $1_1 = HEAP32[$0_1 + 16 >> 2]; 12091 if ($1_1) { 12092 HEAP32[$2_1 + 16 >> 2] = $1_1; 12093 HEAP32[$1_1 + 24 >> 2] = $2_1; 12094 } 12095 $0_1 = HEAP32[$0_1 + 20 >> 2]; 12096 if (!$0_1) { 12097 break block2 12098 } 12099 HEAP32[$2_1 + 20 >> 2] = $0_1; 12100 HEAP32[$0_1 + 24 >> 2] = $2_1; 12101 return; 12102 } 12103 return; 12104 } 12105 (wasm2js_i32$0 = 1068056, wasm2js_i32$1 = HEAP32[267014] & __wasm_rotl_i32(HEAP32[$0_1 + 28 >> 2])), HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1; 12106 } 12107 12108 function $102($0_1, $1_1) { 12109 var $2_1 = 0, $3_1 = 0, $4_1 = 0; 12110 $2_1 = $0_1 + $1_1 | 0; 12111 block3 : { 12112 $3_1 = HEAP32[$0_1 + 4 >> 2]; 12113 block1 : { 12114 block : { 12115 if ($3_1 & 1) { 12116 break block 12117 } 12118 if (!($3_1 & 2)) { 12119 break block1 12120 } 12121 $3_1 = HEAP32[$0_1 >> 2]; 12122 $1_1 = $1_1 + $3_1 | 0; 12123 $0_1 = $0_1 - $3_1 | 0; 12124 if (($0_1 | 0) == HEAP32[267017]) { 12125 if ((HEAP32[$2_1 + 4 >> 2] & 3) != 3) { 12126 break block 12127 } 12128 HEAP32[267015] = $1_1; 12129 HEAP32[$2_1 + 4 >> 2] = HEAP32[$2_1 + 4 >> 2] & -2; 12130 HEAP32[$0_1 + 4 >> 2] = $1_1 | 1; 12131 HEAP32[$2_1 >> 2] = $1_1; 12132 return; 12133 } 12134 $101($0_1, $3_1); 12135 } 12136 block2 : { 12137 $3_1 = HEAP32[$2_1 + 4 >> 2]; 12138 block4 : { 12139 if (!($3_1 & 2)) { 12140 if (HEAP32[267018] == ($2_1 | 0)) { 12141 break block2 12142 } 12143 if (HEAP32[267017] == ($2_1 | 0)) { 12144 break block3 12145 } 12146 $4_1 = $2_1; 12147 $2_1 = $3_1 & -8; 12148 $101($4_1, $2_1); 12149 $1_1 = $1_1 + $2_1 | 0; 12150 HEAP32[$0_1 + 4 >> 2] = $1_1 | 1; 12151 HEAP32[$0_1 + $1_1 >> 2] = $1_1; 12152 if (HEAP32[267017] != ($0_1 | 0)) { 12153 break block4 12154 } 12155 HEAP32[267015] = $1_1; 12156 return; 12157 } 12158 HEAP32[$2_1 + 4 >> 2] = $3_1 & -2; 12159 HEAP32[$0_1 + 4 >> 2] = $1_1 | 1; 12160 HEAP32[$0_1 + $1_1 >> 2] = $1_1; 12161 } 12162 if ($1_1 >>> 0 >= 256) { 12163 $103($0_1, $1_1); 12164 return; 12165 } 12166 $2_1 = HEAP32[267013]; 12167 $3_1 = 1 << ($1_1 >>> 3); 12168 block5 : { 12169 if (!($2_1 & $3_1)) { 12170 HEAP32[267013] = $2_1 | $3_1; 12171 $1_1 = ($1_1 & 248) + 1067788 | 0; 12172 $2_1 = $1_1; 12173 break block5; 12174 } 12175 $1_1 = $1_1 & 248; 12176 $2_1 = $1_1 + 1067788 | 0; 12177 $1_1 = HEAP32[$1_1 + 1067796 >> 2]; 12178 } 12179 HEAP32[$2_1 + 8 >> 2] = $0_1; 12180 HEAP32[$1_1 + 12 >> 2] = $0_1; 12181 HEAP32[$0_1 + 12 >> 2] = $2_1; 12182 HEAP32[$0_1 + 8 >> 2] = $1_1; 12183 return; 12184 } 12185 HEAP32[267018] = $0_1; 12186 $1_1 = $1_1 + HEAP32[267016] | 0; 12187 HEAP32[267016] = $1_1; 12188 HEAP32[$0_1 + 4 >> 2] = $1_1 | 1; 12189 if (HEAP32[267017] != ($0_1 | 0)) { 12190 break block1 12191 } 12192 HEAP32[267015] = 0; 12193 HEAP32[267017] = 0; 12194 } 12195 return; 12196 } 12197 HEAP32[267017] = $0_1; 12198 $1_1 = $1_1 + HEAP32[267015] | 0; 12199 HEAP32[267015] = $1_1; 12200 HEAP32[$0_1 + 4 >> 2] = $1_1 | 1; 12201 HEAP32[$0_1 + $1_1 >> 2] = $1_1; 12202 } 12203 12204 function $103($0_1, $1_1) { 12205 var $2_1 = 0, $3_1 = 0, $4_1 = 0, $5_1 = 0; 12206 HEAP32[$0_1 + 16 >> 2] = 0; 12207 HEAP32[$0_1 + 20 >> 2] = 0; 12208 $3_1 = $1_1 >>> 8 | 0; 12209 $2_1 = 0; 12210 block : { 12211 if (!$3_1) { 12212 break block 12213 } 12214 $2_1 = 31; 12215 if ($1_1 >>> 0 >= 16777216) { 12216 break block 12217 } 12218 $3_1 = Math_clz32($3_1); 12219 $2_1 = ($1_1 >>> 38 - $3_1 & 1 | $3_1 << 1) ^ 62; 12220 } 12221 HEAP32[$0_1 + 28 >> 2] = $2_1; 12222 $4_1 = ($2_1 << 2) + 1067644 | 0; 12223 $3_1 = 1 << $2_1; 12224 if (!($3_1 & HEAP32[267014])) { 12225 HEAP32[$4_1 >> 2] = $0_1; 12226 HEAP32[$0_1 + 24 >> 2] = $4_1; 12227 HEAP32[$0_1 + 12 >> 2] = $0_1; 12228 HEAP32[$0_1 + 8 >> 2] = $0_1; 12229 HEAP32[267014] = $3_1 | HEAP32[267014]; 12230 return; 12231 } 12232 block2 : { 12233 $3_1 = HEAP32[$4_1 >> 2]; 12234 block1 : { 12235 if ((HEAP32[$3_1 + 4 >> 2] & -8) == ($1_1 | 0)) { 12236 $2_1 = $3_1; 12237 break block1; 12238 } 12239 $5_1 = $1_1 << (($2_1 | 0) != 31 ? 25 - ($2_1 >>> 1 | 0) | 0 : 0); 12240 while (1) { 12241 $4_1 = ($5_1 >>> 29 & 4) + $3_1 | 0; 12242 $2_1 = HEAP32[$4_1 + 16 >> 2]; 12243 if (!$2_1) { 12244 break block2 12245 } 12246 $5_1 = $5_1 << 1; 12247 $3_1 = $2_1; 12248 if (($1_1 | 0) != (HEAP32[$2_1 + 4 >> 2] & -8)) { 12249 continue 12250 } 12251 break; 12252 }; 12253 } 12254 $1_1 = HEAP32[$2_1 + 8 >> 2]; 12255 HEAP32[$1_1 + 12 >> 2] = $0_1; 12256 HEAP32[$2_1 + 8 >> 2] = $0_1; 12257 HEAP32[$0_1 + 24 >> 2] = 0; 12258 HEAP32[$0_1 + 12 >> 2] = $2_1; 12259 HEAP32[$0_1 + 8 >> 2] = $1_1; 12260 return; 12261 } 12262 HEAP32[$4_1 + 16 >> 2] = $0_1; 12263 HEAP32[$0_1 + 24 >> 2] = $3_1; 12264 HEAP32[$0_1 + 12 >> 2] = $0_1; 12265 HEAP32[$0_1 + 8 >> 2] = $0_1; 12266 } 12267 12268 function $104($0_1, $1_1) { 12269 $0_1 = $0_1 | 0; 12270 $1_1 = $1_1 | 0; 12271 var $2_1 = 0; 12272 $1_1 = 1059568; 12273 $2_1 = HEAP32[$1_1 >> 2]; 12274 $1_1 = HEAP32[$1_1 + 4 >> 2]; 12275 HEAP32[$0_1 + 8 >> 2] = $2_1; 12276 HEAP32[$0_1 + 12 >> 2] = $1_1; 12277 $1_1 = 1059560; 12278 $2_1 = HEAP32[$1_1 >> 2]; 12279 $1_1 = HEAP32[$1_1 + 4 >> 2]; 12280 HEAP32[$0_1 >> 2] = $2_1; 12281 HEAP32[$0_1 + 4 >> 2] = $1_1; 12282 } 12283 12284 function $105($0_1, $1_1) { 12285 $0_1 = $0_1 | 0; 12286 $1_1 = $1_1 | 0; 12287 var $2_1 = 0; 12288 $1_1 = 1059552; 12289 $2_1 = HEAP32[$1_1 >> 2]; 12290 $1_1 = HEAP32[$1_1 + 4 >> 2]; 12291 HEAP32[$0_1 + 8 >> 2] = $2_1; 12292 HEAP32[$0_1 + 12 >> 2] = $1_1; 12293 $1_1 = 1059544; 12294 $2_1 = HEAP32[$1_1 >> 2]; 12295 $1_1 = HEAP32[$1_1 + 4 >> 2]; 12296 HEAP32[$0_1 >> 2] = $2_1; 12297 HEAP32[$0_1 + 4 >> 2] = $1_1; 12298 } 12299 12300 function $106($0_1, $1_1) { 12301 $0_1 = $0_1 | 0; 12302 $1_1 = $1_1 | 0; 12303 if (HEAP32[$0_1 >> 2] != -1) { 12304 return $145($1_1, HEAP32[$0_1 + 4 >> 2], HEAP32[$0_1 + 8 >> 2]) | 0 12305 } 12306 $0_1 = HEAP32[HEAP32[$0_1 + 12 >> 2] >> 2]; 12307 return $133(HEAP32[$1_1 >> 2], HEAP32[$1_1 + 4 >> 2], HEAP32[$0_1 >> 2], HEAP32[$0_1 + 4 >> 2]) | 0; 12308 } 12309 12310 function $107($0_1, $1_1) { 12311 $0_1 = $0_1 | 0; 12312 $1_1 = $1_1 | 0; 12313 HEAP32[$0_1 + 4 >> 2] = 1059764; 12314 HEAP32[$0_1 >> 2] = $1_1; 12315 } 12316 12317 function $108($0_1, $1_1) { 12318 $0_1 = $0_1 | 0; 12319 $1_1 = $1_1 | 0; 12320 var $2_1 = 0; 12321 $2_1 = HEAP32[$1_1 + 4 >> 2]; 12322 HEAP32[$0_1 >> 2] = HEAP32[$1_1 >> 2]; 12323 HEAP32[$0_1 + 4 >> 2] = $2_1; 12324 } 12325 12326 function $109($0_1, $1_1) { 12327 $0_1 = $0_1 | 0; 12328 $1_1 = $1_1 | 0; 12329 var $2_1 = 0, $3_1 = 0; 12330 $2_1 = HEAP32[$1_1 + 4 >> 2]; 12331 $3_1 = HEAP32[$1_1 >> 2]; 12332 $1_1 = $33(8, 4); 12333 if (!$1_1) { 12334 $123(4, 8); 12335 wasm2js_trap(); 12336 } 12337 HEAP32[$1_1 + 4 >> 2] = $2_1; 12338 HEAP32[$1_1 >> 2] = $3_1; 12339 HEAP32[$0_1 + 4 >> 2] = 1059764; 12340 HEAP32[$0_1 >> 2] = $1_1; 12341 } 12342 12343 function $110($0_1, $1_1) { 12344 $0_1 = $0_1 | 0; 12345 $1_1 = $1_1 | 0; 12346 var $2_1 = 0, $3_1 = 0, $4_1 = 0, $5_1 = 0, $6_1 = 0, $7_1 = 0; 12347 $5_1 = HEAP32[$0_1 + 8 >> 2]; 12348 $3_1 = 1; 12349 block : { 12350 if ($1_1 >>> 0 < 128) { 12351 break block 12352 } 12353 $3_1 = 2; 12354 if ($1_1 >>> 0 < 2048) { 12355 break block 12356 } 12357 $3_1 = $1_1 >>> 0 < 65536 ? 3 : 4; 12358 } 12359 if ($3_1 >>> 0 > HEAP32[$0_1 >> 2] - $5_1 >>> 0) { 12360 $94($0_1, $5_1, $3_1) 12361 } 12362 $2_1 = $5_1 + HEAP32[$0_1 + 4 >> 2] | 0; 12363 block1 : { 12364 if ($1_1 >>> 0 >= 128) { 12365 $6_1 = $1_1 & 63 | -128; 12366 $4_1 = $1_1 >>> 6 | 0; 12367 if ($1_1 >>> 0 < 2048) { 12368 HEAP8[$2_1 + 1 | 0] = $6_1; 12369 HEAP8[$2_1 | 0] = $4_1 | 192; 12370 break block1; 12371 } 12372 $7_1 = $1_1 >>> 12 | 0; 12373 $4_1 = $4_1 & 63 | -128; 12374 if ($1_1 >>> 0 <= 65535) { 12375 HEAP8[$2_1 + 2 | 0] = $6_1; 12376 HEAP8[$2_1 + 1 | 0] = $4_1; 12377 HEAP8[$2_1 | 0] = $7_1 | 224; 12378 break block1; 12379 } 12380 HEAP8[$2_1 + 3 | 0] = $6_1; 12381 HEAP8[$2_1 + 2 | 0] = $4_1; 12382 HEAP8[$2_1 + 1 | 0] = $7_1 & 63 | -128; 12383 HEAP8[$2_1 | 0] = $1_1 >>> 18 | -16; 12384 break block1; 12385 } 12386 HEAP8[$2_1 | 0] = $1_1; 12387 } 12388 HEAP32[$0_1 + 8 >> 2] = $5_1 + $3_1; 12389 return 0; 12390 } 12391 12392 function $111($0_1, $1_1, $2_1) { 12393 $0_1 = $0_1 | 0; 12394 $1_1 = $1_1 | 0; 12395 $2_1 = $2_1 | 0; 12396 var $3_1 = 0; 12397 $3_1 = HEAP32[$0_1 + 8 >> 2]; 12398 block1 : { 12399 block : { 12400 if ($2_1 >>> 0 > HEAP32[$0_1 >> 2] - $3_1 >>> 0) { 12401 $94($0_1, $3_1, $2_1); 12402 $3_1 = HEAP32[$0_1 + 8 >> 2]; 12403 break block; 12404 } 12405 if (!$2_1) { 12406 break block1 12407 } 12408 } 12409 if (!$2_1) { 12410 break block1 12411 } 12412 wasm2js_memory_copy($3_1 + HEAP32[$0_1 + 4 >> 2] | 0, $1_1, $2_1); 12413 } 12414 HEAP32[$0_1 + 8 >> 2] = $2_1 + $3_1; 12415 return 0; 12416 } 12417 12418 function $112($0_1, $1_1) { 12419 $0_1 = $0_1 | 0; 12420 $1_1 = $1_1 | 0; 12421 var $2_1 = 0, $3_1 = 0, $4_1 = 0, $5_1 = 0; 12422 $2_1 = global$0 - 32 | 0; 12423 global$0 = $2_1; 12424 if (HEAP32[$1_1 >> 2] == -1) { 12425 $3_1 = HEAP32[$1_1 + 12 >> 2]; 12426 HEAP32[$2_1 + 28 >> 2] = 0; 12427 HEAP32[$2_1 + 20 >> 2] = 0; 12428 HEAP32[$2_1 + 24 >> 2] = 1; 12429 $3_1 = HEAP32[$3_1 >> 2]; 12430 $133($2_1 + 20 | 0, 1059464, HEAP32[$3_1 >> 2], HEAP32[$3_1 + 4 >> 2]); 12431 $3_1 = HEAP32[$2_1 + 28 >> 2]; 12432 HEAP32[$2_1 + 16 >> 2] = $3_1; 12433 $4_1 = HEAP32[$2_1 + 24 >> 2]; 12434 $5_1 = HEAP32[$2_1 + 20 >> 2]; 12435 HEAP32[$2_1 + 8 >> 2] = $5_1; 12436 HEAP32[$2_1 + 12 >> 2] = $4_1; 12437 HEAP32[$1_1 + 8 >> 2] = $3_1; 12438 HEAP32[$1_1 >> 2] = $5_1; 12439 HEAP32[$1_1 + 4 >> 2] = $4_1; 12440 } 12441 HEAP32[$0_1 + 4 >> 2] = 1059780; 12442 HEAP32[$0_1 >> 2] = $1_1; 12443 global$0 = $2_1 + 32 | 0; 12444 } 12445 12446 function $113($0_1, $1_1) { 12447 $0_1 = $0_1 | 0; 12448 $1_1 = $1_1 | 0; 12449 var $2_1 = 0, $3_1 = 0, $4_1 = 0, $5_1 = 0; 12450 $2_1 = global$0 - 32 | 0; 12451 global$0 = $2_1; 12452 if (HEAP32[$1_1 >> 2] == -1) { 12453 $3_1 = HEAP32[$1_1 + 12 >> 2]; 12454 HEAP32[$2_1 + 24 >> 2] = 0; 12455 HEAP32[$2_1 + 16 >> 2] = 0; 12456 HEAP32[$2_1 + 20 >> 2] = 1; 12457 $3_1 = HEAP32[$3_1 >> 2]; 12458 $133($2_1 + 16 | 0, 1059464, HEAP32[$3_1 >> 2], HEAP32[$3_1 + 4 >> 2]); 12459 $3_1 = HEAP32[$2_1 + 24 >> 2]; 12460 HEAP32[$2_1 + 8 >> 2] = $3_1; 12461 $4_1 = HEAP32[$2_1 + 20 >> 2]; 12462 $5_1 = HEAP32[$2_1 + 16 >> 2]; 12463 HEAP32[$2_1 >> 2] = $5_1; 12464 HEAP32[$2_1 + 4 >> 2] = $4_1; 12465 HEAP32[$1_1 + 8 >> 2] = $3_1; 12466 HEAP32[$1_1 >> 2] = $5_1; 12467 HEAP32[$1_1 + 4 >> 2] = $4_1; 12468 } 12469 $3_1 = HEAP32[$1_1 + 8 >> 2]; 12470 HEAP32[$1_1 + 8 >> 2] = 0; 12471 $5_1 = HEAP32[$1_1 >> 2]; 12472 $4_1 = HEAP32[$1_1 + 4 >> 2]; 12473 HEAP32[$1_1 >> 2] = 0; 12474 HEAP32[$1_1 + 4 >> 2] = 1; 12475 HEAP32[$2_1 + 24 >> 2] = $3_1; 12476 HEAP32[$2_1 + 16 >> 2] = $5_1; 12477 HEAP32[$2_1 + 20 >> 2] = $4_1; 12478 $1_1 = $33(12, 4); 12479 if (!$1_1) { 12480 $123(4, 12); 12481 wasm2js_trap(); 12482 } 12483 HEAP32[$1_1 + 8 >> 2] = HEAP32[$2_1 + 24 >> 2]; 12484 $4_1 = HEAP32[$2_1 + 20 >> 2]; 12485 HEAP32[$1_1 >> 2] = HEAP32[$2_1 + 16 >> 2]; 12486 HEAP32[$1_1 + 4 >> 2] = $4_1; 12487 HEAP32[$0_1 + 4 >> 2] = 1059780; 12488 HEAP32[$0_1 >> 2] = $1_1; 12489 global$0 = $2_1 + 32 | 0; 12490 } 12491 12492 function $114($0_1, $1_1) { 12493 $0_1 = $0_1 | 0; 12494 $1_1 = $1_1 | 0; 12495 HEAP32[$0_1 >> 2] = 0; 12496 } 12497 12498 function $115($0_1, $1_1, $2_1) { 12499 $0_1 = $0_1 | 0; 12500 $1_1 = $1_1 | 0; 12501 $2_1 = $2_1 | 0; 12502 return $133($0_1, 1059464, $1_1, $2_1) | 0; 12503 } 12504 12505 function $116($0_1, $1_1, $2_1, $3_1) { 12506 if ($1_1 >>> 0 >= $3_1 >>> 0) { 12507 $0_1 = $168($2_1, $0_1, $3_1) 12508 } else { 12509 $0_1 = 1 12510 } 12511 return !$0_1; 12512 } 12513 12514 function $117($0_1, $1_1) { 12515 $0_1 = $0_1 | 0; 12516 $1_1 = $1_1 | 0; 12517 return $159(HEAP32[$0_1 >> 2], HEAP32[$0_1 + 4 >> 2], $1_1) | 0; 12518 } 12519 12520 function $118($0_1, $1_1) { 12521 $0_1 = $0_1 | 0; 12522 $1_1 = $1_1 | 0; 12523 return $144($1_1, HEAP32[$0_1 >> 2], HEAP32[$0_1 + 4 >> 2]) | 0; 12524 } 12525 12526 function $119($0_1, $1_1, $2_1) { 12527 var $3_1 = 0, $4_1 = 0; 12528 $3_1 = global$0 - 16 | 0; 12529 global$0 = $3_1; 12530 $1_1 = $1_1 + $2_1 | 0; 12531 if ($1_1 >>> 0 < $2_1 >>> 0) { 12532 $120(0, 0); 12533 wasm2js_trap(); 12534 } 12535 $2_1 = HEAP32[$0_1 >> 2]; 12536 $4_1 = $2_1; 12537 $2_1 = $2_1 << 1; 12538 $1_1 = $1_1 >>> 0 > $2_1 >>> 0 ? $1_1 : $2_1; 12539 $1_1 = $1_1 >>> 0 <= 8 ? 8 : $1_1; 12540 $121($3_1 + 4 | 0, $4_1, HEAP32[$0_1 + 4 >> 2], $1_1); 12541 if (HEAP32[$3_1 + 4 >> 2] == 1) { 12542 $120(HEAP32[$3_1 + 8 >> 2], HEAP32[$3_1 + 12 >> 2]); 12543 wasm2js_trap(); 12544 } 12545 $2_1 = HEAP32[$3_1 + 8 >> 2]; 12546 HEAP32[$0_1 >> 2] = $1_1; 12547 HEAP32[$0_1 + 4 >> 2] = $2_1; 12548 global$0 = $3_1 + 16 | 0; 12549 } 12550 12551 function $120($0_1, $1_1) { 12552 if ($0_1) { 12553 $123($0_1, $1_1); 12554 wasm2js_trap(); 12555 } 12556 $134(1059852, 35, 1059872); 12557 wasm2js_trap(); 12558 } 12559 12560 function $121($0_1, $1_1, $2_1, $3_1) { 12561 block : { 12562 if (($3_1 | 0) < 0) { 12563 $1_1 = 1; 12564 $3_1 = 0; 12565 $2_1 = 4; 12566 break block; 12567 } 12568 block3 : { 12569 block2 : { 12570 block1 : { 12571 if ($1_1) { 12572 $1_1 = $34($2_1, $1_1, 1, $3_1); 12573 break block1; 12574 } 12575 if (!$3_1) { 12576 $1_1 = 1; 12577 break block2; 12578 } 12579 $1_1 = $33($3_1, 1); 12580 } 12581 if ($1_1) { 12582 break block2 12583 } 12584 HEAP32[$0_1 + 4 >> 2] = 1; 12585 $1_1 = 1; 12586 break block3; 12587 } 12588 HEAP32[$0_1 + 4 >> 2] = $1_1; 12589 $1_1 = 0; 12590 } 12591 $2_1 = 8; 12592 } 12593 HEAP32[$2_1 + $0_1 >> 2] = $3_1; 12594 HEAP32[$0_1 >> 2] = $1_1; 12595 } 12596 12597 function $122($0_1) { 12598 var $1_1 = 0, $2_1 = 0, $3_1 = 0; 12599 $2_1 = global$0 - 16 | 0; 12600 global$0 = $2_1; 12601 $1_1 = HEAP32[$0_1 >> 2]; 12602 $3_1 = $1_1; 12603 $1_1 = $1_1 << 1; 12604 $1_1 = $1_1 >>> 0 <= 8 ? 8 : $1_1; 12605 $121($2_1 + 4 | 0, $3_1, HEAP32[$0_1 + 4 >> 2], $1_1); 12606 if (HEAP32[$2_1 + 4 >> 2] == 1) { 12607 $120(HEAP32[$2_1 + 8 >> 2], HEAP32[$2_1 + 12 >> 2]); 12608 wasm2js_trap(); 12609 } 12610 $3_1 = HEAP32[$2_1 + 8 >> 2]; 12611 HEAP32[$0_1 >> 2] = $1_1; 12612 HEAP32[$0_1 + 4 >> 2] = $3_1; 12613 global$0 = $2_1 + 16 | 0; 12614 } 12615 12616 function $123($0_1, $1_1) { 12617 var $2_1 = 0; 12618 $2_1 = global$0 - 16 | 0; 12619 global$0 = $2_1; 12620 HEAP32[$2_1 + 12 >> 2] = $1_1; 12621 HEAP32[$2_1 + 8 >> 2] = $0_1; 12622 $0_1 = $2_1 + 8 | 0; 12623 $1_1 = HEAP32[$0_1 >> 2]; 12624 $2_1 = HEAP32[$0_1 + 4 >> 2]; 12625 $0_1 = HEAP32[267030]; 12626 FUNCTION_TABLE[($0_1 ? $0_1 : 32) | 0]($1_1, $2_1); 12627 wasm2js_trap(); 12628 } 12629 12630 function $124($0_1, $1_1, $2_1) { 12631 var $3_1 = 0, $4_1 = 0, $5_1 = 0, $6_1 = 0, $7_1 = 0, $8_1 = 0; 12632 $5_1 = global$0 - 16 | 0; 12633 global$0 = $5_1; 12634 block6 : { 12635 block3 : { 12636 block5 : { 12637 block4 : { 12638 block1 : { 12639 block : { 12640 if ($2_1 & 1) { 12641 $3_1 = $2_1 >>> 1 | 0; 12642 break block; 12643 } 12644 $3_1 = HEAPU8[$1_1 | 0]; 12645 if (!$3_1) { 12646 break block1 12647 } 12648 $4_1 = $1_1; 12649 while (1) { 12650 $4_1 = $4_1 + 1 | 0; 12651 block2 : { 12652 if ($3_1 << 24 >> 24 < 0) { 12653 if (($3_1 & 255) == 128) { 12654 $3_1 = HEAPU8[$4_1 | 0] | HEAPU8[$4_1 + 1 | 0] << 8; 12655 $6_1 = $3_1 + $6_1 | 0; 12656 $4_1 = ($3_1 + $4_1 | 0) + 2 | 0; 12657 break block2; 12658 } 12659 $8_1 = $4_1; 12660 $4_1 = ($3_1 & 3) << 24; 12661 $4_1 = (($8_1 + (($4_1 << 5 & 1073741824 | $4_1 << 7) >>> 29 | 0) | 0) + ($3_1 >>> 1 & 2) | 0) + ($3_1 >>> 2 & 2) | 0; 12662 $7_1 = $7_1 | !$6_1; 12663 break block2; 12664 } 12665 $3_1 = $3_1 & 255; 12666 $4_1 = $3_1 + $4_1 | 0; 12667 $6_1 = $3_1 + $6_1 | 0; 12668 } 12669 $3_1 = HEAPU8[$4_1 | 0]; 12670 if ($3_1) { 12671 continue 12672 } 12673 break; 12674 }; 12675 $3_1 = 0; 12676 if ($6_1 >>> 0 < 16 & $7_1) { 12677 break block 12678 } 12679 $7_1 = 0; 12680 $3_1 = $6_1 << 1; 12681 if (($3_1 | 0) < 0) { 12682 break block3 12683 } 12684 } 12685 if ($3_1) { 12686 break block4 12687 } 12688 } 12689 $4_1 = 1; 12690 $3_1 = 0; 12691 break block5; 12692 } 12693 $7_1 = 1; 12694 $4_1 = $33($3_1, 1); 12695 if (!$4_1) { 12696 break block3 12697 } 12698 } 12699 HEAP32[$5_1 + 8 >> 2] = 0; 12700 HEAP32[$5_1 + 4 >> 2] = $4_1; 12701 HEAP32[$5_1 >> 2] = $3_1; 12702 if (!$133($5_1, 1059888, $1_1, $2_1)) { 12703 break block6 12704 } 12705 $152(1059928, 86, $5_1 + 15 | 0, 1059912, 1060016); 12706 wasm2js_trap(); 12707 } 12708 $120($7_1, $3_1); 12709 wasm2js_trap(); 12710 } 12711 HEAP32[$0_1 + 8 >> 2] = HEAP32[$5_1 + 8 >> 2]; 12712 $1_1 = HEAP32[$5_1 + 4 >> 2]; 12713 HEAP32[$0_1 >> 2] = HEAP32[$5_1 >> 2]; 12714 HEAP32[$0_1 + 4 >> 2] = $1_1; 12715 global$0 = $5_1 + 16 | 0; 12716 } 12717 12718 function $125($0_1, $1_1) { 12719 $0_1 = $0_1 | 0; 12720 $1_1 = $1_1 | 0; 12721 return $145($1_1, 1060032, 5) | 0; 12722 } 12723 12724 function $126($0_1, $1_1) { 12725 $0_1 = $0_1 | 0; 12726 $1_1 = $1_1 | 0; 12727 var $2_1 = 0, $3_1 = 0, $4_1 = 0, $5_1 = 0, $6_1 = 0, $7_1 = 0; 12728 $5_1 = HEAP32[$0_1 + 8 >> 2]; 12729 $3_1 = 1; 12730 block : { 12731 if ($1_1 >>> 0 < 128) { 12732 break block 12733 } 12734 $3_1 = 2; 12735 if ($1_1 >>> 0 < 2048) { 12736 break block 12737 } 12738 $3_1 = $1_1 >>> 0 < 65536 ? 3 : 4; 12739 } 12740 if ($3_1 >>> 0 > HEAP32[$0_1 >> 2] - $5_1 >>> 0) { 12741 $119($0_1, $5_1, $3_1) 12742 } 12743 $2_1 = $5_1 + HEAP32[$0_1 + 4 >> 2] | 0; 12744 block1 : { 12745 if ($1_1 >>> 0 >= 128) { 12746 $6_1 = $1_1 & 63 | -128; 12747 $4_1 = $1_1 >>> 6 | 0; 12748 if ($1_1 >>> 0 < 2048) { 12749 HEAP8[$2_1 + 1 | 0] = $6_1; 12750 HEAP8[$2_1 | 0] = $4_1 | 192; 12751 break block1; 12752 } 12753 $7_1 = $1_1 >>> 12 | 0; 12754 $4_1 = $4_1 & 63 | -128; 12755 if ($1_1 >>> 0 <= 65535) { 12756 HEAP8[$2_1 + 2 | 0] = $6_1; 12757 HEAP8[$2_1 + 1 | 0] = $4_1; 12758 HEAP8[$2_1 | 0] = $7_1 | 224; 12759 break block1; 12760 } 12761 HEAP8[$2_1 + 3 | 0] = $6_1; 12762 HEAP8[$2_1 + 2 | 0] = $4_1; 12763 HEAP8[$2_1 + 1 | 0] = $7_1 & 63 | -128; 12764 HEAP8[$2_1 | 0] = $1_1 >>> 18 | -16; 12765 break block1; 12766 } 12767 HEAP8[$2_1 | 0] = $1_1; 12768 } 12769 HEAP32[$0_1 + 8 >> 2] = $5_1 + $3_1; 12770 return 0; 12771 } 12772 12773 function $127($0_1, $1_1, $2_1) { 12774 $0_1 = $0_1 | 0; 12775 $1_1 = $1_1 | 0; 12776 $2_1 = $2_1 | 0; 12777 var $3_1 = 0; 12778 $3_1 = HEAP32[$0_1 + 8 >> 2]; 12779 block1 : { 12780 block : { 12781 if ($2_1 >>> 0 > HEAP32[$0_1 >> 2] - $3_1 >>> 0) { 12782 $119($0_1, $3_1, $2_1); 12783 $3_1 = HEAP32[$0_1 + 8 >> 2]; 12784 break block; 12785 } 12786 if (!$2_1) { 12787 break block1 12788 } 12789 } 12790 if (!$2_1) { 12791 break block1 12792 } 12793 wasm2js_memory_copy($3_1 + HEAP32[$0_1 + 4 >> 2] | 0, $1_1, $2_1); 12794 } 12795 HEAP32[$0_1 + 8 >> 2] = $2_1 + $3_1; 12796 return 0; 12797 } 12798 12799 function $128($0_1, $1_1, $2_1) { 12800 $0_1 = $0_1 | 0; 12801 $1_1 = $1_1 | 0; 12802 $2_1 = $2_1 | 0; 12803 return $133($0_1, 1059888, $1_1, $2_1) | 0; 12804 } 12805 12806 function $129($0_1, $1_1, $2_1) { 12807 $134($0_1, $1_1 << 1 | 1, $2_1); 12808 wasm2js_trap(); 12809 } 12810 12811 function $130($0_1, $1_1, $2_1, $3_1, $4_1, $5_1) { 12812 var $6_1 = 0; 12813 block : { 12814 if ($2_1) { 12815 if (HEAPU8[$1_1 | 0] <= 48) { 12816 break block 12817 } 12818 HEAP16[$5_1 >> 1] = 2; 12819 block3 : { 12820 block4 : { 12821 block1 : { 12822 block2 : { 12823 $6_1 = $3_1 << 16 >> 16; 12824 if (($6_1 | 0) > 0) { 12825 HEAP32[$5_1 + 4 >> 2] = $1_1; 12826 $3_1 = $3_1 & 65535; 12827 if ($3_1 >>> 0 < $2_1 >>> 0) { 12828 break block1 12829 } 12830 HEAP16[$5_1 + 12 >> 1] = 0; 12831 HEAP32[$5_1 + 8 >> 2] = $2_1; 12832 HEAP32[$5_1 + 16 >> 2] = $3_1 - $2_1; 12833 if ($4_1) { 12834 break block2 12835 } 12836 $1_1 = 2; 12837 break block3; 12838 } 12839 HEAP32[$5_1 + 32 >> 2] = $2_1; 12840 HEAP32[$5_1 + 28 >> 2] = $1_1; 12841 HEAP16[$5_1 + 24 >> 1] = 2; 12842 HEAP16[$5_1 + 12 >> 1] = 0; 12843 HEAP32[$5_1 + 8 >> 2] = 2; 12844 HEAP32[$5_1 + 4 >> 2] = 1062720; 12845 $3_1 = 0 - $6_1 | 0; 12846 HEAP32[$5_1 + 16 >> 2] = $3_1; 12847 $1_1 = 3; 12848 if ($2_1 >>> 0 >= $4_1 >>> 0) { 12849 break block3 12850 } 12851 $2_1 = $4_1 - $2_1 | 0; 12852 if ($3_1 >>> 0 >= $2_1 >>> 0) { 12853 break block3 12854 } 12855 $4_1 = $2_1 + $6_1 | 0; 12856 break block4; 12857 } 12858 HEAP32[$5_1 + 32 >> 2] = 1; 12859 HEAP32[$5_1 + 28 >> 2] = 1064094; 12860 HEAP16[$5_1 + 24 >> 1] = 2; 12861 break block4; 12862 } 12863 HEAP16[$5_1 + 24 >> 1] = 2; 12864 HEAP32[$5_1 + 20 >> 2] = 1; 12865 HEAP32[$5_1 + 16 >> 2] = 1064094; 12866 HEAP16[$5_1 + 12 >> 1] = 2; 12867 HEAP32[$5_1 + 8 >> 2] = $3_1; 12868 $2_1 = $2_1 - $3_1 | 0; 12869 HEAP32[$5_1 + 32 >> 2] = $2_1; 12870 HEAP32[$5_1 + 28 >> 2] = $1_1 + $3_1; 12871 if ($2_1 >>> 0 >= $4_1 >>> 0) { 12872 $1_1 = 3; 12873 break block3; 12874 } 12875 $4_1 = $4_1 - $2_1 | 0; 12876 } 12877 HEAP32[$5_1 + 40 >> 2] = $4_1; 12878 HEAP16[$5_1 + 36 >> 1] = 0; 12879 $1_1 = 4; 12880 } 12881 HEAP32[$0_1 + 4 >> 2] = $1_1; 12882 HEAP32[$0_1 >> 2] = $5_1; 12883 return; 12884 } 12885 $129(1064388, 33, 1064424); 12886 wasm2js_trap(); 12887 } 12888 $129(1064440, 31, 1064472); 12889 wasm2js_trap(); 12890 } 12891 12892 function $131($0_1, $1_1) { 12893 var $2_1 = 0, $3_1 = 0, $4_1 = 0, $5_1 = 0, $6_1 = 0, $7_1 = 0, $8_1 = 0, $9_1 = 0, $10_1 = 0, $11_1 = 0; 12894 $5_1 = global$0 - 16 | 0; 12895 global$0 = $5_1; 12896 $4_1 = HEAPU16[$0_1 + 12 >> 1]; 12897 block : { 12898 if (!$4_1) { 12899 $2_1 = $143(HEAP32[$0_1 >> 2], HEAP32[$0_1 + 4 >> 2], $1_1); 12900 break block; 12901 } 12902 $7_1 = HEAP32[$1_1 + 12 >> 2]; 12903 HEAP32[$5_1 + 12 >> 2] = $7_1; 12904 $2_1 = HEAP32[$1_1 + 8 >> 2]; 12905 HEAP32[$5_1 + 8 >> 2] = $2_1; 12906 $3_1 = HEAP32[$1_1 + 4 >> 2]; 12907 HEAP32[$5_1 + 4 >> 2] = $3_1; 12908 $1_1 = HEAP32[$1_1 >> 2]; 12909 HEAP32[$5_1 >> 2] = $1_1; 12910 $10_1 = HEAP32[$0_1 + 12 >> 2]; 12911 block1 : { 12912 $9_1 = HEAP32[$0_1 + 8 >> 2]; 12913 $6_1 = $9_1; 12914 if ($6_1 & 16777216) { 12915 if (FUNCTION_TABLE[HEAP32[HEAP32[$0_1 + 4 >> 2] + 12 >> 2]](HEAP32[$0_1 >> 2], $1_1, $3_1) | 0) { 12916 break block1 12917 } 12918 $6_1 = $6_1 & -1612709888 | 536870960; 12919 HEAP32[$0_1 + 8 >> 2] = $6_1; 12920 HEAP32[$5_1 >> 2] = 1; 12921 HEAP32[$5_1 + 4 >> 2] = 0; 12922 $1_1 = $4_1 - ($3_1 & 65535) | 0; 12923 $4_1 = $1_1 >>> 0 <= $4_1 >>> 0 ? $1_1 : 0; 12924 $3_1 = 0; 12925 } 12926 if ($7_1) { 12927 while (1) { 12928 block5 : { 12929 block6 : { 12930 block3 : { 12931 switch (HEAPU16[$2_1 >> 1] - 1 | 0) { 12932 default: 12933 $1_1 = HEAP32[$2_1 + 4 >> 2]; 12934 break block5; 12935 case 0: 12936 $1_1 = HEAPU16[$2_1 + 2 >> 1]; 12937 if ($1_1) { 12938 break block6 12939 } 12940 $1_1 = 1; 12941 break block5; 12942 case 1: 12943 break block3; 12944 }; 12945 } 12946 $1_1 = HEAP32[$2_1 + 8 >> 2]; 12947 break block5; 12948 } 12949 $1_1 = (($1_1 + 393206 & $1_1 + 524188 ^ $1_1 + 916504 & $1_1 + 514288) >>> 17 | 0) + 1 | 0; 12950 } 12951 $1_1 = $1_1 + $3_1 | 0; 12952 $3_1 = $1_1 >>> 0 < $3_1 >>> 0 ? -1 : $1_1; 12953 $2_1 = $2_1 + 12 | 0; 12954 $7_1 = $7_1 - 1 | 0; 12955 if ($7_1) { 12956 continue 12957 } 12958 break; 12959 } 12960 } 12961 block7 : { 12962 if ($3_1 >>> 0 >= ($4_1 & 65535) >>> 0) { 12963 $2_1 = $143(HEAP32[$0_1 >> 2], HEAP32[$0_1 + 4 >> 2], $5_1); 12964 break block7; 12965 } 12966 $4_1 = $4_1 - $3_1 | 0; 12967 $3_1 = 0; 12968 block10 : { 12969 block9 : { 12970 switch (($6_1 >>> 29 & 3) - 1 | 0) { 12971 case 0: 12972 case 2: 12973 $3_1 = $4_1; 12974 break block10; 12975 case 1: 12976 break block9; 12977 default: 12978 break block10; 12979 }; 12980 } 12981 $3_1 = ($4_1 & 65534) >>> 1 | 0; 12982 } 12983 $7_1 = $6_1 & 2097151; 12984 $1_1 = HEAP32[$0_1 + 4 >> 2]; 12985 $6_1 = HEAP32[$0_1 >> 2]; 12986 $8_1 = $3_1 & 65535; 12987 if ($8_1) { 12988 $11_1 = HEAP32[$1_1 + 16 >> 2]; 12989 $2_1 = 0; 12990 while (1) { 12991 if (FUNCTION_TABLE[$11_1 | 0]($6_1, $7_1) | 0) { 12992 break block1 12993 } 12994 $2_1 = $2_1 + 1 | 0; 12995 if ($8_1 >>> 0 > ($2_1 & 65535) >>> 0) { 12996 continue 12997 } 12998 break; 12999 }; 13000 } 13001 if ($143($6_1, $1_1, $5_1)) { 13002 break block1 13003 } 13004 $2_1 = 0; 13005 if (($4_1 & 65535) == ($3_1 & 65535)) { 13006 break block7 13007 } 13008 $8_1 = HEAP32[$1_1 + 16 >> 2]; 13009 $1_1 = 0; 13010 $3_1 = $4_1 - $3_1 & 65535; 13011 while (1) { 13012 $2_1 = FUNCTION_TABLE[$8_1 | 0]($6_1, $7_1) | 0; 13013 if ($2_1) { 13014 break block7 13015 } 13016 $1_1 = $1_1 + 1 | 0; 13017 if ($3_1 >>> 0 > ($1_1 & 65535) >>> 0) { 13018 continue 13019 } 13020 break; 13021 }; 13022 } 13023 HEAP32[$0_1 + 8 >> 2] = $9_1; 13024 HEAP32[$0_1 + 12 >> 2] = $10_1; 13025 break block; 13026 } 13027 $2_1 = 1; 13028 } 13029 global$0 = $5_1 + 16 | 0; 13030 return $2_1; 13031 } 13032 13033 function $132($0_1, $1_1) { 13034 $0_1 = $0_1 | 0; 13035 $1_1 = $1_1 | 0; 13036 var $2_1 = 0, $3_1 = 0, $4_1 = 0, $5_1 = 0, $6_1 = 0, $7_1 = 0, $8_1 = 0, $9_1 = 0, $10_1 = 0, $11_1 = 0, $12_1 = 0, $13_1 = 0; 13037 $6_1 = global$0 - 32 | 0; 13038 global$0 = $6_1; 13039 $4_1 = 20; 13040 $9_1 = HEAP32[$0_1 >> 2]; 13041 $2_1 = $9_1; 13042 $10_1 = HEAP32[$0_1 + 4 >> 2]; 13043 $3_1 = $10_1; 13044 $0_1 = 0; 13045 if (($3_1 | 0) == ($0_1 | 0) & $2_1 >>> 0 >= 1e3 | $0_1 >>> 0 < $3_1 >>> 0) { 13046 while (1) { 13047 $11_1 = $2_1; 13048 $7_1 = $3_1; 13049 $2_1 = __wasm_i64_udiv($2_1, $3_1, 1e4, 0); 13050 $3_1 = i64toi32_i32$HIGH_BITS; 13051 $0_1 = __wasm_i64_mul($2_1, $3_1, 1e4, 0); 13052 $5_1 = $11_1 - $0_1 | 0; 13053 $0_1 = $4_1 + ($6_1 + 12 | 0) | 0; 13054 $12_1 = $0_1 - 4 | 0; 13055 $13_1 = (($5_1 & 65535) >>> 0) / 100 | 0; 13056 $8_1 = $13_1 << 1; 13057 $8_1 = HEAPU8[$8_1 + 1063894 | 0] | HEAPU8[$8_1 + 1063895 | 0] << 8; 13058 HEAP8[$12_1 | 0] = $8_1; 13059 HEAP8[$12_1 + 1 | 0] = $8_1 >>> 8; 13060 $0_1 = $0_1 - 2 | 0; 13061 $5_1 = ($5_1 - Math_imul($13_1, 100) & 65535) << 1; 13062 $5_1 = HEAPU8[$5_1 + 1063894 | 0] | HEAPU8[$5_1 + 1063895 | 0] << 8; 13063 HEAP8[$0_1 | 0] = $5_1; 13064 HEAP8[$0_1 + 1 | 0] = $5_1 >>> 8; 13065 $4_1 = $4_1 - 4 | 0; 13066 $0_1 = 0; 13067 if (($7_1 | 0) == ($0_1 | 0) & $11_1 >>> 0 > 9999999 | $0_1 >>> 0 < $7_1 >>> 0) { 13068 continue 13069 } 13070 break; 13071 } 13072 } 13073 $7_1 = 0; 13074 if (($7_1 | 0) == ($3_1 | 0) & $2_1 >>> 0 > 9 | $3_1 >>> 0 > $7_1 >>> 0) { 13075 $4_1 = $4_1 - 2 | 0; 13076 $3_1 = $4_1 + ($6_1 + 12 | 0) | 0; 13077 $0_1 = (($2_1 & 65535) >>> 0) / 100 | 0; 13078 $2_1 = ($2_1 - Math_imul($0_1, 100) & 65535) << 1; 13079 $2_1 = HEAPU8[$2_1 + 1063894 | 0] | HEAPU8[$2_1 + 1063895 | 0] << 8; 13080 HEAP8[$3_1 | 0] = $2_1; 13081 HEAP8[$3_1 + 1 | 0] = $2_1 >>> 8; 13082 $3_1 = 0; 13083 $2_1 = $0_1; 13084 } 13085 if (!(!($2_1 | $3_1) & ($10_1 | $9_1) != 0)) { 13086 $4_1 = $4_1 - 1 | 0; 13087 HEAP8[$4_1 + ($6_1 + 12 | 0) | 0] = HEAPU8[($2_1 << 1) + 1063895 | 0]; 13088 } 13089 $0_1 = $140($1_1, 1, 1, 0, $4_1 + ($6_1 + 12 | 0) | 0, 20 - $4_1 | 0); 13090 global$0 = $6_1 + 32 | 0; 13091 return $0_1 | 0; 13092 } 13093 13094 function $133($0_1, $1_1, $2_1, $3_1) { 13095 var $4_1 = 0, $5_1 = 0, $6_1 = 0, $7_1 = 0, $8_1 = 0, $9_1 = 0, $10_1 = 0, $11_1 = 0; 13096 $6_1 = global$0 - 16 | 0; 13097 global$0 = $6_1; 13098 block1 : { 13099 block : { 13100 if (!($3_1 & 1)) { 13101 $5_1 = HEAPU8[$2_1 | 0]; 13102 if ($5_1) { 13103 break block 13104 } 13105 $7_1 = 0; 13106 break block1; 13107 } 13108 $7_1 = FUNCTION_TABLE[HEAP32[$1_1 + 12 >> 2]]($0_1, $2_1, $3_1 >>> 1 | 0) | 0; 13109 break block1; 13110 } 13111 $10_1 = HEAP32[$1_1 + 12 >> 2]; 13112 while (1) { 13113 $4_1 = $2_1 + 1 | 0; 13114 block5 : { 13115 block3 : { 13116 block4 : { 13117 block2 : { 13118 if ($5_1 << 24 >> 24 < 0) { 13119 if (($5_1 | 0) == 128) { 13120 break block2 13121 } 13122 if (($5_1 | 0) != 192) { 13123 break block3 13124 } 13125 HEAP32[$6_1 + 4 >> 2] = $1_1; 13126 HEAP32[$6_1 >> 2] = $0_1; 13127 HEAP32[$6_1 + 8 >> 2] = 1610612768; 13128 HEAP32[$6_1 + 12 >> 2] = 0; 13129 $2_1 = ($8_1 << 3) + $3_1 | 0; 13130 if (!(FUNCTION_TABLE[HEAP32[$2_1 + 4 >> 2]](HEAP32[$2_1 >> 2], $6_1) | 0)) { 13131 break block4 13132 } 13133 $7_1 = 1; 13134 break block1; 13135 } 13136 $2_1 = $5_1; 13137 if (!(FUNCTION_TABLE[$10_1 | 0]($0_1, $4_1, $2_1) | 0)) { 13138 $2_1 = $2_1 + $4_1 | 0; 13139 break block5; 13140 } 13141 $7_1 = 1; 13142 break block1; 13143 } 13144 $4_1 = $2_1 + 3 | 0; 13145 $2_1 = HEAPU8[$2_1 + 1 | 0] | HEAPU8[$2_1 + 2 | 0] << 8; 13146 if (!(FUNCTION_TABLE[$10_1 | 0]($0_1, $4_1, $2_1) | 0)) { 13147 $2_1 = $2_1 + $4_1 | 0; 13148 break block5; 13149 } 13150 $7_1 = 1; 13151 break block1; 13152 } 13153 $8_1 = $8_1 + 1 | 0; 13154 $2_1 = $4_1; 13155 break block5; 13156 } 13157 $11_1 = 1610612768; 13158 if ($5_1 & 1) { 13159 $11_1 = HEAPU8[$2_1 + 1 | 0] | HEAPU8[$2_1 + 2 | 0] << 8 | (HEAPU8[$2_1 + 3 | 0] << 16 | HEAPU8[$2_1 + 4 | 0] << 24); 13160 $4_1 = $2_1 + 5 | 0; 13161 } 13162 $7_1 = 0; 13163 block6 : { 13164 if (!($5_1 & 2)) { 13165 $9_1 = 0; 13166 $2_1 = $4_1; 13167 break block6; 13168 } 13169 $9_1 = HEAPU8[$4_1 | 0] | HEAPU8[$4_1 + 1 | 0] << 8; 13170 $2_1 = $4_1 + 2 | 0; 13171 } 13172 if ($5_1 & 4) { 13173 $7_1 = HEAPU8[$2_1 | 0] | HEAPU8[$2_1 + 1 | 0] << 8; 13174 $2_1 = $2_1 + 2 | 0; 13175 } 13176 $4_1 = $2_1; 13177 if ($5_1 & 8) { 13178 $8_1 = HEAPU8[$2_1 | 0] | HEAPU8[$2_1 + 1 | 0] << 8; 13179 $2_1 = $2_1 + 2 | 0; 13180 } else { 13181 $2_1 = $4_1 13182 } 13183 $9_1 = $5_1 & 16 ? HEAPU16[(($9_1 << 3) + $3_1 | 0) + 4 >> 1] : $9_1; 13184 if ($5_1 & 32) { 13185 $7_1 = HEAPU16[(($7_1 << 3) + $3_1 | 0) + 4 >> 1] 13186 } 13187 HEAP16[$6_1 + 14 >> 1] = $7_1; 13188 HEAP16[$6_1 + 12 >> 1] = $9_1; 13189 HEAP32[$6_1 + 8 >> 2] = $11_1; 13190 HEAP32[$6_1 + 4 >> 2] = $1_1; 13191 HEAP32[$6_1 >> 2] = $0_1; 13192 $4_1 = ($8_1 << 3) + $3_1 | 0; 13193 $7_1 = 1; 13194 if (FUNCTION_TABLE[HEAP32[$4_1 + 4 >> 2]](HEAP32[$4_1 >> 2], $6_1) | 0) { 13195 break block1 13196 } 13197 $8_1 = $8_1 + 1 | 0; 13198 } 13199 $5_1 = HEAPU8[$2_1 | 0]; 13200 if ($5_1) { 13201 continue 13202 } 13203 break; 13204 }; 13205 $7_1 = 0; 13206 } 13207 global$0 = $6_1 + 16 | 0; 13208 return $7_1; 13209 } 13210 13211 function $134($0_1, $1_1, $2_1) { 13212 var $3_1 = 0; 13213 $3_1 = global$0 - 32 | 0; 13214 global$0 = $3_1; 13215 HEAP32[$3_1 + 16 >> 2] = $1_1; 13216 HEAP32[$3_1 + 12 >> 2] = $0_1; 13217 HEAP16[$3_1 + 28 >> 1] = 1; 13218 HEAP32[$3_1 + 24 >> 2] = $2_1; 13219 HEAP32[$3_1 + 20 >> 2] = $3_1 + 12; 13220 $1_1 = global$0 - 16 | 0; 13221 global$0 = $1_1; 13222 $0_1 = $3_1 + 20 | 0; 13223 $2_1 = HEAP32[$0_1 >> 2]; 13224 $3_1 = HEAP32[$0_1 + 4 >> 2]; 13225 HEAP32[$1_1 + 12 >> 2] = $0_1; 13226 HEAP32[$1_1 + 4 >> 2] = $2_1; 13227 HEAP32[$1_1 + 8 >> 2] = $3_1; 13228 $0_1 = global$0 - 16 | 0; 13229 global$0 = $0_1; 13230 $1_1 = $1_1 + 4 | 0; 13231 $2_1 = HEAP32[$1_1 >> 2]; 13232 $3_1 = HEAP32[$2_1 + 4 >> 2]; 13233 if ($3_1 & 1) { 13234 $2_1 = HEAP32[$2_1 >> 2]; 13235 HEAP32[$0_1 + 4 >> 2] = $3_1 >>> 1; 13236 HEAP32[$0_1 >> 2] = $2_1; 13237 $2_1 = $0_1; 13238 $0_1 = HEAP32[$1_1 + 8 >> 2]; 13239 $95($2_1, 1059488, HEAP32[$1_1 + 4 >> 2], HEAPU8[$0_1 + 8 | 0], HEAPU8[$0_1 + 9 | 0]); 13240 wasm2js_trap(); 13241 } 13242 HEAP32[$0_1 >> 2] = -1; 13243 HEAP32[$0_1 + 12 >> 2] = $1_1; 13244 $2_1 = $0_1; 13245 $0_1 = HEAP32[$1_1 + 8 >> 2]; 13246 $95($2_1, 1059516, HEAP32[$1_1 + 4 >> 2], HEAPU8[$0_1 + 8 | 0], HEAPU8[$0_1 + 9 | 0]); 13247 wasm2js_trap(); 13248 } 13249 13250 function $135($0_1, $1_1, $2_1, $3_1) { 13251 var $4_1 = 0; 13252 $4_1 = global$0 - 32 | 0; 13253 global$0 = $4_1; 13254 block2 : { 13255 block1 : { 13256 block : { 13257 if ($0_1 >>> 0 <= $2_1 >>> 0) { 13258 if ($1_1 >>> 0 > $2_1 >>> 0) { 13259 break block 13260 } 13261 if ($0_1 >>> 0 <= $1_1 >>> 0) { 13262 break block1 13263 } 13264 HEAP32[$4_1 + 8 >> 2] = $0_1; 13265 HEAP32[$4_1 + 12 >> 2] = $1_1; 13266 HEAP32[$4_1 + 24 >> 2] = $4_1 + 12; 13267 HEAP32[$4_1 + 28 >> 2] = 4; 13268 HEAP32[$4_1 + 16 >> 2] = $4_1 + 8; 13269 HEAP32[$4_1 + 20 >> 2] = 4; 13270 $134(1048576, $4_1 + 16 | 0, $3_1); 13271 wasm2js_trap(); 13272 } 13273 HEAP32[$4_1 + 8 >> 2] = $0_1; 13274 HEAP32[$4_1 + 12 >> 2] = $2_1; 13275 HEAP32[$4_1 + 24 >> 2] = $4_1 + 12; 13276 HEAP32[$4_1 + 28 >> 2] = 4; 13277 HEAP32[$4_1 + 16 >> 2] = $4_1 + 8; 13278 HEAP32[$4_1 + 20 >> 2] = 4; 13279 $134(1048853, $4_1 + 16 | 0, $3_1); 13280 wasm2js_trap(); 13281 } 13282 HEAP32[$4_1 + 8 >> 2] = $1_1; 13283 HEAP32[$4_1 + 12 >> 2] = $2_1; 13284 HEAP32[$4_1 + 24 >> 2] = $4_1 + 12; 13285 HEAP32[$4_1 + 28 >> 2] = 4; 13286 break block2; 13287 } 13288 HEAP32[$4_1 + 8 >> 2] = $1_1; 13289 HEAP32[$4_1 + 12 >> 2] = $2_1; 13290 HEAP32[$4_1 + 24 >> 2] = $4_1 + 12; 13291 HEAP32[$4_1 + 28 >> 2] = 4; 13292 } 13293 HEAP32[$4_1 + 16 >> 2] = $4_1 + 8; 13294 HEAP32[$4_1 + 20 >> 2] = 4; 13295 $134(1048910, $4_1 + 16 | 0, $3_1); 13296 wasm2js_trap(); 13297 } 13298 13299 function $136($0_1, $1_1, $2_1) { 13300 var $3_1 = 0, $4_1 = 0, $5_1 = 0, $6_1 = 0, $7_1 = 0; 13301 $6_1 = global$0 - 16 | 0; 13302 global$0 = $6_1; 13303 block27 : { 13304 block10 : { 13305 block9 : { 13306 block11 : { 13307 block19 : { 13308 block20 : { 13309 block18 : { 13310 block17 : { 13311 block5 : { 13312 block6 : { 13313 block : { 13314 block4 : { 13315 block2 : { 13316 block3 : { 13317 block8 : { 13318 block1 : { 13319 switch ($1_1 | 0) { 13320 default: 13321 if (($1_1 | 0) == 92) { 13322 break block8 13323 } 13324 break; 13325 case 0: 13326 break block; 13327 case 1: 13328 case 2: 13329 case 3: 13330 case 4: 13331 case 5: 13332 case 6: 13333 case 7: 13334 case 8: 13335 case 11: 13336 case 12: 13337 case 14: 13338 case 15: 13339 case 16: 13340 case 17: 13341 case 18: 13342 case 19: 13343 case 20: 13344 case 21: 13345 case 22: 13346 case 23: 13347 case 24: 13348 case 25: 13349 case 26: 13350 case 27: 13351 case 28: 13352 case 29: 13353 case 30: 13354 case 31: 13355 case 32: 13356 case 33: 13357 case 35: 13358 case 36: 13359 case 37: 13360 case 38: 13361 break block1; 13362 case 9: 13363 break block2; 13364 case 10: 13365 break block3; 13366 case 13: 13367 break block4; 13368 case 34: 13369 break block5; 13370 case 39: 13371 break block6; 13372 }; 13373 } 13374 if (($1_1 & 2097150) == 65438 | $1_1 - 32 >>> 0 < 95) { 13375 break block9 13376 } 13377 if ($1_1 >>> 0 < 32 | $1_1 - 127 >>> 0 < 33 | ($1_1 - 57344 >>> 0 < 6400 | $1_1 - 983040 >>> 0 < 65534) | (($1_1 | 0) == 32 | $1_1 + -1048576 >>> 0 < 65534)) { 13378 break block10 13379 } 13380 if ($1_1 >>> 0 < 133) { 13381 break block11 13382 } 13383 block13 : { 13384 block14 : { 13385 block16 : { 13386 block15 : { 13387 block12 : { 13388 $5_1 = $1_1 >>> 8 | 0; 13389 switch ($5_1 - 22 | 0) { 13390 case 0: 13391 break block12; 13392 case 1: 13393 case 2: 13394 case 3: 13395 case 4: 13396 case 5: 13397 case 6: 13398 case 7: 13399 case 8: 13400 case 9: 13401 case 11: 13402 case 12: 13403 case 13: 13404 case 14: 13405 case 15: 13406 case 16: 13407 case 17: 13408 case 18: 13409 case 19: 13410 case 20: 13411 case 21: 13412 case 22: 13413 case 23: 13414 case 24: 13415 case 25: 13416 break block13; 13417 case 10: 13418 break block14; 13419 case 26: 13420 break block15; 13421 default: 13422 break block16; 13423 }; 13424 } 13425 $3_1 = ($1_1 | 0) == 5760; 13426 break block13; 13427 } 13428 $3_1 = ($1_1 | 0) == 12288; 13429 break block13; 13430 } 13431 if ($5_1) { 13432 break block13 13433 } 13434 $3_1 = HEAPU8[($1_1 & 255) + 1060037 | 0]; 13435 break block13; 13436 } 13437 $3_1 = (HEAPU8[($1_1 & 255) + 1060037 | 0] & 2) >>> 1 | 0; 13438 } 13439 if ($3_1 & 1) { 13440 break block10 13441 } 13442 if ($2_1 & 1 & $1_1 >>> 0 >= 768) { 13443 break block17 13444 } 13445 if ($1_1 >>> 0 > 172) { 13446 break block18 13447 } 13448 break block11; 13449 } 13450 HEAP16[$0_1 + 2 >> 1] = 0; 13451 HEAP16[$0_1 + 4 >> 1] = 0; 13452 $1_1 = 0; 13453 HEAP16[$0_1 + 6 >> 1] = $1_1; 13454 HEAP16[$0_1 + 8 >> 1] = $1_1 >>> 16; 13455 HEAP16[$0_1 >> 1] = 23644; 13456 break block19; 13457 } 13458 HEAP16[$0_1 + 2 >> 1] = 0; 13459 HEAP16[$0_1 + 4 >> 1] = 0; 13460 $1_1 = 0; 13461 HEAP16[$0_1 + 6 >> 1] = $1_1; 13462 HEAP16[$0_1 + 8 >> 1] = $1_1 >>> 16; 13463 HEAP16[$0_1 >> 1] = 28252; 13464 break block19; 13465 } 13466 HEAP16[$0_1 + 2 >> 1] = 0; 13467 HEAP16[$0_1 + 4 >> 1] = 0; 13468 $1_1 = 0; 13469 HEAP16[$0_1 + 6 >> 1] = $1_1; 13470 HEAP16[$0_1 + 8 >> 1] = $1_1 >>> 16; 13471 HEAP16[$0_1 >> 1] = 29788; 13472 break block19; 13473 } 13474 HEAP16[$0_1 + 2 >> 1] = 0; 13475 HEAP16[$0_1 + 4 >> 1] = 0; 13476 $1_1 = 0; 13477 HEAP16[$0_1 + 6 >> 1] = $1_1; 13478 HEAP16[$0_1 + 8 >> 1] = $1_1 >>> 16; 13479 HEAP16[$0_1 >> 1] = 29276; 13480 break block19; 13481 } 13482 HEAP16[$0_1 + 2 >> 1] = 0; 13483 HEAP16[$0_1 + 4 >> 1] = 0; 13484 $1_1 = 0; 13485 HEAP16[$0_1 + 6 >> 1] = $1_1; 13486 HEAP16[$0_1 + 8 >> 1] = $1_1 >>> 16; 13487 HEAP16[$0_1 >> 1] = 12380; 13488 break block19; 13489 } 13490 if (!($2_1 & 256)) { 13491 break block9 13492 } 13493 HEAP16[$0_1 + 2 >> 1] = 0; 13494 HEAP16[$0_1 + 4 >> 1] = 0; 13495 $1_1 = 0; 13496 HEAP16[$0_1 + 6 >> 1] = $1_1; 13497 HEAP16[$0_1 + 8 >> 1] = $1_1 >>> 16; 13498 HEAP16[$0_1 >> 1] = 10076; 13499 break block19; 13500 } 13501 if (($2_1 & 16777215) >>> 0 >= 65536) { 13502 break block20 13503 } 13504 break block9; 13505 } 13506 $5_1 = 0; 13507 $2_1 = $1_1 >>> 0 >= 69291 ? 16 : 0; 13508 $3_1 = $2_1; 13509 $2_1 = $2_1 | 8; 13510 $2_1 = (HEAP32[($2_1 << 2) + 1064720 >> 2] & 2097151) >>> 0 > $1_1 >>> 0 ? $3_1 : $2_1; 13511 $3_1 = $2_1; 13512 $2_1 = $2_1 | 4; 13513 $2_1 = (HEAP32[($2_1 << 2) + 1064720 >> 2] & 2097151) >>> 0 > $1_1 >>> 0 ? $3_1 : $2_1; 13514 $3_1 = $2_1; 13515 $2_1 = $2_1 | 2; 13516 $2_1 = (HEAP32[($2_1 << 2) + 1064720 >> 2] & 2097151) >>> 0 > $1_1 >>> 0 ? $3_1 : $2_1; 13517 $3_1 = $2_1; 13518 $2_1 = $2_1 + 1 | 0; 13519 $2_1 = (HEAP32[($2_1 << 2) + 1064720 >> 2] & 2097151) >>> 0 > $1_1 >>> 0 ? $3_1 : $2_1; 13520 $3_1 = $2_1; 13521 $2_1 = $2_1 + 1 | 0; 13522 $2_1 = (HEAP32[($2_1 << 2) + 1064720 >> 2] & 2097151) >>> 0 > $1_1 >>> 0 ? $3_1 : $2_1; 13523 $3_1 = HEAP32[($2_1 << 2) + 1064720 >> 2] << 11; 13524 $4_1 = $1_1 << 11; 13525 $4_1 = ((($3_1 | 0) == ($4_1 | 0)) + ($3_1 >>> 0 < $4_1 >>> 0) | 0) + $2_1 | 0; 13526 $2_1 = $4_1 << 2; 13527 $7_1 = $2_1 + 1064720 | 0; 13528 $2_1 = HEAP32[$2_1 + 1064720 >> 2] >>> 21 | 0; 13529 $3_1 = 767; 13530 block21 : { 13531 if ($4_1 >>> 0 <= 31) { 13532 $3_1 = HEAP32[$7_1 + 4 >> 2] >>> 21 | 0; 13533 if (!$4_1) { 13534 break block21 13535 } 13536 } 13537 $5_1 = HEAP32[$7_1 - 4 >> 2] & 2097151; 13538 } 13539 block22 : { 13540 if (!(($2_1 ^ -1) + $3_1 | 0)) { 13541 break block22 13542 } 13543 $5_1 = $1_1 - $5_1 | 0; 13544 $4_1 = $3_1 - 1 | 0; 13545 $3_1 = 0; 13546 while (1) { 13547 $3_1 = HEAPU8[$2_1 + 1061754 | 0] + $3_1 | 0; 13548 if ($5_1 >>> 0 < $3_1 >>> 0) { 13549 break block22 13550 } 13551 $2_1 = $2_1 + 1 | 0; 13552 if (($2_1 | 0) != ($4_1 | 0)) { 13553 continue 13554 } 13555 break; 13556 }; 13557 } 13558 if ($2_1 & 1) { 13559 break block10 13560 } 13561 } 13562 $5_1 = 0; 13563 $2_1 = $1_1 >>> 0 >= 65024 ? 6 : 0; 13564 $3_1 = $2_1; 13565 $2_1 = $2_1 + 3 | 0; 13566 $2_1 = (HEAP32[($2_1 << 2) + 1064852 >> 2] & 2097151) >>> 0 > $1_1 >>> 0 ? $3_1 : $2_1; 13567 $3_1 = $2_1; 13568 $2_1 = $2_1 + 1 | 0; 13569 $2_1 = (HEAP32[($2_1 << 2) + 1064852 >> 2] & 2097151) >>> 0 > $1_1 >>> 0 ? $3_1 : $2_1; 13570 $3_1 = $2_1; 13571 $2_1 = $2_1 + 1 | 0; 13572 $2_1 = (HEAP32[($2_1 << 2) + 1064852 >> 2] & 2097151) >>> 0 > $1_1 >>> 0 ? $3_1 : $2_1; 13573 $3_1 = HEAP32[($2_1 << 2) + 1064852 >> 2] << 11; 13574 $4_1 = $1_1 << 11; 13575 $4_1 = ((($3_1 | 0) == ($4_1 | 0)) + ($3_1 >>> 0 < $4_1 >>> 0) | 0) + $2_1 | 0; 13576 $2_1 = $4_1 << 2; 13577 $7_1 = $2_1 + 1064852 | 0; 13578 $2_1 = HEAP32[$2_1 + 1064852 >> 2] >>> 21 | 0; 13579 $3_1 = 35; 13580 block23 : { 13581 if ($4_1 >>> 0 <= 10) { 13582 $3_1 = HEAP32[$7_1 + 4 >> 2] >>> 21 | 0; 13583 if (!$4_1) { 13584 break block23 13585 } 13586 } 13587 $5_1 = HEAP32[$7_1 - 4 >> 2] & 2097151; 13588 } 13589 block24 : { 13590 if (!(($2_1 ^ -1) + $3_1 | 0)) { 13591 break block24 13592 } 13593 $5_1 = $1_1 - $5_1 | 0; 13594 $4_1 = $3_1 - 1 | 0; 13595 $3_1 = 0; 13596 while (1) { 13597 $3_1 = HEAPU8[$2_1 + 1062521 | 0] + $3_1 | 0; 13598 if ($5_1 >>> 0 < $3_1 >>> 0) { 13599 break block24 13600 } 13601 $2_1 = $2_1 + 1 | 0; 13602 if (($2_1 | 0) != ($4_1 | 0)) { 13603 continue 13604 } 13605 break; 13606 }; 13607 } 13608 if ($2_1 & 1) { 13609 break block10 13610 } 13611 $5_1 = 0; 13612 $2_1 = $1_1 >>> 0 >= 69821 ? 5 : 0; 13613 $3_1 = $2_1; 13614 $2_1 = $2_1 + 3 | 0; 13615 $2_1 = (HEAP32[($2_1 << 2) + 1064900 >> 2] & 2097151) >>> 0 > $1_1 >>> 0 ? $3_1 : $2_1; 13616 $3_1 = $2_1; 13617 $2_1 = $2_1 + 1 | 0; 13618 $2_1 = (HEAP32[($2_1 << 2) + 1064900 >> 2] & 2097151) >>> 0 > $1_1 >>> 0 ? $3_1 : $2_1; 13619 $3_1 = $2_1; 13620 $2_1 = $2_1 + 1 | 0; 13621 $2_1 = (HEAP32[($2_1 << 2) + 1064900 >> 2] & 2097151) >>> 0 > $1_1 >>> 0 ? $3_1 : $2_1; 13622 $3_1 = HEAP32[($2_1 << 2) + 1064900 >> 2] << 11; 13623 $4_1 = $1_1 << 11; 13624 $4_1 = ((($3_1 | 0) == ($4_1 | 0)) + ($3_1 >>> 0 < $4_1 >>> 0) | 0) + $2_1 | 0; 13625 $2_1 = $4_1 << 2; 13626 $7_1 = $2_1 + 1064900 | 0; 13627 $2_1 = HEAP32[$2_1 + 1064900 >> 2] >>> 21 | 0; 13628 $3_1 = 43; 13629 block25 : { 13630 if ($4_1 >>> 0 <= 9) { 13631 $3_1 = HEAP32[$7_1 + 4 >> 2] >>> 21 | 0; 13632 if (!$4_1) { 13633 break block25 13634 } 13635 } 13636 $5_1 = HEAP32[$7_1 - 4 >> 2] & 2097151; 13637 } 13638 block26 : { 13639 if (!(($2_1 ^ -1) + $3_1 | 0)) { 13640 break block26 13641 } 13642 $5_1 = $1_1 - $5_1 | 0; 13643 $4_1 = $3_1 - 1 | 0; 13644 $3_1 = 0; 13645 while (1) { 13646 $3_1 = HEAPU8[$2_1 + 1062556 | 0] + $3_1 | 0; 13647 if ($5_1 >>> 0 < $3_1 >>> 0) { 13648 break block26 13649 } 13650 $2_1 = $2_1 + 1 | 0; 13651 if (($2_1 | 0) != ($4_1 | 0)) { 13652 continue 13653 } 13654 break; 13655 }; 13656 } 13657 if (!($2_1 & 1)) { 13658 break block11 13659 } 13660 break block10; 13661 } 13662 HEAP16[$0_1 + 2 >> 1] = 0; 13663 HEAP16[$0_1 + 4 >> 1] = 0; 13664 $1_1 = 0; 13665 HEAP16[$0_1 + 6 >> 1] = $1_1; 13666 HEAP16[$0_1 + 8 >> 1] = $1_1 >>> 16; 13667 HEAP16[$0_1 >> 1] = 8796; 13668 } 13669 $2_1 = 0; 13670 $1_1 = 2; 13671 break block27; 13672 } 13673 $2_1 = 1; 13674 block30 : { 13675 if ($1_1 >>> 0 < 888) { 13676 break block30 13677 } 13678 block29 : { 13679 if ($1_1 >>> 0 < 262142) { 13680 break block29 13681 } 13682 if (($1_1 | 0) == 917505 | $1_1 - 917536 >>> 0 < 96 | ($1_1 - 917760 >>> 0 < 240 | $1_1 - 983040 >>> 0 < 65534)) { 13683 break block30 13684 } 13685 $2_1 = $1_1 + -1048576 >>> 0 < 65534; 13686 break block30; 13687 } 13688 $5_1 = 0; 13689 $2_1 = $1_1 >>> 0 >= 111356 ? 27 : 0; 13690 $3_1 = $2_1; 13691 $2_1 = $2_1 + 13 | 0; 13692 $2_1 = (HEAP32[($2_1 << 2) + 1064504 >> 2] & 2097151) >>> 0 > $1_1 >>> 0 ? $3_1 : $2_1; 13693 $3_1 = $2_1; 13694 $2_1 = $2_1 + 7 | 0; 13695 $2_1 = (HEAP32[($2_1 << 2) + 1064504 >> 2] & 2097151) >>> 0 > $1_1 >>> 0 ? $3_1 : $2_1; 13696 $3_1 = $2_1; 13697 $2_1 = $2_1 + 3 | 0; 13698 $2_1 = (HEAP32[($2_1 << 2) + 1064504 >> 2] & 2097151) >>> 0 > $1_1 >>> 0 ? $3_1 : $2_1; 13699 $3_1 = $2_1; 13700 $2_1 = $2_1 + 2 | 0; 13701 $2_1 = (HEAP32[($2_1 << 2) + 1064504 >> 2] & 2097151) >>> 0 > $1_1 >>> 0 ? $3_1 : $2_1; 13702 $3_1 = $2_1; 13703 $2_1 = $2_1 + 1 | 0; 13704 $2_1 = (HEAP32[($2_1 << 2) + 1064504 >> 2] & 2097151) >>> 0 > $1_1 >>> 0 ? $3_1 : $2_1; 13705 $3_1 = HEAP32[($2_1 << 2) + 1064504 >> 2] << 11; 13706 $4_1 = $1_1 << 11; 13707 $4_1 = ((($3_1 | 0) == ($4_1 | 0)) + ($3_1 >>> 0 < $4_1 >>> 0) | 0) + $2_1 | 0; 13708 $2_1 = $4_1 << 2; 13709 $7_1 = $2_1 + 1064504 | 0; 13710 $2_1 = HEAP32[$2_1 + 1064504 >> 2] >>> 21 | 0; 13711 $3_1 = 1461; 13712 block31 : { 13713 if ($4_1 >>> 0 <= 52) { 13714 $3_1 = HEAP32[$7_1 + 4 >> 2] >>> 21 | 0; 13715 if (!$4_1) { 13716 break block31 13717 } 13718 } 13719 $5_1 = HEAP32[$7_1 - 4 >> 2] & 2097151; 13720 } 13721 block32 : { 13722 if (!(($2_1 ^ -1) + $3_1 | 0)) { 13723 break block32 13724 } 13725 $5_1 = $1_1 - $5_1 | 0; 13726 $4_1 = $3_1 - 1 | 0; 13727 $3_1 = 0; 13728 while (1) { 13729 $3_1 = HEAPU8[$2_1 + 1060293 | 0] + $3_1 | 0; 13730 if ($5_1 >>> 0 < $3_1 >>> 0) { 13731 break block32 13732 } 13733 $2_1 = $2_1 + 1 | 0; 13734 if (($2_1 | 0) != ($4_1 | 0)) { 13735 continue 13736 } 13737 break; 13738 }; 13739 } 13740 $2_1 = !($2_1 & 1); 13741 } 13742 if (!$2_1) { 13743 break block10 13744 } 13745 } 13746 HEAP32[$0_1 >> 2] = $1_1; 13747 $2_1 = 128; 13748 $1_1 = 129; 13749 break block27; 13750 } 13751 HEAP8[$6_1 + 8 | 0] = 0; 13752 HEAP16[$6_1 + 6 >> 1] = 0; 13753 HEAP8[$6_1 + 9 | 0] = HEAPU8[($1_1 >>> 20 | 0) + 1062599 | 0]; 13754 HEAP8[$6_1 + 13 | 0] = HEAPU8[($1_1 >>> 4 & 15) + 1062599 | 0]; 13755 HEAP8[$6_1 + 12 | 0] = HEAPU8[($1_1 >>> 8 & 15) + 1062599 | 0]; 13756 HEAP8[$6_1 + 11 | 0] = HEAPU8[($1_1 >>> 12 & 15) + 1062599 | 0]; 13757 HEAP8[$6_1 + 10 | 0] = HEAPU8[($1_1 >>> 16 & 15) + 1062599 | 0]; 13758 $2_1 = Math_clz32($1_1 | 1) >>> 2 | 0; 13759 $3_1 = $6_1 + 6 | 0; 13760 $5_1 = $2_1 + $3_1 | 0; 13761 HEAP8[$5_1 | 0] = 123; 13762 HEAP8[$5_1 - 1 | 0] = 117; 13763 $2_1 = $2_1 - 2 | 0; 13764 HEAP8[$2_1 + $3_1 | 0] = 92; 13765 $3_1 = HEAPU16[$6_1 + 10 >> 1] | HEAPU16[$6_1 + 12 >> 1] << 16; 13766 HEAP32[$0_1 >> 2] = HEAPU16[$6_1 + 6 >> 1] | HEAPU16[$6_1 + 8 >> 1] << 16; 13767 HEAP32[$0_1 + 4 >> 2] = $3_1; 13768 HEAP8[$6_1 + 15 | 0] = 125; 13769 HEAP8[$6_1 + 14 | 0] = HEAPU8[($1_1 & 15) + 1062599 | 0]; 13770 HEAP16[$0_1 + 8 >> 1] = HEAPU16[$6_1 + 14 >> 1]; 13771 $1_1 = 10; 13772 } 13773 HEAP8[$0_1 + 13 | 0] = $1_1; 13774 HEAP8[$0_1 + 12 | 0] = $2_1; 13775 global$0 = $6_1 + 16 | 0; 13776 } 13777 13778 function $137($0_1, $1_1, $2_1) { 13779 var $3_1 = 0; 13780 $3_1 = global$0 - 32 | 0; 13781 global$0 = $3_1; 13782 HEAP32[$3_1 + 12 >> 2] = $1_1; 13783 HEAP32[$3_1 + 8 >> 2] = $0_1; 13784 HEAP32[$3_1 + 24 >> 2] = $3_1 + 8; 13785 HEAP32[$3_1 + 28 >> 2] = 4; 13786 HEAP32[$3_1 + 16 >> 2] = $3_1 + 12; 13787 HEAP32[$3_1 + 20 >> 2] = 4; 13788 $134(1048655, $3_1 + 16 | 0, $2_1); 13789 wasm2js_trap(); 13790 } 13791 13792 function $138($0_1, $1_1, $2_1) { 13793 var $3_1 = 0, $4_1 = 0, $5_1 = 0, $6_1 = 0, $7_1 = 0, $8_1 = 0, $9_1 = 0, $10_1 = 0, $11_1 = 0, $12_1 = 0, $13_1 = 0, $14_1 = 0, $15_1 = 0, $16_1 = 0, $17_1 = 0, $18_1 = 0, $19_1 = 0, $20_1 = 0, $21_1 = 0, $22_1 = 0, $23_1 = 0; 13794 $14_1 = global$0 - 160 | 0; 13795 global$0 = $14_1; 13796 wasm2js_memory_fill($14_1, 0, 160); 13797 block : { 13798 block1 : { 13799 $8_1 = HEAP32[$0_1 + 160 >> 2]; 13800 if ($8_1 >>> 0 >= $2_1 >>> 0) { 13801 if ($8_1 >>> 0 >= 41) { 13802 break block 13803 } 13804 $19_1 = ($2_1 << 2) + $1_1 | 0; 13805 block2 : { 13806 block3 : { 13807 if ($8_1) { 13808 $20_1 = $8_1 + 1 | 0; 13809 $15_1 = $8_1 << 2; 13810 while (1) { 13811 $3_1 = ($12_1 << 2) + $14_1 | 0; 13812 while (1) { 13813 $2_1 = $12_1; 13814 $9_1 = $3_1; 13815 if (($1_1 | 0) == ($19_1 | 0)) { 13816 break block1 13817 } 13818 $3_1 = $3_1 + 4 | 0; 13819 $12_1 = $2_1 + 1 | 0; 13820 $11_1 = HEAP32[$1_1 >> 2]; 13821 $18_1 = $1_1 + 4 | 0; 13822 $1_1 = $18_1; 13823 if (!$11_1) { 13824 continue 13825 } 13826 break; 13827 }; 13828 $21_1 = $11_1; 13829 $5_1 = 0; 13830 $4_1 = 0; 13831 $11_1 = $15_1; 13832 $1_1 = $2_1; 13833 $3_1 = $0_1; 13834 while (1) { 13835 if ($1_1 >>> 0 >= 40) { 13836 break block2 13837 } 13838 $6_1 = HEAP32[$9_1 >> 2]; 13839 $10_1 = $6_1 + $5_1 | 0; 13840 $17_1 = $10_1; 13841 $16_1 = $6_1 >>> 0 > $10_1 >>> 0 ? $4_1 + 1 | 0 : $4_1; 13842 $6_1 = __wasm_i64_mul(HEAP32[$3_1 >> 2], 0, $21_1, $22_1); 13843 $10_1 = i64toi32_i32$HIGH_BITS + $16_1 | 0; 13844 $4_1 = $6_1 + $17_1 | 0; 13845 $10_1 = $6_1 >>> 0 > $4_1 >>> 0 ? $10_1 + 1 | 0 : $10_1; 13846 $5_1 = $4_1; 13847 HEAP32[$9_1 >> 2] = $4_1; 13848 $4_1 = $10_1; 13849 $16_1 = $5_1; 13850 $6_1 = 32; 13851 $7_1 = 0; 13852 if (($6_1 & 63) >>> 0 >= 32) { 13853 $17_1 = 0; 13854 $5_1 = $4_1 >>> $7_1 | 0; 13855 } else { 13856 $17_1 = $10_1 >>> $7_1 | 0; 13857 $5_1 = ((1 << $7_1) - 1 & $10_1) << 32 - $7_1 | $16_1 >>> $7_1; 13858 } 13859 $4_1 = $17_1; 13860 $9_1 = $9_1 + 4 | 0; 13861 $1_1 = $1_1 + 1 | 0; 13862 $3_1 = $3_1 + 4 | 0; 13863 $11_1 = $11_1 - 4 | 0; 13864 if ($11_1) { 13865 continue 13866 } 13867 break; 13868 }; 13869 if ($4_1 | $5_1) { 13870 $1_1 = $2_1 + $8_1 | 0; 13871 if ($1_1 >>> 0 >= 40) { 13872 break block3 13873 } 13874 HEAP32[($1_1 << 2) + $14_1 >> 2] = $5_1; 13875 $1_1 = $20_1; 13876 } else { 13877 $1_1 = $8_1 13878 } 13879 $1_1 = $1_1 + $2_1 | 0; 13880 $13_1 = $1_1 >>> 0 < $13_1 >>> 0 ? $13_1 : $1_1; 13881 $1_1 = $18_1; 13882 continue; 13883 }; 13884 } 13885 while (1) { 13886 if (($1_1 | 0) == ($19_1 | 0)) { 13887 break block1 13888 } 13889 $9_1 = $9_1 + 1 | 0; 13890 $2_1 = HEAP32[$1_1 >> 2]; 13891 $1_1 = $1_1 + 4 | 0; 13892 if (!$2_1) { 13893 continue 13894 } 13895 $2_1 = $9_1 - 1 | 0; 13896 $13_1 = $2_1 >>> 0 < $13_1 >>> 0 ? $13_1 : $2_1; 13897 continue; 13898 }; 13899 } 13900 $137($1_1, 40, 1062848); 13901 wasm2js_trap(); 13902 } 13903 $137($1_1, 40, 1062848); 13904 wasm2js_trap(); 13905 } 13906 if ($8_1 >>> 0 >= 41) { 13907 break block 13908 } 13909 $20_1 = $2_1 + 1 | 0; 13910 $19_1 = $2_1 << 2; 13911 $23_1 = ($8_1 << 2) + $0_1 | 0; 13912 $3_1 = $0_1; 13913 block4 : { 13914 while (1) { 13915 $12_1 = ($11_1 << 2) + $14_1 | 0; 13916 while (1) { 13917 $18_1 = $11_1; 13918 $9_1 = $12_1; 13919 if (($3_1 | 0) == ($23_1 | 0)) { 13920 break block1 13921 } 13922 $12_1 = $9_1 + 4 | 0; 13923 $11_1 = $11_1 + 1 | 0; 13924 $15_1 = HEAP32[$3_1 >> 2]; 13925 $8_1 = $3_1 + 4 | 0; 13926 $3_1 = $8_1; 13927 if (!$15_1) { 13928 continue 13929 } 13930 break; 13931 }; 13932 $21_1 = $15_1; 13933 $5_1 = 0; 13934 $4_1 = 0; 13935 $15_1 = $19_1; 13936 $3_1 = $18_1; 13937 $12_1 = $1_1; 13938 while (1) { 13939 if ($3_1 >>> 0 >= 40) { 13940 break block4 13941 } 13942 $6_1 = HEAP32[$9_1 >> 2]; 13943 $7_1 = $5_1 + $6_1 | 0; 13944 $4_1 = $7_1 >>> 0 < $6_1 >>> 0 ? $4_1 + 1 | 0 : $4_1; 13945 $16_1 = $7_1; 13946 $6_1 = __wasm_i64_mul(HEAP32[$12_1 >> 2], 0, $21_1, $22_1); 13947 $7_1 = $4_1 + i64toi32_i32$HIGH_BITS | 0; 13948 $17_1 = $6_1 + $16_1 | 0; 13949 $7_1 = $6_1 >>> 0 > $17_1 >>> 0 ? $7_1 + 1 | 0 : $7_1; 13950 $5_1 = $17_1; 13951 HEAP32[$9_1 >> 2] = $5_1; 13952 $10_1 = $5_1; 13953 $6_1 = 32; 13954 $4_1 = 0; 13955 if (($6_1 & 63) >>> 0 >= 32) { 13956 $16_1 = 0; 13957 $5_1 = $7_1 >>> $4_1 | 0; 13958 } else { 13959 $16_1 = $7_1 >>> $4_1 | 0; 13960 $5_1 = ((1 << $4_1) - 1 & $7_1) << 32 - $4_1 | $10_1 >>> $4_1; 13961 } 13962 $4_1 = $16_1; 13963 $9_1 = $9_1 + 4 | 0; 13964 $3_1 = $3_1 + 1 | 0; 13965 $12_1 = $12_1 + 4 | 0; 13966 $15_1 = $15_1 - 4 | 0; 13967 if ($15_1) { 13968 continue 13969 } 13970 break; 13971 }; 13972 block5 : { 13973 if ($4_1 | $5_1) { 13974 $3_1 = $2_1 + $18_1 | 0; 13975 if ($3_1 >>> 0 >= 40) { 13976 break block5 13977 } 13978 HEAP32[($3_1 << 2) + $14_1 >> 2] = $5_1; 13979 $3_1 = $20_1; 13980 } else { 13981 $3_1 = $2_1 13982 } 13983 $3_1 = $3_1 + $18_1 | 0; 13984 $13_1 = $3_1 >>> 0 < $13_1 >>> 0 ? $13_1 : $3_1; 13985 $3_1 = $8_1; 13986 continue; 13987 } 13988 break; 13989 }; 13990 $137($3_1, 40, 1062848); 13991 wasm2js_trap(); 13992 } 13993 $137($3_1, 40, 1062848); 13994 wasm2js_trap(); 13995 } 13996 wasm2js_memory_copy($0_1, $14_1, 160); 13997 HEAP32[$0_1 + 160 >> 2] = $13_1; 13998 global$0 = $14_1 + 160 | 0; 13999 return; 14000 } 14001 $135(0, $8_1, 40, 1062848); 14002 wasm2js_trap(); 14003 } 14004 14005 function $139($0_1, $1_1) { 14006 var $2_1 = 0, $3_1 = 0, $4_1 = 0, $5_1 = 0, $6_1 = 0, $7_1 = 0, $8_1 = 0, $9_1 = 0, $10_1 = 0, $11_1 = 0; 14007 block4 : { 14008 block3 : { 14009 if ($1_1 >>> 0 < 1280) { 14010 $5_1 = $1_1 >>> 5 | 0; 14011 block1 : { 14012 block : { 14013 $2_1 = HEAP32[$0_1 + 160 >> 2]; 14014 if ($2_1) { 14015 $3_1 = $2_1 - 1 | 0; 14016 $7_1 = ($0_1 + ($2_1 << 2) | 0) - 4 | 0; 14017 $4_1 = ($0_1 + ($2_1 + $5_1 << 2) | 0) - 4 | 0; 14018 $2_1 = $2_1 >>> 0 < 41; 14019 while (1) { 14020 if (!$2_1) { 14021 break block 14022 } 14023 $6_1 = $3_1 + $5_1 | 0; 14024 if ($6_1 >>> 0 >= 40) { 14025 break block1 14026 } 14027 HEAP32[$4_1 >> 2] = HEAP32[$7_1 >> 2]; 14028 $7_1 = $7_1 - 4 | 0; 14029 $4_1 = $4_1 - 4 | 0; 14030 $3_1 = $3_1 - 1 | 0; 14031 if (($3_1 | 0) != -1) { 14032 continue 14033 } 14034 break; 14035 }; 14036 } 14037 $4_1 = $1_1 & 31; 14038 block2 : { 14039 if (!$5_1) { 14040 break block2 14041 } 14042 $1_1 = $5_1 << 2; 14043 if (!$1_1) { 14044 break block2 14045 } 14046 wasm2js_memory_fill($0_1, 0, $1_1); 14047 } 14048 $3_1 = HEAP32[$0_1 + 160 >> 2]; 14049 $1_1 = $5_1 + $3_1 | 0; 14050 if (!$4_1) { 14051 HEAP32[$0_1 + 160 >> 2] = $1_1; 14052 return $0_1; 14053 } 14054 $2_1 = $1_1 - 1 | 0; 14055 if ($2_1 >>> 0 > 39) { 14056 break block3 14057 } 14058 $7_1 = $1_1; 14059 $6_1 = 32 - $4_1 | 0; 14060 $2_1 = HEAP32[($2_1 << 2) + $0_1 >> 2] >>> $6_1 | 0; 14061 if (!$2_1) { 14062 break block4 14063 } 14064 if ($1_1 >>> 0 <= 39) { 14065 HEAP32[($1_1 << 2) + $0_1 >> 2] = $2_1; 14066 $7_1 = $1_1 + 1 | 0; 14067 break block4; 14068 } 14069 $137($1_1, 40, 1062848); 14070 wasm2js_trap(); 14071 } 14072 $137($3_1, 40, 1062848); 14073 wasm2js_trap(); 14074 } 14075 $137($6_1, 40, 1062848); 14076 wasm2js_trap(); 14077 } 14078 $129(1062864, 29, 1062848); 14079 wasm2js_trap(); 14080 } 14081 $137($2_1, 40, 1062848); 14082 wasm2js_trap(); 14083 } 14084 $9_1 = $5_1 + 1 | 0; 14085 block5 : { 14086 if ($1_1 >>> 0 <= $9_1 >>> 0) { 14087 break block5 14088 } 14089 block6 : { 14090 if ($3_1 & 1) { 14091 $2_1 = $1_1; 14092 break block6; 14093 } 14094 $2_1 = $1_1 - 1 | 0; 14095 $8_1 = ($2_1 << 2) + $0_1 | 0; 14096 HEAP32[$8_1 >> 2] = HEAP32[$8_1 >> 2] << $4_1 | HEAP32[(($1_1 << 2) + $0_1 | 0) - 8 >> 2] >>> $6_1; 14097 } 14098 if (($3_1 | 0) == 2) { 14099 break block5 14100 } 14101 $3_1 = ($0_1 + ($2_1 << 2) | 0) - 12 | 0; 14102 while (1) { 14103 $1_1 = $3_1 + 8 | 0; 14104 $10_1 = $1_1; 14105 $11_1 = HEAP32[$1_1 >> 2] << $4_1; 14106 $1_1 = $3_1 + 4 | 0; 14107 $8_1 = HEAP32[$1_1 >> 2]; 14108 HEAP32[$10_1 >> 2] = $11_1 | $8_1 >>> $6_1; 14109 HEAP32[$1_1 >> 2] = $8_1 << $4_1 | HEAP32[$3_1 >> 2] >>> $6_1; 14110 $3_1 = $3_1 - 8 | 0; 14111 $2_1 = $2_1 - 2 | 0; 14112 if ($2_1 >>> 0 > $9_1 >>> 0) { 14113 continue 14114 } 14115 break; 14116 }; 14117 } 14118 $1_1 = ($5_1 << 2) + $0_1 | 0; 14119 HEAP32[$1_1 >> 2] = HEAP32[$1_1 >> 2] << $4_1; 14120 HEAP32[$0_1 + 160 >> 2] = $7_1; 14121 return $0_1; 14122 } 14123 14124 function $140($0_1, $1_1, $2_1, $3_1, $4_1, $5_1) { 14125 var $6_1 = 0, $7_1 = 0, $8_1 = 0, $9_1 = 0, $10_1 = 0, $11_1 = 0, $12_1 = 0, $13_1 = 0; 14126 block : { 14127 if (!$1_1) { 14128 $7_1 = HEAP32[$0_1 + 8 >> 2]; 14129 $13_1 = 45; 14130 $8_1 = $5_1 + 1 | 0; 14131 break block; 14132 } 14133 $7_1 = HEAP32[$0_1 + 8 >> 2]; 14134 $1_1 = $7_1 & 2097152; 14135 $13_1 = $1_1 ? 43 : -1; 14136 $8_1 = $5_1 + ($1_1 >>> 21 | 0) | 0; 14137 } 14138 block1 : { 14139 if (!($7_1 & 8388608)) { 14140 $2_1 = 0; 14141 break block1; 14142 } 14143 block2 : { 14144 if ($3_1 >>> 0 >= 16) { 14145 $1_1 = $141($2_1, $3_1); 14146 break block2; 14147 } 14148 if (!$3_1) { 14149 $1_1 = 0; 14150 break block2; 14151 } 14152 $9_1 = $3_1 & 3; 14153 $1_1 = 0; 14154 if ($3_1 >>> 0 >= 4) { 14155 $6_1 = $3_1 & 12; 14156 while (1) { 14157 $11_1 = $2_1 + $10_1 | 0; 14158 $1_1 = ((((HEAP8[$11_1 | 0] > -65) + $1_1 | 0) + (HEAP8[$11_1 + 1 | 0] > -65) | 0) + (HEAP8[$11_1 + 2 | 0] > -65) | 0) + (HEAP8[$11_1 + 3 | 0] > -65) | 0; 14159 $10_1 = $10_1 + 4 | 0; 14160 if (($10_1 | 0) != ($6_1 | 0)) { 14161 continue 14162 } 14163 break; 14164 }; 14165 if (!$9_1) { 14166 break block2 14167 } 14168 } 14169 $6_1 = $2_1 + $10_1 | 0; 14170 while (1) { 14171 $1_1 = (HEAP8[$6_1 | 0] > -65) + $1_1 | 0; 14172 $6_1 = $6_1 + 1 | 0; 14173 $9_1 = $9_1 - 1 | 0; 14174 if ($9_1) { 14175 continue 14176 } 14177 break; 14178 }; 14179 } 14180 $8_1 = $1_1 + $8_1 | 0; 14181 } 14182 block9 : { 14183 block7 : { 14184 block10 : { 14185 block11 : { 14186 block8 : { 14187 block3 : { 14188 block6 : { 14189 block5 : { 14190 block4 : { 14191 $9_1 = HEAPU16[$0_1 + 12 >> 1]; 14192 if ($8_1 >>> 0 < $9_1 >>> 0) { 14193 if ($7_1 & 16777216) { 14194 break block3 14195 } 14196 $6_1 = $9_1 - $8_1 | 0; 14197 $8_1 = 0; 14198 switch (($7_1 >>> 29 & 3) - 1 | 0) { 14199 case 0: 14200 case 2: 14201 break block4; 14202 case 1: 14203 break block5; 14204 default: 14205 break block6; 14206 }; 14207 } 14208 $1_1 = HEAP32[$0_1 >> 2]; 14209 $0_1 = HEAP32[$0_1 + 4 >> 2]; 14210 if (!$142($1_1, $0_1, $13_1, $2_1, $3_1)) { 14211 break block7 14212 } 14213 return 1; 14214 } 14215 $8_1 = $6_1; 14216 break block6; 14217 } 14218 $8_1 = ($6_1 & 65534) >>> 1 | 0; 14219 } 14220 $9_1 = $7_1 & 2097151; 14221 $12_1 = HEAP32[$0_1 + 4 >> 2]; 14222 $10_1 = HEAP32[$0_1 >> 2]; 14223 $11_1 = $8_1 & 65535; 14224 if (!$11_1) { 14225 break block8 14226 } 14227 $0_1 = HEAP32[$12_1 + 16 >> 2]; 14228 $1_1 = 0; 14229 $7_1 = 1; 14230 while (1) { 14231 if (FUNCTION_TABLE[$0_1 | 0]($10_1, $9_1) | 0) { 14232 break block9 14233 } 14234 $1_1 = $1_1 + 1 | 0; 14235 if (($1_1 & 65535) >>> 0 < $11_1 >>> 0) { 14236 continue 14237 } 14238 break; 14239 }; 14240 break block8; 14241 } 14242 $10_1 = HEAP32[$0_1 + 12 >> 2]; 14243 $12_1 = HEAP32[$0_1 + 8 >> 2]; 14244 HEAP32[$0_1 + 8 >> 2] = $12_1 & -1612709888 | 536870960; 14245 $7_1 = 1; 14246 $11_1 = HEAP32[$0_1 >> 2]; 14247 $6_1 = HEAP32[$0_1 + 4 >> 2]; 14248 if ($142($11_1, $6_1, $13_1, $2_1, $3_1)) { 14249 break block9 14250 } 14251 if (($8_1 & 65535) == ($9_1 | 0)) { 14252 break block10 14253 } 14254 $3_1 = HEAP32[$6_1 + 16 >> 2]; 14255 $1_1 = 0; 14256 $2_1 = $9_1 - $8_1 & 65535; 14257 break block11; 14258 } 14259 $7_1 = 1; 14260 if ($142($10_1, $12_1, $13_1, $2_1, $3_1)) { 14261 break block9 14262 } 14263 if (FUNCTION_TABLE[HEAP32[$12_1 + 12 >> 2]]($10_1, $4_1, $5_1) | 0) { 14264 break block9 14265 } 14266 if (($6_1 & 65535) == ($8_1 & 65535)) { 14267 return 0 14268 } 14269 $2_1 = HEAP32[$12_1 + 16 >> 2]; 14270 $1_1 = 0; 14271 $0_1 = $6_1 - $8_1 & 65535; 14272 while (1) { 14273 $7_1 = FUNCTION_TABLE[$2_1 | 0]($10_1, $9_1) | 0; 14274 if ($7_1) { 14275 break block9 14276 } 14277 $1_1 = $1_1 + 1 | 0; 14278 if ($0_1 >>> 0 > ($1_1 & 65535) >>> 0) { 14279 continue 14280 } 14281 break; 14282 }; 14283 break block9; 14284 } 14285 while (1) { 14286 if (!(FUNCTION_TABLE[$3_1 | 0]($11_1, 48) | 0)) { 14287 $1_1 = $1_1 + 1 | 0; 14288 if (($1_1 & 65535) >>> 0 < $2_1 >>> 0) { 14289 continue 14290 } 14291 break block10; 14292 } 14293 break; 14294 }; 14295 return 1; 14296 } 14297 if (FUNCTION_TABLE[HEAP32[$6_1 + 12 >> 2]]($11_1, $4_1, $5_1) | 0) { 14298 break block9 14299 } 14300 HEAP32[$0_1 + 8 >> 2] = $12_1; 14301 HEAP32[$0_1 + 12 >> 2] = $10_1; 14302 return 0; 14303 } 14304 $7_1 = FUNCTION_TABLE[HEAP32[$0_1 + 12 >> 2]]($1_1, $4_1, $5_1) | 0; 14305 } 14306 return $7_1; 14307 } 14308 14309 function $141($0_1, $1_1) { 14310 var $2_1 = 0, $3_1 = 0, $4_1 = 0, $5_1 = 0, $6_1 = 0, $7_1 = 0, $8_1 = 0, $9_1 = 0; 14311 block2 : { 14312 block : { 14313 $3_1 = $0_1 + 3 & -4; 14314 $6_1 = $3_1 - $0_1 | 0; 14315 if ($6_1 >>> 0 > $1_1 >>> 0) { 14316 break block 14317 } 14318 $9_1 = $1_1 - $6_1 | 0; 14319 $8_1 = $9_1 >>> 2 | 0; 14320 if (!$8_1) { 14321 break block 14322 } 14323 $1_1 = 0; 14324 if (($0_1 | 0) != ($3_1 | 0)) { 14325 $3_1 = $0_1 - $3_1 | 0; 14326 if ($3_1 >>> 0 <= 4294967292) { 14327 while (1) { 14328 $2_1 = $0_1 + $4_1 | 0; 14329 $1_1 = ((((HEAP8[$2_1 | 0] > -65) + $1_1 | 0) + (HEAP8[$2_1 + 1 | 0] > -65) | 0) + (HEAP8[$2_1 + 2 | 0] > -65) | 0) + (HEAP8[$2_1 + 3 | 0] > -65) | 0; 14330 $4_1 = $4_1 + 4 | 0; 14331 if ($4_1) { 14332 continue 14333 } 14334 break; 14335 } 14336 } 14337 $2_1 = $0_1 + $4_1 | 0; 14338 while (1) { 14339 $1_1 = (HEAP8[$2_1 | 0] > -65) + $1_1 | 0; 14340 $2_1 = $2_1 + 1 | 0; 14341 $3_1 = $3_1 + 1 | 0; 14342 if ($3_1) { 14343 continue 14344 } 14345 break; 14346 }; 14347 } 14348 $3_1 = $0_1 + $6_1 | 0; 14349 $0_1 = $9_1 & 3; 14350 block1 : { 14351 if (!$0_1) { 14352 break block1 14353 } 14354 $4_1 = ($9_1 & 2147483644) + $3_1 | 0; 14355 $5_1 = HEAP8[$4_1 | 0] > -65; 14356 if (($0_1 | 0) == 1) { 14357 break block1 14358 } 14359 $5_1 = (HEAP8[$4_1 + 1 | 0] > -65) + $5_1 | 0; 14360 if (($0_1 | 0) == 2) { 14361 break block1 14362 } 14363 $5_1 = (HEAP8[$4_1 + 2 | 0] > -65) + $5_1 | 0; 14364 } 14365 $4_1 = $1_1 + $5_1 | 0; 14366 while (1) { 14367 $0_1 = $3_1; 14368 if (!$8_1) { 14369 break block2 14370 } 14371 $5_1 = $8_1 >>> 0 >= 192 ? 192 : $8_1; 14372 $6_1 = $5_1 & 3; 14373 $3_1 = $5_1 << 2; 14374 $1_1 = $3_1 & 1008; 14375 block3 : { 14376 if (!$1_1) { 14377 $2_1 = 0; 14378 break block3; 14379 } 14380 $9_1 = $0_1 + $1_1 | 0; 14381 $2_1 = 0; 14382 $1_1 = $0_1; 14383 while (1) { 14384 $7_1 = $2_1; 14385 $2_1 = HEAP32[$1_1 >> 2]; 14386 $7_1 = $7_1 + ((($2_1 ^ -1) >>> 7 | $2_1 >>> 6) & 16843009) | 0; 14387 $2_1 = HEAP32[$1_1 + 4 >> 2]; 14388 $7_1 = $7_1 + ((($2_1 ^ -1) >>> 7 | $2_1 >>> 6) & 16843009) | 0; 14389 $2_1 = HEAP32[$1_1 + 8 >> 2]; 14390 $7_1 = $7_1 + ((($2_1 ^ -1) >>> 7 | $2_1 >>> 6) & 16843009) | 0; 14391 $2_1 = HEAP32[$1_1 + 12 >> 2]; 14392 $2_1 = $7_1 + ((($2_1 ^ -1) >>> 7 | $2_1 >>> 6) & 16843009) | 0; 14393 $1_1 = $1_1 + 16 | 0; 14394 if (($9_1 | 0) != ($1_1 | 0)) { 14395 continue 14396 } 14397 break; 14398 }; 14399 } 14400 $8_1 = $8_1 - $5_1 | 0; 14401 $3_1 = $0_1 + $3_1 | 0; 14402 $4_1 = $4_1 + (Math_imul(($2_1 >>> 8 & 16711935) + ($2_1 & 16711935) | 0, 65537) >>> 16 | 0) | 0; 14403 if (!$6_1) { 14404 continue 14405 } 14406 break; 14407 }; 14408 $0_1 = (($5_1 & 252) << 2) + $0_1 | 0; 14409 $1_1 = HEAP32[$0_1 >> 2]; 14410 $1_1 = (($1_1 ^ -1) >>> 7 | $1_1 >>> 6) & 16843009; 14411 $2_1 = $1_1; 14412 block4 : { 14413 if (($6_1 | 0) == 1) { 14414 break block4 14415 } 14416 $1_1 = HEAP32[$0_1 + 4 >> 2]; 14417 $1_1 = $2_1 + ((($1_1 ^ -1) >>> 7 | $1_1 >>> 6) & 16843009) | 0; 14418 $2_1 = $1_1; 14419 if (($6_1 | 0) == 2) { 14420 break block4 14421 } 14422 $0_1 = HEAP32[$0_1 + 8 >> 2]; 14423 $2_1 = $1_1 + ((($0_1 ^ -1) >>> 7 | $0_1 >>> 6) & 16843009) | 0; 14424 } 14425 $1_1 = $2_1; 14426 $4_1 = $4_1 + (Math_imul(($1_1 >>> 8 & 459007) + ($1_1 & 16711935) | 0, 65537) >>> 16 | 0) | 0; 14427 break block2; 14428 } 14429 if (!$1_1) { 14430 return 0 14431 } 14432 $2_1 = $1_1 & 3; 14433 $3_1 = 0; 14434 if ($1_1 >>> 0 >= 4) { 14435 $5_1 = $1_1 & -4; 14436 while (1) { 14437 $1_1 = $0_1 + $3_1 | 0; 14438 $4_1 = ((((HEAP8[$1_1 | 0] > -65) + $4_1 | 0) + (HEAP8[$1_1 + 1 | 0] > -65) | 0) + (HEAP8[$1_1 + 2 | 0] > -65) | 0) + (HEAP8[$1_1 + 3 | 0] > -65) | 0; 14439 $3_1 = $3_1 + 4 | 0; 14440 if (($3_1 | 0) != ($5_1 | 0)) { 14441 continue 14442 } 14443 break; 14444 }; 14445 if (!$2_1) { 14446 break block2 14447 } 14448 } 14449 $1_1 = $0_1 + $3_1 | 0; 14450 while (1) { 14451 $4_1 = (HEAP8[$1_1 | 0] > -65) + $4_1 | 0; 14452 $1_1 = $1_1 + 1 | 0; 14453 $2_1 = $2_1 - 1 | 0; 14454 if ($2_1) { 14455 continue 14456 } 14457 break; 14458 }; 14459 } 14460 return $4_1; 14461 } 14462 14463 function $142($0_1, $1_1, $2_1, $3_1, $4_1) { 14464 block : { 14465 if (($2_1 | 0) == -1) { 14466 break block 14467 } 14468 if (!(FUNCTION_TABLE[HEAP32[$1_1 + 16 >> 2]]($0_1, $2_1) | 0)) { 14469 break block 14470 } 14471 return 1; 14472 } 14473 if (!$3_1) { 14474 return 0 14475 } 14476 return FUNCTION_TABLE[HEAP32[$1_1 + 12 >> 2]]($0_1, $3_1, $4_1) | 0; 14477 } 14478 14479 function $143($0_1, $1_1, $2_1) { 14480 var $3_1 = 0, $4_1 = 0, $5_1 = 0, $6_1 = 0, $7_1 = 0, $8_1 = 0, $9_1 = 0; 14481 $7_1 = global$0 - 16 | 0; 14482 global$0 = $7_1; 14483 block1 : { 14484 block : { 14485 $3_1 = HEAP32[$2_1 + 4 >> 2]; 14486 if (!$3_1) { 14487 break block 14488 } 14489 if (!(FUNCTION_TABLE[HEAP32[$1_1 + 12 >> 2]]($0_1, HEAP32[$2_1 >> 2], $3_1) | 0)) { 14490 break block 14491 } 14492 $4_1 = 1; 14493 break block1; 14494 } 14495 $3_1 = HEAP32[$2_1 + 12 >> 2]; 14496 if ($3_1) { 14497 $5_1 = HEAP32[$2_1 + 8 >> 2]; 14498 $9_1 = $5_1 + Math_imul($3_1, 12) | 0; 14499 while (1) { 14500 block6 : { 14501 block2 : { 14502 switch (HEAPU16[$5_1 >> 1] - 1 | 0) { 14503 default: 14504 $2_1 = HEAP32[$5_1 + 4 >> 2]; 14505 block5 : { 14506 if ($2_1 >>> 0 >= 65) { 14507 $3_1 = HEAP32[$1_1 + 12 >> 2]; 14508 while (1) { 14509 $4_1 = 1; 14510 if (FUNCTION_TABLE[$3_1 | 0]($0_1, 1062893, 64) | 0) { 14511 break block1 14512 } 14513 $2_1 = $2_1 + -64 | 0; 14514 if ($2_1 >>> 0 > 64) { 14515 continue 14516 } 14517 break; 14518 }; 14519 break block5; 14520 } 14521 if (!$2_1) { 14522 break block6 14523 } 14524 } 14525 if (!(FUNCTION_TABLE[HEAP32[$1_1 + 12 >> 2]]($0_1, 1062893, $2_1) | 0)) { 14526 break block6 14527 } 14528 $4_1 = 1; 14529 break block1; 14530 case 1: 14531 if (!(FUNCTION_TABLE[HEAP32[$1_1 + 12 >> 2]]($0_1, HEAP32[$5_1 + 4 >> 2], HEAP32[$5_1 + 8 >> 2]) | 0)) { 14532 break block6 14533 } 14534 $4_1 = 1; 14535 break block1; 14536 case 0: 14537 break block2; 14538 }; 14539 } 14540 $2_1 = HEAPU16[$5_1 + 2 >> 1]; 14541 HEAP8[$7_1 + 12 | 0] = 0; 14542 HEAP32[$7_1 + 8 >> 2] = 0; 14543 if ($2_1) { 14544 $3_1 = (($2_1 + 393206 & $2_1 + 524188 ^ $2_1 + 916504 & $2_1 + 514288) >>> 17 | 0) + 1 | 0 14545 } else { 14546 $3_1 = 1 14547 } 14548 $8_1 = $3_1 - 1 | 0; 14549 $6_1 = $8_1 + ($7_1 + 8 | 0) | 0; 14550 $4_1 = ($2_1 >>> 0) / 10 | 0; 14551 HEAP8[$6_1 | 0] = $2_1 - Math_imul($4_1, 10) | 48; 14552 block7 : { 14553 if (!$8_1) { 14554 break block7 14555 } 14556 HEAP8[$6_1 - 1 | 0] = ($4_1 >>> 0) % 10 | 48; 14557 if (($3_1 | 0) == 2) { 14558 break block7 14559 } 14560 HEAP8[$6_1 - 2 | 0] = (($2_1 >>> 0) / 100 >>> 0) % 10 | 48; 14561 if (($3_1 | 0) == 3) { 14562 break block7 14563 } 14564 HEAP8[$6_1 - 3 | 0] = (($2_1 >>> 0) / 1e3 >>> 0) % 10 | 48; 14565 if (($3_1 | 0) == 4) { 14566 break block7 14567 } 14568 HEAP8[$6_1 - 4 | 0] = ($2_1 >>> 0) / 1e4 | 48; 14569 if (($3_1 | 0) == 5) { 14570 break block7 14571 } 14572 HEAP8[$6_1 - 5 | 0] = 48; 14573 if (($3_1 | 0) == 6) { 14574 break block7 14575 } 14576 HEAP8[$6_1 - 6 | 0] = 48; 14577 if (($3_1 | 0) == 7) { 14578 break block7 14579 } 14580 HEAP8[$6_1 - 7 | 0] = 48; 14581 } 14582 if (!(FUNCTION_TABLE[HEAP32[$1_1 + 12 >> 2]]($0_1, $7_1 + 8 | 0, $3_1) | 0)) { 14583 break block6 14584 } 14585 $4_1 = 1; 14586 break block1; 14587 } 14588 $5_1 = $5_1 + 12 | 0; 14589 if (($9_1 | 0) != ($5_1 | 0)) { 14590 continue 14591 } 14592 break; 14593 }; 14594 } 14595 $4_1 = 0; 14596 } 14597 global$0 = $7_1 + 16 | 0; 14598 return $4_1; 14599 } 14600 14601 function $144($0_1, $1_1, $2_1) { 14602 var $3_1 = 0, $4_1 = 0, $5_1 = 0, $6_1 = 0, $7_1 = 0, $8_1 = 0, $9_1 = 0, $10_1 = 0; 14603 block9 : { 14604 block : { 14605 $7_1 = HEAP32[$0_1 + 8 >> 2]; 14606 if (!($7_1 & 402653184)) { 14607 break block 14608 } 14609 block3 : { 14610 block4 : { 14611 block2 : { 14612 block1 : { 14613 if ($7_1 & 268435456) { 14614 $6_1 = HEAPU16[$0_1 + 14 >> 1]; 14615 if ($6_1) { 14616 break block1 14617 } 14618 $2_1 = 0; 14619 break block2; 14620 } 14621 if ($2_1 >>> 0 >= 16) { 14622 $4_1 = $141($1_1, $2_1); 14623 break block3; 14624 } 14625 if (!$2_1) { 14626 break block3 14627 } 14628 $5_1 = $2_1 & 3; 14629 if ($2_1 >>> 0 >= 4) { 14630 $8_1 = $2_1 & 12; 14631 while (1) { 14632 $6_1 = $1_1 + $3_1 | 0; 14633 $4_1 = ((((HEAP8[$6_1 | 0] > -65) + $4_1 | 0) + (HEAP8[$6_1 + 1 | 0] > -65) | 0) + (HEAP8[$6_1 + 2 | 0] > -65) | 0) + (HEAP8[$6_1 + 3 | 0] > -65) | 0; 14634 $3_1 = $3_1 + 4 | 0; 14635 if (($3_1 | 0) != ($8_1 | 0)) { 14636 continue 14637 } 14638 break; 14639 }; 14640 if (!$5_1) { 14641 break block3 14642 } 14643 } 14644 $3_1 = $1_1 + $3_1 | 0; 14645 while (1) { 14646 $4_1 = (HEAP8[$3_1 | 0] > -65) + $4_1 | 0; 14647 $3_1 = $3_1 + 1 | 0; 14648 $5_1 = $5_1 - 1 | 0; 14649 if ($5_1) { 14650 continue 14651 } 14652 break; 14653 }; 14654 break block3; 14655 } 14656 $8_1 = $1_1 + $2_1 | 0; 14657 $2_1 = 0; 14658 $3_1 = $1_1; 14659 $5_1 = $6_1; 14660 while (1) { 14661 $4_1 = $3_1; 14662 if (($8_1 | 0) == ($3_1 | 0)) { 14663 break block4 14664 } 14665 $9_1 = $3_1 + 1 | 0; 14666 $3_1 = HEAP8[$3_1 | 0]; 14667 block5 : { 14668 if (($3_1 | 0) >= 0) { 14669 break block5 14670 } 14671 $9_1 = $4_1 + 2 | 0; 14672 if ($3_1 >>> 0 < 4294967264) { 14673 break block5 14674 } 14675 $9_1 = ($3_1 >>> 0 > 4294967279 ? 4 : 3) + $4_1 | 0; 14676 } 14677 $3_1 = $9_1; 14678 $2_1 = $2_1 + ($3_1 - $4_1 | 0) | 0; 14679 $5_1 = $5_1 - 1 | 0; 14680 if ($5_1) { 14681 continue 14682 } 14683 break; 14684 }; 14685 } 14686 $5_1 = 0; 14687 } 14688 $4_1 = $6_1 - $5_1 | 0; 14689 } 14690 $3_1 = HEAPU16[$0_1 + 12 >> 1]; 14691 if ($3_1 >>> 0 <= $4_1 >>> 0) { 14692 break block 14693 } 14694 $5_1 = $3_1 - $4_1 | 0; 14695 $3_1 = 0; 14696 block8 : { 14697 block7 : { 14698 switch (($7_1 >>> 29 & 3) - 1 | 0) { 14699 case 0: 14700 $3_1 = $5_1; 14701 break block8; 14702 case 1: 14703 break block7; 14704 default: 14705 break block8; 14706 }; 14707 } 14708 $3_1 = ($5_1 & 65534) >>> 1 | 0; 14709 } 14710 $8_1 = $7_1 & 2097151; 14711 $6_1 = HEAP32[$0_1 + 4 >> 2]; 14712 $7_1 = HEAP32[$0_1 >> 2]; 14713 $9_1 = $3_1 & 65535; 14714 if ($9_1) { 14715 $10_1 = HEAP32[$6_1 + 16 >> 2]; 14716 $4_1 = 0; 14717 $0_1 = 1; 14718 while (1) { 14719 if (FUNCTION_TABLE[$10_1 | 0]($7_1, $8_1) | 0) { 14720 break block9 14721 } 14722 $4_1 = $4_1 + 1 | 0; 14723 if ($9_1 >>> 0 > ($4_1 & 65535) >>> 0) { 14724 continue 14725 } 14726 break; 14727 }; 14728 } 14729 if (FUNCTION_TABLE[HEAP32[$6_1 + 12 >> 2]]($7_1, $1_1, $2_1) | 0) { 14730 return 1 14731 } 14732 if (($5_1 & 65535) == ($3_1 & 65535)) { 14733 return 0 14734 } 14735 $1_1 = HEAP32[$6_1 + 16 >> 2]; 14736 $4_1 = 0; 14737 $2_1 = $5_1 - $3_1 & 65535; 14738 while (1) { 14739 $0_1 = FUNCTION_TABLE[$1_1 | 0]($7_1, $8_1) | 0; 14740 if ($0_1) { 14741 break block9 14742 } 14743 $4_1 = $4_1 + 1 | 0; 14744 if (($4_1 & 65535) >>> 0 < $2_1 >>> 0) { 14745 continue 14746 } 14747 break; 14748 }; 14749 break block9; 14750 } 14751 $0_1 = FUNCTION_TABLE[HEAP32[HEAP32[$0_1 + 4 >> 2] + 12 >> 2]](HEAP32[$0_1 >> 2], $1_1, $2_1) | 0; 14752 } 14753 return $0_1; 14754 } 14755 14756 function $145($0_1, $1_1, $2_1) { 14757 return FUNCTION_TABLE[HEAP32[HEAP32[$0_1 + 4 >> 2] + 12 >> 2]](HEAP32[$0_1 >> 2], $1_1, $2_1) | 0; 14758 } 14759 14760 function $146($0_1, $1_1, $2_1, $3_1, $4_1) { 14761 var $5_1 = 0, $6_1 = 0, $7_1 = 0, $8_1 = 0, $9_1 = 0, $10_1 = 0, $11_1 = 0, $12_1 = 0, $13_1 = 0, $14_1 = 0, $15_1 = 0, $16_1 = 0, $17_1 = 0, $18_1 = 0, $19_1 = 0, $20_1 = 0; 14762 block8 : { 14763 block9 : { 14764 if ($4_1) { 14765 $5_1 = 1; 14766 $19_1 = 1; 14767 if (($4_1 | 0) != 1) { 14768 $7_1 = 1; 14769 $10_1 = 1; 14770 while (1) { 14771 block : { 14772 $12_1 = $9_1 + $14_1 | 0; 14773 if ($12_1 >>> 0 < $4_1 >>> 0) { 14774 $7_1 = HEAPU8[$3_1 + $7_1 | 0]; 14775 $12_1 = HEAPU8[$3_1 + $12_1 | 0]; 14776 if ($7_1 >>> 0 >= $12_1 >>> 0) { 14777 if (($7_1 | 0) != ($12_1 | 0)) { 14778 $5_1 = 1; 14779 $9_1 = 0; 14780 $14_1 = $10_1; 14781 $10_1 = $10_1 + 1 | 0; 14782 break block; 14783 } 14784 $12_1 = $9_1 + 1 | 0; 14785 $7_1 = ($12_1 | 0) == ($5_1 | 0); 14786 $9_1 = $7_1 ? 0 : $12_1; 14787 $10_1 = $10_1 + ($7_1 ? $12_1 : 0) | 0; 14788 break block; 14789 } 14790 $10_1 = ($9_1 + $10_1 | 0) + 1 | 0; 14791 $5_1 = $10_1 - $14_1 | 0; 14792 $9_1 = 0; 14793 break block; 14794 } 14795 $137($12_1, $4_1, 1063744); 14796 wasm2js_trap(); 14797 } 14798 $7_1 = $9_1 + $10_1 | 0; 14799 if ($4_1 >>> 0 > $7_1 >>> 0) { 14800 continue 14801 } 14802 break; 14803 }; 14804 $7_1 = 1; 14805 $10_1 = 1; 14806 $9_1 = 0; 14807 $12_1 = 0; 14808 while (1) { 14809 block2 : { 14810 block1 : { 14811 $16_1 = $9_1 + $12_1 | 0; 14812 if ($16_1 >>> 0 < $4_1 >>> 0) { 14813 $7_1 = HEAPU8[$3_1 + $7_1 | 0]; 14814 $16_1 = HEAPU8[$3_1 + $16_1 | 0]; 14815 if ($7_1 >>> 0 > $16_1 >>> 0) { 14816 break block1 14817 } 14818 if (($7_1 | 0) != ($16_1 | 0)) { 14819 $19_1 = 1; 14820 $12_1 = $10_1; 14821 $10_1 = $10_1 + 1 | 0; 14822 $9_1 = 0; 14823 break block2; 14824 } 14825 $7_1 = $9_1 + 1 | 0; 14826 $16_1 = ($19_1 | 0) == ($7_1 | 0); 14827 $10_1 = $10_1 + ($16_1 ? $7_1 : 0) | 0; 14828 $9_1 = $16_1 ? 0 : $7_1; 14829 break block2; 14830 } 14831 $137($16_1, $4_1, 1063744); 14832 wasm2js_trap(); 14833 } 14834 $10_1 = ($9_1 + $10_1 | 0) + 1 | 0; 14835 $19_1 = $10_1 - $12_1 | 0; 14836 $9_1 = 0; 14837 } 14838 $7_1 = $9_1 + $10_1 | 0; 14839 if ($4_1 >>> 0 > $7_1 >>> 0) { 14840 continue 14841 } 14842 break; 14843 }; 14844 } 14845 block13 : { 14846 block12 : { 14847 $10_1 = $12_1 >>> 0 < $14_1 >>> 0; 14848 $16_1 = $10_1 ? $14_1 : $12_1; 14849 if ($4_1 >>> 0 >= $16_1 >>> 0) { 14850 block7 : { 14851 block3 : { 14852 block6 : { 14853 block5 : { 14854 block4 : { 14855 $10_1 = $10_1 ? $5_1 : $19_1; 14856 $5_1 = $16_1 + $10_1 | 0; 14857 if (!($5_1 >>> 0 < $10_1 >>> 0 | $4_1 >>> 0 < $5_1 >>> 0)) { 14858 if (!$168($3_1, $3_1 + $10_1 | 0, $16_1)) { 14859 break block3 14860 } 14861 $10_1 = $4_1 & 3; 14862 if ($4_1 - 1 >>> 0 >= 3) { 14863 break block4 14864 } 14865 $7_1 = 0; 14866 break block5; 14867 } 14868 $135($10_1, $5_1, $4_1, 1063792); 14869 wasm2js_trap(); 14870 } 14871 $12_1 = $4_1 & -4; 14872 $7_1 = 0; 14873 while (1) { 14874 $8_1 = 0; 14875 $15_1 = 1; 14876 $5_1 = $3_1 + $7_1 | 0; 14877 $13_1 = HEAPU8[$5_1 + 3 | 0]; 14878 $6_1 = $13_1 & 31; 14879 if (($13_1 & 63) >>> 0 >= 32) { 14880 $11_1 = $15_1 << $6_1; 14881 $14_1 = 0; 14882 } else { 14883 $11_1 = (1 << $6_1) - 1 & $15_1 >>> 32 - $6_1 | $8_1 << $6_1; 14884 $14_1 = $15_1 << $6_1; 14885 } 14886 $9_1 = $11_1; 14887 $15_1 = 0; 14888 $8_1 = 1; 14889 $13_1 = HEAPU8[$5_1 | 0]; 14890 $6_1 = $13_1 & 31; 14891 if (($13_1 & 63) >>> 0 >= 32) { 14892 $11_1 = $8_1 << $6_1; 14893 $20_1 = 0; 14894 } else { 14895 $11_1 = (1 << $6_1) - 1 & $8_1 >>> 32 - $6_1 | $15_1 << $6_1; 14896 $20_1 = $8_1 << $6_1; 14897 } 14898 $17_1 = $20_1 | $17_1; 14899 $18_1 = $11_1 | $18_1; 14900 $11_1 = 1; 14901 $13_1 = HEAPU8[$5_1 + 1 | 0]; 14902 $6_1 = $13_1 & 31; 14903 if (($13_1 & 63) >>> 0 >= 32) { 14904 $8_1 = $11_1 << $6_1; 14905 $20_1 = 0; 14906 } else { 14907 $8_1 = (1 << $6_1) - 1 & $11_1 >>> 32 - $6_1 | $15_1 << $6_1; 14908 $20_1 = $11_1 << $6_1; 14909 } 14910 $17_1 = $20_1 | $17_1; 14911 $18_1 = $8_1 | $18_1; 14912 $8_1 = 1; 14913 $13_1 = HEAPU8[$5_1 + 2 | 0]; 14914 $6_1 = $13_1 & 31; 14915 if (($13_1 & 63) >>> 0 >= 32) { 14916 $11_1 = $8_1 << $6_1; 14917 $5_1 = 0; 14918 } else { 14919 $11_1 = (1 << $6_1) - 1 & $8_1 >>> 32 - $6_1 | $15_1 << $6_1; 14920 $5_1 = $8_1 << $6_1; 14921 } 14922 $17_1 = $5_1 | $17_1 | $14_1; 14923 $18_1 = $11_1 | $18_1 | $9_1; 14924 $7_1 = $7_1 + 4 | 0; 14925 if (($7_1 | 0) != ($12_1 | 0)) { 14926 continue 14927 } 14928 break; 14929 }; 14930 if (!$10_1) { 14931 break block6 14932 } 14933 } 14934 $9_1 = $3_1 + $7_1 | 0; 14935 while (1) { 14936 $11_1 = 0; 14937 $8_1 = 1; 14938 $13_1 = HEAPU8[$9_1 | 0]; 14939 $6_1 = $13_1 & 31; 14940 if (($13_1 & 63) >>> 0 >= 32) { 14941 $15_1 = $8_1 << $6_1; 14942 $12_1 = 0; 14943 } else { 14944 $15_1 = (1 << $6_1) - 1 & $8_1 >>> 32 - $6_1 | $11_1 << $6_1; 14945 $12_1 = $8_1 << $6_1; 14946 } 14947 $17_1 = $12_1 | $17_1; 14948 $18_1 = $15_1 | $18_1; 14949 $9_1 = $9_1 + 1 | 0; 14950 $10_1 = $10_1 - 1 | 0; 14951 if ($10_1) { 14952 continue 14953 } 14954 break; 14955 }; 14956 } 14957 $10_1 = $4_1 - $16_1 | 0; 14958 $10_1 = ($10_1 >>> 0 > $16_1 >>> 0 ? $10_1 : $16_1) + 1 | 0; 14959 $12_1 = $16_1; 14960 $7_1 = -1; 14961 $9_1 = -1; 14962 break block7; 14963 } 14964 $11_1 = $4_1 - 1 | 0; 14965 $14_1 = 1; 14966 $9_1 = 0; 14967 $5_1 = 1; 14968 $19_1 = 0; 14969 while (1) { 14970 $12_1 = $5_1; 14971 $8_1 = $9_1 + $5_1 | 0; 14972 if ($8_1 >>> 0 < $4_1 >>> 0) { 14973 $5_1 = ($4_1 - $9_1 | 0) + ($5_1 ^ -1) | 0; 14974 if ($4_1 >>> 0 <= $5_1 >>> 0) { 14975 break block8 14976 } 14977 $7_1 = $11_1 - ($9_1 + $19_1 | 0) | 0; 14978 if ($4_1 >>> 0 <= $7_1 >>> 0) { 14979 break block9 14980 } 14981 block11 : { 14982 block10 : { 14983 $5_1 = HEAPU8[$3_1 + $5_1 | 0]; 14984 $7_1 = HEAPU8[$3_1 + $7_1 | 0]; 14985 if ($5_1 >>> 0 >= $7_1 >>> 0) { 14986 if (($5_1 | 0) == ($7_1 | 0)) { 14987 break block10 14988 } 14989 $5_1 = $12_1 + 1 | 0; 14990 $9_1 = 0; 14991 $14_1 = 1; 14992 $19_1 = $12_1; 14993 break block11; 14994 } 14995 $5_1 = $8_1 + 1 | 0; 14996 $14_1 = $5_1 - $19_1 | 0; 14997 $9_1 = 0; 14998 break block11; 14999 } 15000 $5_1 = $9_1 + 1 | 0; 15001 $7_1 = ($14_1 | 0) == ($5_1 | 0); 15002 $9_1 = $7_1 ? 0 : $5_1; 15003 $5_1 = $12_1 + ($7_1 ? $5_1 : 0) | 0; 15004 } 15005 if (($10_1 | 0) != ($14_1 | 0)) { 15006 continue 15007 } 15008 } 15009 break; 15010 }; 15011 $14_1 = 1; 15012 $9_1 = 0; 15013 $5_1 = 1; 15014 $7_1 = 0; 15015 while (1) { 15016 $12_1 = $5_1; 15017 $15_1 = $9_1 + $5_1 | 0; 15018 if ($15_1 >>> 0 < $4_1 >>> 0) { 15019 $5_1 = ($4_1 - $9_1 | 0) + ($5_1 ^ -1) | 0; 15020 if ($4_1 >>> 0 <= $5_1 >>> 0) { 15021 break block12 15022 } 15023 $8_1 = $11_1 - ($7_1 + $9_1 | 0) | 0; 15024 if ($4_1 >>> 0 <= $8_1 >>> 0) { 15025 break block13 15026 } 15027 block15 : { 15028 block14 : { 15029 $5_1 = HEAPU8[$3_1 + $5_1 | 0]; 15030 $8_1 = HEAPU8[$3_1 + $8_1 | 0]; 15031 if ($5_1 >>> 0 <= $8_1 >>> 0) { 15032 if (($5_1 | 0) == ($8_1 | 0)) { 15033 break block14 15034 } 15035 $5_1 = $12_1 + 1 | 0; 15036 $9_1 = 0; 15037 $14_1 = 1; 15038 $7_1 = $12_1; 15039 break block15; 15040 } 15041 $5_1 = $15_1 + 1 | 0; 15042 $14_1 = $5_1 - $7_1 | 0; 15043 $9_1 = 0; 15044 break block15; 15045 } 15046 $5_1 = $9_1 + 1 | 0; 15047 $8_1 = ($14_1 | 0) == ($5_1 | 0); 15048 $9_1 = $8_1 ? 0 : $5_1; 15049 $5_1 = $12_1 + ($8_1 ? $5_1 : 0) | 0; 15050 } 15051 if (($10_1 | 0) != ($14_1 | 0)) { 15052 continue 15053 } 15054 } 15055 break; 15056 }; 15057 $12_1 = $4_1 - ($7_1 >>> 0 > $19_1 >>> 0 ? $7_1 : $19_1) | 0; 15058 block16 : { 15059 if (!$10_1) { 15060 $10_1 = 0; 15061 break block16; 15062 } 15063 $7_1 = $10_1 & 3; 15064 block17 : { 15065 if ($10_1 >>> 0 < 4) { 15066 $5_1 = 0; 15067 break block17; 15068 } 15069 $19_1 = $10_1 & -4; 15070 $5_1 = 0; 15071 while (1) { 15072 $11_1 = 0; 15073 $15_1 = 1; 15074 $14_1 = $3_1 + $5_1 | 0; 15075 $13_1 = HEAPU8[$14_1 + 3 | 0]; 15076 $6_1 = $13_1 & 31; 15077 if (($13_1 & 63) >>> 0 >= 32) { 15078 $8_1 = $15_1 << $6_1; 15079 $20_1 = 0; 15080 } else { 15081 $8_1 = (1 << $6_1) - 1 & $15_1 >>> 32 - $6_1 | $11_1 << $6_1; 15082 $20_1 = $15_1 << $6_1; 15083 } 15084 $9_1 = $8_1; 15085 $15_1 = 0; 15086 $11_1 = 1; 15087 $13_1 = HEAPU8[$14_1 | 0]; 15088 $6_1 = $13_1 & 31; 15089 if (($13_1 & 63) >>> 0 >= 32) { 15090 $8_1 = $11_1 << $6_1; 15091 $11_1 = 0; 15092 } else { 15093 $8_1 = (1 << $6_1) - 1 & $11_1 >>> 32 - $6_1 | $15_1 << $6_1; 15094 $11_1 = $11_1 << $6_1; 15095 } 15096 $17_1 = $11_1 | $17_1; 15097 $18_1 = $8_1 | $18_1; 15098 $8_1 = 1; 15099 $13_1 = HEAPU8[$14_1 + 1 | 0]; 15100 $6_1 = $13_1 & 31; 15101 if (($13_1 & 63) >>> 0 >= 32) { 15102 $11_1 = $8_1 << $6_1; 15103 $8_1 = 0; 15104 } else { 15105 $11_1 = (1 << $6_1) - 1 & $8_1 >>> 32 - $6_1 | $15_1 << $6_1; 15106 $8_1 = $8_1 << $6_1; 15107 } 15108 $17_1 = $8_1 | $17_1; 15109 $18_1 = $11_1 | $18_1; 15110 $11_1 = 1; 15111 $13_1 = HEAPU8[$14_1 + 2 | 0]; 15112 $6_1 = $13_1 & 31; 15113 if (($13_1 & 63) >>> 0 >= 32) { 15114 $8_1 = $11_1 << $6_1; 15115 $14_1 = 0; 15116 } else { 15117 $8_1 = (1 << $6_1) - 1 & $11_1 >>> 32 - $6_1 | $15_1 << $6_1; 15118 $14_1 = $11_1 << $6_1; 15119 } 15120 $17_1 = $14_1 | $17_1 | $20_1; 15121 $18_1 = $8_1 | $18_1 | $9_1; 15122 $5_1 = $5_1 + 4 | 0; 15123 if (($5_1 | 0) != ($19_1 | 0)) { 15124 continue 15125 } 15126 break; 15127 }; 15128 if (!$7_1) { 15129 break block16 15130 } 15131 } 15132 $9_1 = $3_1 + $5_1 | 0; 15133 while (1) { 15134 $8_1 = 0; 15135 $11_1 = 1; 15136 $13_1 = HEAPU8[$9_1 | 0]; 15137 $6_1 = $13_1 & 31; 15138 if (($13_1 & 63) >>> 0 >= 32) { 15139 $15_1 = $11_1 << $6_1; 15140 $14_1 = 0; 15141 } else { 15142 $15_1 = (1 << $6_1) - 1 & $11_1 >>> 32 - $6_1 | $8_1 << $6_1; 15143 $14_1 = $11_1 << $6_1; 15144 } 15145 $17_1 = $14_1 | $17_1; 15146 $18_1 = $15_1 | $18_1; 15147 $9_1 = $9_1 + 1 | 0; 15148 $7_1 = $7_1 - 1 | 0; 15149 if ($7_1) { 15150 continue 15151 } 15152 break; 15153 }; 15154 } 15155 $7_1 = $4_1; 15156 $9_1 = 0; 15157 } 15158 HEAP32[$0_1 + 60 >> 2] = $4_1; 15159 HEAP32[$0_1 + 56 >> 2] = $3_1; 15160 HEAP32[$0_1 + 52 >> 2] = $2_1; 15161 HEAP32[$0_1 + 48 >> 2] = $1_1; 15162 HEAP32[$0_1 + 40 >> 2] = $7_1; 15163 HEAP32[$0_1 + 36 >> 2] = $9_1; 15164 HEAP32[$0_1 + 32 >> 2] = $2_1; 15165 HEAP32[$0_1 + 28 >> 2] = 0; 15166 HEAP32[$0_1 + 24 >> 2] = $10_1; 15167 HEAP32[$0_1 + 20 >> 2] = $12_1; 15168 HEAP32[$0_1 + 16 >> 2] = $16_1; 15169 HEAP32[$0_1 + 8 >> 2] = $17_1; 15170 HEAP32[$0_1 + 12 >> 2] = $18_1; 15171 HEAP32[$0_1 >> 2] = 1; 15172 return; 15173 } 15174 $135(0, $16_1, $4_1, 1063808); 15175 wasm2js_trap(); 15176 } 15177 $137($5_1, $4_1, 1063760); 15178 wasm2js_trap(); 15179 } 15180 $137($8_1, $4_1, 1063776); 15181 wasm2js_trap(); 15182 } 15183 HEAP32[$0_1 + 60 >> 2] = 0; 15184 HEAP32[$0_1 + 56 >> 2] = $3_1; 15185 HEAP32[$0_1 + 52 >> 2] = $2_1; 15186 HEAP32[$0_1 + 48 >> 2] = $1_1; 15187 HEAP8[$0_1 + 14 | 0] = 0; 15188 HEAP16[$0_1 + 12 >> 1] = 257; 15189 HEAP32[$0_1 + 8 >> 2] = $2_1; 15190 HEAP32[$0_1 >> 2] = 0; 15191 HEAP32[$0_1 + 4 >> 2] = 0; 15192 return; 15193 } 15194 $137($7_1, $4_1, 1063776); 15195 wasm2js_trap(); 15196 } 15197 $137($5_1, $4_1, 1063760); 15198 wasm2js_trap(); 15199 } 15200 15201 function $147($0_1, $1_1) { 15202 $0_1 = $0_1 | 0; 15203 $1_1 = $1_1 | 0; 15204 var $2_1 = 0, $3_1 = 0, $4_1 = 0, $5_1 = 0, $6_1 = 0, $7_1 = 0, $8_1 = 0, $9_1 = 0, $10_1 = 0; 15205 $5_1 = global$0 - 16 | 0; 15206 global$0 = $5_1; 15207 $3_1 = 10; 15208 $8_1 = HEAP32[$0_1 >> 2]; 15209 $0_1 = $8_1; 15210 if ($0_1 >>> 0 >= 1e3) { 15211 while (1) { 15212 $2_1 = $3_1 + ($5_1 + 6 | 0) | 0; 15213 $4_1 = $2_1 - 4 | 0; 15214 $6_1 = $0_1; 15215 $0_1 = ($0_1 >>> 0) / 1e4 | 0; 15216 $9_1 = $6_1 - Math_imul($0_1, 1e4) | 0; 15217 $10_1 = (($9_1 & 65535) >>> 0) / 100 | 0; 15218 $7_1 = $10_1 << 1; 15219 $7_1 = HEAPU8[$7_1 + 1063894 | 0] | HEAPU8[$7_1 + 1063895 | 0] << 8; 15220 HEAP8[$4_1 | 0] = $7_1; 15221 HEAP8[$4_1 + 1 | 0] = $7_1 >>> 8; 15222 $2_1 = $2_1 - 2 | 0; 15223 $4_1 = ($9_1 - Math_imul($10_1, 100) & 65535) << 1; 15224 $4_1 = HEAPU8[$4_1 + 1063894 | 0] | HEAPU8[$4_1 + 1063895 | 0] << 8; 15225 HEAP8[$2_1 | 0] = $4_1; 15226 HEAP8[$2_1 + 1 | 0] = $4_1 >>> 8; 15227 $3_1 = $3_1 - 4 | 0; 15228 if ($6_1 >>> 0 > 9999999) { 15229 continue 15230 } 15231 break; 15232 } 15233 } 15234 if ($0_1 >>> 0 > 9) { 15235 $3_1 = $3_1 - 2 | 0; 15236 $6_1 = $3_1 + ($5_1 + 6 | 0) | 0; 15237 $2_1 = $0_1; 15238 $0_1 = (($0_1 & 65535) >>> 0) / 100 | 0; 15239 $2_1 = ($2_1 - Math_imul($0_1, 100) & 65535) << 1; 15240 $2_1 = HEAPU8[$2_1 + 1063894 | 0] | HEAPU8[$2_1 + 1063895 | 0] << 8; 15241 HEAP8[$6_1 | 0] = $2_1; 15242 HEAP8[$6_1 + 1 | 0] = $2_1 >>> 8; 15243 } 15244 if (!($0_1 ? 0 : $8_1)) { 15245 $3_1 = $3_1 - 1 | 0; 15246 HEAP8[$3_1 + ($5_1 + 6 | 0) | 0] = HEAPU8[($0_1 << 1) + 1063895 | 0]; 15247 } 15248 $0_1 = $140($1_1, 1, 1, 0, $3_1 + ($5_1 + 6 | 0) | 0, 10 - $3_1 | 0); 15249 global$0 = $5_1 + 16 | 0; 15250 return $0_1 | 0; 15251 } 15252 15253 function $148($0_1, $1_1, $2_1, $3_1, $4_1) { 15254 var $5_1 = 0, $6_1 = 0, $7_1 = 0, $8_1 = 0; 15255 $5_1 = global$0 - 48 | 0; 15256 global$0 = $5_1; 15257 HEAP32[$5_1 + 4 >> 2] = $3_1; 15258 HEAP32[$5_1 >> 2] = $2_1; 15259 HEAP32[$5_1 + 8 >> 2] = $1_1; 15260 block : { 15261 block11 : { 15262 block7 : { 15263 block2 : { 15264 block4 : { 15265 block1 : { 15266 $7_1 = $1_1 >>> 0 < $2_1 >>> 0; 15267 if (!$7_1) { 15268 $8_1 = $1_1 >>> 0 < $3_1 >>> 0; 15269 if ($8_1) { 15270 break block 15271 } 15272 if ($2_1 >>> 0 > $3_1 >>> 0) { 15273 break block1 15274 } 15275 if (!$2_1 | $1_1 >>> 0 <= $2_1 >>> 0) { 15276 break block2 15277 } 15278 if (HEAP8[$0_1 + $2_1 | 0] > -65) { 15279 break block2 15280 } 15281 $6_1 = $2_1 - 1 | 0; 15282 if (HEAP8[$6_1 + $0_1 | 0] <= -65) { 15283 $3_1 = $2_1 - 2 | 0; 15284 $6_1 = HEAP8[$0_1 + $3_1 | 0] > -65 ? $3_1 : $2_1 - 3 | 0; 15285 } 15286 $3_1 = $2_1 + 1 | 0; 15287 $3_1 = $1_1 >>> 0 > $3_1 >>> 0 ? $1_1 : $3_1; 15288 $7_1 = $7_1 ? $2_1 : $1_1; 15289 while (1) { 15290 block3 : { 15291 if (($2_1 | 0) != ($7_1 | 0)) { 15292 if (HEAP8[$0_1 + $2_1 | 0] <= -65) { 15293 break block3 15294 } 15295 break block4; 15296 } 15297 $137($7_1, $1_1, 1063824); 15298 wasm2js_trap(); 15299 } 15300 $2_1 = $2_1 + 1 | 0; 15301 if ($1_1 >>> 0 > $2_1 >>> 0) { 15302 continue 15303 } 15304 break; 15305 }; 15306 $2_1 = $3_1; 15307 break block4; 15308 } 15309 HEAP32[$5_1 + 32 >> 2] = $5_1 + 8; 15310 HEAP32[$5_1 + 36 >> 2] = 4; 15311 HEAP32[$5_1 + 24 >> 2] = $5_1; 15312 HEAP32[$5_1 + 28 >> 2] = 4; 15313 $134(1048733, $5_1 + 24 | 0, $4_1); 15314 wasm2js_trap(); 15315 } 15316 HEAP32[$5_1 + 32 >> 2] = $5_1 + 4; 15317 HEAP32[$5_1 + 36 >> 2] = 4; 15318 HEAP32[$5_1 + 24 >> 2] = $5_1; 15319 HEAP32[$5_1 + 28 >> 2] = 4; 15320 $134(1048616, $5_1 + 24 | 0, $4_1); 15321 wasm2js_trap(); 15322 } 15323 HEAP32[$5_1 + 12 >> 2] = $6_1; 15324 HEAP32[$5_1 + 16 >> 2] = $2_1; 15325 block5 : { 15326 if ($2_1 >>> 0 < $6_1 >>> 0 | $1_1 >>> 0 < $2_1 >>> 0) { 15327 break block5 15328 } 15329 block6 : { 15330 if (($1_1 | 0) == ($6_1 | 0)) { 15331 break block6 15332 } 15333 if (HEAP8[$0_1 + $6_1 | 0] <= -65 ? $6_1 : 0) { 15334 break block5 15335 } 15336 if (($1_1 | 0) == ($2_1 | 0)) { 15337 break block6 15338 } 15339 if (HEAP8[$0_1 + $2_1 | 0] <= -65) { 15340 break block5 15341 } 15342 } 15343 if (($2_1 | 0) == ($6_1 | 0)) { 15344 break block7 15345 } 15346 $1_1 = $0_1 + $6_1 | 0; 15347 $0_1 = HEAP8[$1_1 | 0]; 15348 block8 : { 15349 if (($0_1 | 0) >= 0) { 15350 $6_1 = $0_1 & 255; 15351 break block8; 15352 } 15353 $3_1 = HEAPU8[$1_1 + 1 | 0] & 63; 15354 $2_1 = $0_1 & 31; 15355 $6_1 = $3_1 | $2_1 << 6; 15356 if ($0_1 >>> 0 <= 4294967263) { 15357 break block8 15358 } 15359 $3_1 = HEAPU8[$1_1 + 2 | 0] & 63 | $3_1 << 6; 15360 $6_1 = $3_1 | $2_1 << 12; 15361 if ($0_1 >>> 0 < 4294967280) { 15362 break block8 15363 } 15364 $6_1 = $2_1 << 18 & 1835008 | (HEAPU8[$1_1 + 3 | 0] & 63 | $3_1 << 6); 15365 } 15366 HEAP32[$5_1 + 20 >> 2] = $6_1; 15367 HEAP32[$5_1 + 40 >> 2] = $5_1 + 12; 15368 HEAP32[$5_1 + 44 >> 2] = 56; 15369 HEAP32[$5_1 + 32 >> 2] = $5_1 + 20; 15370 HEAP32[$5_1 + 36 >> 2] = 57; 15371 HEAP32[$5_1 + 24 >> 2] = $5_1; 15372 HEAP32[$5_1 + 28 >> 2] = 4; 15373 $134(1051441, $5_1 + 24 | 0, $4_1); 15374 wasm2js_trap(); 15375 } 15376 $148($0_1, $1_1, $6_1, $2_1, $4_1); 15377 wasm2js_trap(); 15378 } 15379 if (!$3_1 | $1_1 >>> 0 <= $3_1 >>> 0) { 15380 break block 15381 } 15382 if (HEAP8[$0_1 + $3_1 | 0] > -65) { 15383 break block 15384 } 15385 $6_1 = $3_1 - 1 | 0; 15386 if (HEAP8[$6_1 + $0_1 | 0] <= -65) { 15387 $2_1 = $3_1 - 2 | 0; 15388 $6_1 = HEAP8[$0_1 + $2_1 | 0] > -65 ? $2_1 : $3_1 - 3 | 0; 15389 } 15390 $2_1 = $3_1 + 1 | 0; 15391 $2_1 = $1_1 >>> 0 > $2_1 >>> 0 ? $1_1 : $2_1; 15392 $7_1 = $8_1 ? $3_1 : $1_1; 15393 block10 : { 15394 while (1) { 15395 block9 : { 15396 if (($3_1 | 0) != ($7_1 | 0)) { 15397 if (HEAP8[$0_1 + $3_1 | 0] <= -65) { 15398 break block9 15399 } 15400 break block10; 15401 } 15402 $137($7_1, $1_1, 1063824); 15403 wasm2js_trap(); 15404 } 15405 $3_1 = $3_1 + 1 | 0; 15406 if ($1_1 >>> 0 > $3_1 >>> 0) { 15407 continue 15408 } 15409 break; 15410 }; 15411 $3_1 = $2_1; 15412 } 15413 HEAP32[$5_1 + 12 >> 2] = $6_1; 15414 HEAP32[$5_1 + 16 >> 2] = $3_1; 15415 if ($3_1 >>> 0 < $6_1 >>> 0 | $1_1 >>> 0 < $3_1 >>> 0) { 15416 break block11 15417 } 15418 block12 : { 15419 if (($1_1 | 0) == ($6_1 | 0)) { 15420 break block12 15421 } 15422 if (HEAP8[$0_1 + $6_1 | 0] <= -65 ? $6_1 : 0) { 15423 break block11 15424 } 15425 if (($1_1 | 0) == ($3_1 | 0)) { 15426 break block12 15427 } 15428 if (HEAP8[$0_1 + $3_1 | 0] <= -65) { 15429 break block11 15430 } 15431 } 15432 if (($3_1 | 0) == ($6_1 | 0)) { 15433 break block7 15434 } 15435 $1_1 = $0_1 + $6_1 | 0; 15436 $0_1 = HEAP8[$1_1 | 0]; 15437 block13 : { 15438 if (($0_1 | 0) >= 0) { 15439 $6_1 = $0_1 & 255; 15440 break block13; 15441 } 15442 $3_1 = HEAPU8[$1_1 + 1 | 0] & 63; 15443 $2_1 = $0_1 & 31; 15444 $6_1 = $3_1 | $2_1 << 6; 15445 if ($0_1 >>> 0 <= 4294967263) { 15446 break block13 15447 } 15448 $3_1 = HEAPU8[$1_1 + 2 | 0] & 63 | $3_1 << 6; 15449 $6_1 = $3_1 | $2_1 << 12; 15450 if ($0_1 >>> 0 < 4294967280) { 15451 break block13 15452 } 15453 $6_1 = $2_1 << 18 & 1835008 | (HEAPU8[$1_1 + 3 | 0] & 63 | $3_1 << 6); 15454 } 15455 HEAP32[$5_1 + 20 >> 2] = $6_1; 15456 HEAP32[$5_1 + 40 >> 2] = $5_1 + 12; 15457 HEAP32[$5_1 + 44 >> 2] = 56; 15458 HEAP32[$5_1 + 32 >> 2] = $5_1 + 20; 15459 HEAP32[$5_1 + 36 >> 2] = 57; 15460 HEAP32[$5_1 + 24 >> 2] = $5_1 + 4; 15461 HEAP32[$5_1 + 28 >> 2] = 4; 15462 $134(1051523, $5_1 + 24 | 0, $4_1); 15463 wasm2js_trap(); 15464 } 15465 $151($4_1); 15466 wasm2js_trap(); 15467 } 15468 $148($0_1, $1_1, $6_1, $3_1, $4_1); 15469 wasm2js_trap(); 15470 } 15471 HEAP32[$5_1 + 32 >> 2] = $5_1 + 8; 15472 HEAP32[$5_1 + 36 >> 2] = 4; 15473 HEAP32[$5_1 + 24 >> 2] = $5_1 + 4; 15474 HEAP32[$5_1 + 28 >> 2] = 4; 15475 $134(1048794, $5_1 + 24 | 0, $4_1); 15476 wasm2js_trap(); 15477 } 15478 15479 function $149($0_1, $1_1) { 15480 $0_1 = $0_1 | 0; 15481 $1_1 = $1_1 | 0; 15482 var $2_1 = 0, $3_1 = 0, $4_1 = 0; 15483 $4_1 = global$0 - 16 | 0; 15484 global$0 = $4_1; 15485 block2 : { 15486 block1 : { 15487 block : { 15488 $2_1 = HEAP32[$1_1 + 8 >> 2]; 15489 if (!($2_1 & 33554432)) { 15490 if ($2_1 & 67108864) { 15491 break block 15492 } 15493 if (!$147($0_1, $1_1)) { 15494 break block1 15495 } 15496 $2_1 = 1; 15497 break block2; 15498 } 15499 $2_1 = HEAP32[$0_1 >> 2]; 15500 while (1) { 15501 HEAP8[($3_1 + $4_1 | 0) + 15 | 0] = HEAPU8[($2_1 & 15) + 1062599 | 0]; 15502 $3_1 = $3_1 - 1 | 0; 15503 $2_1 = $2_1 >>> 4 | 0; 15504 if ($2_1) { 15505 continue 15506 } 15507 break; 15508 }; 15509 $2_1 = 1; 15510 if (!$140($1_1, 1, 1067346, 2, ($3_1 + $4_1 | 0) + 16 | 0, 0 - $3_1 | 0)) { 15511 break block1 15512 } 15513 break block2; 15514 } 15515 $2_1 = HEAP32[$0_1 >> 2]; 15516 while (1) { 15517 HEAP8[($3_1 + $4_1 | 0) + 15 | 0] = HEAPU8[($2_1 & 15) + 1067348 | 0]; 15518 $3_1 = $3_1 - 1 | 0; 15519 $2_1 = $2_1 >>> 4 | 0; 15520 if ($2_1) { 15521 continue 15522 } 15523 break; 15524 }; 15525 $2_1 = 1; 15526 if ($140($1_1, 1, 1067346, 2, ($3_1 + $4_1 | 0) + 16 | 0, 0 - $3_1 | 0)) { 15527 break block2 15528 } 15529 } 15530 if (FUNCTION_TABLE[HEAP32[HEAP32[$1_1 + 4 >> 2] + 12 >> 2]](HEAP32[$1_1 >> 2], 1067344, 2) | 0) { 15531 $2_1 = 1; 15532 break block2; 15533 } 15534 $0_1 = $0_1 + 4 | 0; 15535 block3 : { 15536 $2_1 = HEAP32[$1_1 + 8 >> 2]; 15537 if (!($2_1 & 33554432)) { 15538 if ($2_1 & 67108864) { 15539 break block3 15540 } 15541 $2_1 = $147($0_1, $1_1); 15542 break block2; 15543 } 15544 $2_1 = HEAP32[$0_1 >> 2]; 15545 $3_1 = 0; 15546 while (1) { 15547 HEAP8[($3_1 + $4_1 | 0) + 15 | 0] = HEAPU8[($2_1 & 15) + 1062599 | 0]; 15548 $3_1 = $3_1 - 1 | 0; 15549 $2_1 = $2_1 >>> 4 | 0; 15550 if ($2_1) { 15551 continue 15552 } 15553 break; 15554 }; 15555 $2_1 = $140($1_1, 1, 1067346, 2, ($3_1 + $4_1 | 0) + 16 | 0, 0 - $3_1 | 0); 15556 break block2; 15557 } 15558 $2_1 = HEAP32[$0_1 >> 2]; 15559 $3_1 = 0; 15560 while (1) { 15561 HEAP8[($3_1 + $4_1 | 0) + 15 | 0] = HEAPU8[($2_1 & 15) + 1067348 | 0]; 15562 $3_1 = $3_1 - 1 | 0; 15563 $2_1 = $2_1 >>> 4 | 0; 15564 if ($2_1) { 15565 continue 15566 } 15567 break; 15568 }; 15569 $2_1 = $140($1_1, 1, 1067346, 2, ($3_1 + $4_1 | 0) + 16 | 0, 0 - $3_1 | 0); 15570 } 15571 global$0 = $4_1 + 16 | 0; 15572 return $2_1 | 0; 15573 } 15574 15575 function $150($0_1, $1_1) { 15576 $0_1 = $0_1 | 0; 15577 $1_1 = $1_1 | 0; 15578 var $2_1 = 0, $3_1 = 0, $4_1 = 0, $5_1 = 0; 15579 $3_1 = global$0 - 16 | 0; 15580 global$0 = $3_1; 15581 $4_1 = HEAP32[$1_1 >> 2]; 15582 $5_1 = HEAP32[$1_1 + 4 >> 2]; 15583 $1_1 = HEAP32[$5_1 + 16 >> 2]; 15584 $2_1 = 1; 15585 block : { 15586 if (FUNCTION_TABLE[$1_1 | 0]($4_1, 39) | 0) { 15587 break block 15588 } 15589 $136($3_1, HEAP32[$0_1 >> 2], 257); 15590 block1 : { 15591 $0_1 = HEAPU8[$3_1 + 13 | 0]; 15592 if ($0_1 >>> 0 >= 129) { 15593 if (!(FUNCTION_TABLE[$1_1 | 0]($4_1, HEAP32[$3_1 >> 2]) | 0)) { 15594 break block1 15595 } 15596 $2_1 = 1; 15597 break block; 15598 } 15599 $2_1 = HEAPU8[$3_1 + 12 | 0]; 15600 if (!(FUNCTION_TABLE[HEAP32[$5_1 + 12 >> 2]]($4_1, $2_1 + $3_1 | 0, $0_1 - $2_1 | 0) | 0)) { 15601 break block1 15602 } 15603 $2_1 = 1; 15604 break block; 15605 } 15606 $2_1 = FUNCTION_TABLE[$1_1 | 0]($4_1, 39) | 0; 15607 } 15608 global$0 = $3_1 + 16 | 0; 15609 return $2_1 | 0; 15610 } 15611 15612 function $151($0_1) { 15613 $129(1063840, 43, $0_1); 15614 wasm2js_trap(); 15615 } 15616 15617 function $152($0_1, $1_1, $2_1, $3_1, $4_1) { 15618 var $5_1 = 0; 15619 $5_1 = global$0 - 32 | 0; 15620 global$0 = $5_1; 15621 HEAP32[$5_1 + 4 >> 2] = $1_1; 15622 HEAP32[$5_1 >> 2] = $0_1; 15623 HEAP32[$5_1 + 12 >> 2] = $3_1; 15624 HEAP32[$5_1 + 8 >> 2] = $2_1; 15625 HEAP32[$5_1 + 24 >> 2] = $5_1 + 8; 15626 HEAP32[$5_1 + 28 >> 2] = 53; 15627 HEAP32[$5_1 + 16 >> 2] = $5_1; 15628 HEAP32[$5_1 + 20 >> 2] = 55; 15629 $134(1049199, $5_1 + 16 | 0, $4_1); 15630 wasm2js_trap(); 15631 } 15632 15633 function $153($0_1, $1_1) { 15634 $0_1 = $0_1 | 0; 15635 $1_1 = $1_1 | 0; 15636 return $133(HEAP32[$1_1 >> 2], HEAP32[$1_1 + 4 >> 2], HEAP32[$0_1 >> 2], HEAP32[$0_1 + 4 >> 2]) | 0; 15637 } 15638 15639 function $154($0_1, $1_1, $2_1, $3_1) { 15640 var $4_1 = 0, $5_1 = 0, $6_1 = 0, $7_1 = 0, $8_1 = 0, $9_1 = 0; 15641 $4_1 = $2_1 + 3 & -4; 15642 block1 : { 15643 block2 : { 15644 block : { 15645 if (($4_1 | 0) == ($2_1 | 0)) { 15646 $8_1 = $3_1 - 8 | 0; 15647 $4_1 = 0; 15648 break block; 15649 } 15650 $4_1 = $4_1 - $2_1 | 0; 15651 $4_1 = $3_1 >>> 0 < $4_1 >>> 0 ? $3_1 : $4_1; 15652 if ($3_1) { 15653 $6_1 = $1_1 & 255; 15654 $7_1 = 1; 15655 while (1) { 15656 if (($6_1 | 0) == HEAPU8[$2_1 + $5_1 | 0]) { 15657 break block1 15658 } 15659 $5_1 = $5_1 + 1 | 0; 15660 if (($5_1 | 0) != ($4_1 | 0)) { 15661 continue 15662 } 15663 break; 15664 }; 15665 } 15666 $8_1 = $3_1 - 8 | 0; 15667 if ($8_1 >>> 0 < $4_1 >>> 0) { 15668 break block2 15669 } 15670 } 15671 $5_1 = Math_imul($1_1 & 255, 16843009); 15672 while (1) { 15673 $7_1 = $2_1 + $4_1 | 0; 15674 $6_1 = $5_1 ^ HEAP32[$7_1 >> 2]; 15675 $9_1 = 16843008 - $6_1 | $6_1; 15676 $6_1 = $5_1 ^ HEAP32[$7_1 + 4 >> 2]; 15677 if (($9_1 & (16843008 - $6_1 | $6_1) & -2139062144) != -2139062144) { 15678 break block2 15679 } 15680 $4_1 = $4_1 + 8 | 0; 15681 if ($8_1 >>> 0 >= $4_1 >>> 0) { 15682 continue 15683 } 15684 break; 15685 }; 15686 } 15687 if (($3_1 | 0) != ($4_1 | 0)) { 15688 $5_1 = $1_1 & 255; 15689 $7_1 = 1; 15690 while (1) { 15691 if (HEAPU8[$2_1 + $4_1 | 0] == ($5_1 | 0)) { 15692 $5_1 = $4_1; 15693 break block1; 15694 } 15695 $4_1 = $4_1 + 1 | 0; 15696 if (($4_1 | 0) != ($3_1 | 0)) { 15697 continue 15698 } 15699 break; 15700 }; 15701 } 15702 $7_1 = 0; 15703 } 15704 HEAP32[$0_1 + 4 >> 2] = $5_1; 15705 HEAP32[$0_1 >> 2] = $7_1; 15706 } 15707 15708 function $155($0_1) { 15709 $134(1064351, 51, $0_1); 15710 wasm2js_trap(); 15711 } 15712 15713 function $156($0_1, $1_1, $2_1, $3_1, $4_1, $5_1, $6_1, $7_1, $8_1, $9_1, $10_1, $11_1) { 15714 var $12_1 = 0, $13_1 = 0, $14_1 = 0, $15_1 = 0, $16_1 = 0, $17_1 = 0, $18_1 = 0, $19_1 = 0; 15715 block2 : { 15716 block8 : { 15717 block3 : { 15718 block : { 15719 block1 : { 15720 block7 : { 15721 block5 : { 15722 block4 : { 15723 $13_1 = $8_1; 15724 if (($9_1 | 0) == ($11_1 | 0) & $10_1 >>> 0 < $13_1 >>> 0 | $9_1 >>> 0 > $11_1 >>> 0) { 15725 $14_1 = $13_1; 15726 $12_1 = $10_1; 15727 $13_1 = $14_1 - $12_1 | 0; 15728 $15_1 = $9_1 - (($12_1 >>> 0 > $14_1 >>> 0) + $11_1 | 0) | 0; 15729 $14_1 = $11_1; 15730 if (($15_1 | 0) == ($14_1 | 0) & $12_1 >>> 0 >= $13_1 >>> 0 | $14_1 >>> 0 > $15_1 >>> 0) { 15731 break block 15732 } 15733 $12_1 = $8_1; 15734 $14_1 = $6_1; 15735 $13_1 = $12_1 - $14_1 | 0; 15736 $12_1 = $9_1 - (($12_1 >>> 0 < $14_1 >>> 0) + $7_1 | 0) | 0; 15737 $18_1 = ($7_1 | 0) == ($12_1 | 0) & $13_1 >>> 0 > $14_1 >>> 0 | $7_1 >>> 0 < $12_1 >>> 0; 15738 $13_1 = $7_1; 15739 $12_1 = 1; 15740 $15_1 = 1; 15741 if (($12_1 & 63) >>> 0 >= 32) { 15742 $17_1 = $14_1 << $15_1; 15743 $12_1 = 0; 15744 } else { 15745 $17_1 = (1 << $15_1) - 1 & $14_1 >>> 32 - $15_1 | $13_1 << $15_1; 15746 $12_1 = $14_1 << $15_1; 15747 } 15748 $13_1 = $8_1; 15749 $19_1 = $13_1 - $12_1 | 0; 15750 $15_1 = $9_1 - (($12_1 >>> 0 > $13_1 >>> 0) + $17_1 | 0) | 0; 15751 $17_1 = $10_1; 15752 $12_1 = 1; 15753 $14_1 = 1; 15754 if (($12_1 & 63) >>> 0 >= 32) { 15755 $13_1 = $17_1 << $14_1; 15756 $12_1 = 0; 15757 } else { 15758 $13_1 = (1 << $14_1) - 1 & $17_1 >>> 32 - $14_1 | $11_1 << $14_1; 15759 $12_1 = $17_1 << $14_1; 15760 } 15761 if ((($15_1 | 0) == ($13_1 | 0) & $12_1 >>> 0 <= $19_1 >>> 0 | $15_1 >>> 0 > $13_1 >>> 0) & $18_1) { 15762 break block1 15763 } 15764 $12_1 = $6_1; 15765 if (($7_1 | 0) == ($11_1 | 0) & $10_1 >>> 0 >= $12_1 >>> 0 | $7_1 >>> 0 < $11_1 >>> 0) { 15766 break block2 15767 } 15768 $13_1 = $10_1; 15769 $6_1 = $12_1 - $13_1 | 0; 15770 $7_1 = $7_1 - (($12_1 >>> 0 < $13_1 >>> 0) + $11_1 | 0) | 0; 15771 $12_1 = $8_1; 15772 $13_1 = $6_1; 15773 $15_1 = $12_1 - $13_1 | 0; 15774 $14_1 = $9_1 - (($12_1 >>> 0 < $13_1 >>> 0) + $7_1 | 0) | 0; 15775 if (($14_1 | 0) == ($7_1 | 0) & $13_1 >>> 0 < $15_1 >>> 0 | $7_1 >>> 0 < $14_1 >>> 0) { 15776 break block2 15777 } 15778 if ($2_1 >>> 0 < $3_1 >>> 0) { 15779 break block3 15780 } 15781 $6_1 = $1_1 + $3_1 | 0; 15782 if ($3_1) { 15783 break block4 15784 } 15785 $16_1 = 49; 15786 break block5; 15787 } 15788 HEAP32[$0_1 >> 2] = 0; 15789 return; 15790 } 15791 block6 : { 15792 while (1) { 15793 $7_1 = $6_1 + $16_1 | 0; 15794 if (HEAPU8[$7_1 - 1 | 0] == 57) { 15795 $16_1 = $16_1 - 1 | 0; 15796 if ($16_1 + $3_1 | 0) { 15797 continue 15798 } 15799 break block6; 15800 } 15801 break; 15802 }; 15803 $5_1 = $7_1 - 1 | 0; 15804 HEAP8[$5_1 | 0] = HEAPU8[$5_1 | 0] + 1; 15805 $5_1 = 0 - $16_1 | 0; 15806 if (!$5_1) { 15807 break block7 15808 } 15809 wasm2js_memory_fill($7_1, 48, $5_1); 15810 break block7; 15811 } 15812 HEAP8[$1_1 | 0] = 49; 15813 $16_1 = 48; 15814 $7_1 = $3_1 - 1 | 0; 15815 if (!$7_1) { 15816 break block5 15817 } 15818 wasm2js_memory_fill($1_1 + 1 | 0, 48, $7_1); 15819 } 15820 $4_1 = $4_1 + 1 << 16 >> 16; 15821 if (($4_1 | 0) <= $5_1 << 16 >> 16 | $2_1 >>> 0 <= $3_1 >>> 0) { 15822 break block7 15823 } 15824 HEAP8[$6_1 | 0] = $16_1; 15825 $3_1 = $3_1 + 1 | 0; 15826 } 15827 if ($2_1 >>> 0 >= $3_1 >>> 0) { 15828 break block8 15829 } 15830 $135(0, $3_1, $2_1, 1067296); 15831 wasm2js_trap(); 15832 } 15833 if ($2_1 >>> 0 >= $3_1 >>> 0) { 15834 break block8 15835 } 15836 $135(0, $3_1, $2_1, 1067328); 15837 wasm2js_trap(); 15838 } 15839 HEAP32[$0_1 >> 2] = 0; 15840 return; 15841 } 15842 $135(0, $3_1, $2_1, 1067312); 15843 wasm2js_trap(); 15844 } 15845 HEAP16[$0_1 + 8 >> 1] = $4_1; 15846 HEAP32[$0_1 + 4 >> 2] = $3_1; 15847 HEAP32[$0_1 >> 2] = $1_1; 15848 return; 15849 } 15850 HEAP32[$0_1 >> 2] = 0; 15851 } 15852 15853 function $157($0_1, $1_1) { 15854 var $2_1 = 0, $3_1 = 0, $4_1 = 0, $5_1 = 0, $6_1 = 0, $7_1 = 0, $8_1 = 0, $9_1 = 0, $10_1 = 0, $11_1 = 0, $12_1 = 0, $13_1 = 0, $14_1 = 0, $15_1 = 0, $16_1 = 0, $17_1 = 0; 15855 block3 : { 15856 block1 : { 15857 block : { 15858 if ($1_1 >>> 0 >= 8) { 15859 $8_1 = $1_1 & 7; 15860 if (!$8_1) { 15861 break block 15862 } 15863 $10_1 = HEAP32[$0_1 + 160 >> 2]; 15864 if ($10_1 >>> 0 > 40) { 15865 break block1 15866 } 15867 if (!$10_1) { 15868 HEAP32[$0_1 + 160 >> 2] = 0; 15869 break block; 15870 } 15871 $11_1 = $10_1 << 2; 15872 $9_1 = $11_1 - 4 | 0; 15873 $3_1 = ($9_1 >>> 2 | 0) + 1 | 0; 15874 $16_1 = $3_1 & 3; 15875 $15_1 = HEAP32[($8_1 << 2) + 1067100 >> 2] >>> $8_1 | 0; 15876 $8_1 = $0_1; 15877 block2 : { 15878 if ($9_1 >>> 0 >= 12) { 15879 $9_1 = $3_1 & 2147483644; 15880 while (1) { 15881 $3_1 = __wasm_i64_mul(HEAP32[$8_1 >> 2], 0, $15_1, $14_1); 15882 $5_1 = i64toi32_i32$HIGH_BITS + $4_1 | 0; 15883 $6_1 = $3_1 + $2_1 | 0; 15884 $5_1 = $6_1 >>> 0 < $2_1 >>> 0 ? $5_1 + 1 | 0 : $5_1; 15885 HEAP32[$8_1 >> 2] = $6_1; 15886 $3_1 = $8_1 + 4 | 0; 15887 $17_1 = $3_1; 15888 $12_1 = __wasm_i64_mul(HEAP32[$3_1 >> 2], 0, $15_1, $14_1); 15889 $13_1 = i64toi32_i32$HIGH_BITS; 15890 $3_1 = $5_1; 15891 $7_1 = $6_1; 15892 $2_1 = 32; 15893 $4_1 = 0; 15894 if (($2_1 & 63) >>> 0 >= 32) { 15895 $5_1 = 0; 15896 $2_1 = $3_1 >>> $4_1 | 0; 15897 } else { 15898 $5_1 = $3_1 >>> $4_1 | 0; 15899 $2_1 = ((1 << $4_1) - 1 & $3_1) << 32 - $4_1 | $7_1 >>> $4_1; 15900 } 15901 $6_1 = $5_1 + $13_1 | 0; 15902 $4_1 = $2_1 + $12_1 | 0; 15903 $6_1 = $2_1 >>> 0 > $4_1 >>> 0 ? $6_1 + 1 | 0 : $6_1; 15904 HEAP32[$17_1 >> 2] = $4_1; 15905 $3_1 = $8_1 + 8 | 0; 15906 $17_1 = $3_1; 15907 $12_1 = __wasm_i64_mul(HEAP32[$3_1 >> 2], 0, $15_1, $14_1); 15908 $13_1 = i64toi32_i32$HIGH_BITS; 15909 $3_1 = $6_1; 15910 $5_1 = $4_1; 15911 $2_1 = 32; 15912 $7_1 = 0; 15913 if (($2_1 & 63) >>> 0 >= 32) { 15914 $6_1 = 0; 15915 $2_1 = $3_1 >>> $7_1 | 0; 15916 } else { 15917 $6_1 = $3_1 >>> $7_1 | 0; 15918 $2_1 = ((1 << $7_1) - 1 & $3_1) << 32 - $7_1 | $5_1 >>> $7_1; 15919 } 15920 $4_1 = $6_1 + $13_1 | 0; 15921 $7_1 = $2_1 + $12_1 | 0; 15922 $4_1 = $2_1 >>> 0 > $7_1 >>> 0 ? $4_1 + 1 | 0 : $4_1; 15923 HEAP32[$17_1 >> 2] = $7_1; 15924 $3_1 = $8_1 + 12 | 0; 15925 $17_1 = $3_1; 15926 $12_1 = __wasm_i64_mul(HEAP32[$3_1 >> 2], 0, $15_1, $14_1); 15927 $13_1 = i64toi32_i32$HIGH_BITS; 15928 $3_1 = $4_1; 15929 $6_1 = $7_1; 15930 $2_1 = 32; 15931 $5_1 = 0; 15932 if (($2_1 & 63) >>> 0 >= 32) { 15933 $4_1 = 0; 15934 $2_1 = $3_1 >>> $5_1 | 0; 15935 } else { 15936 $4_1 = $3_1 >>> $5_1 | 0; 15937 $2_1 = ((1 << $5_1) - 1 & $3_1) << 32 - $5_1 | $6_1 >>> $5_1; 15938 } 15939 $7_1 = $4_1 + $13_1 | 0; 15940 $5_1 = $2_1 + $12_1 | 0; 15941 $7_1 = $5_1 >>> 0 < $2_1 >>> 0 ? $7_1 + 1 | 0 : $7_1; 15942 HEAP32[$17_1 >> 2] = $5_1; 15943 $4_1 = $5_1; 15944 $2_1 = 32; 15945 $6_1 = 0; 15946 if (($2_1 & 63) >>> 0 >= 32) { 15947 $3_1 = 0; 15948 $2_1 = $7_1 >>> $6_1 | 0; 15949 } else { 15950 $3_1 = $7_1 >>> $6_1 | 0; 15951 $2_1 = ((1 << $6_1) - 1 & $7_1) << 32 - $6_1 | $4_1 >>> $6_1; 15952 } 15953 $4_1 = $3_1; 15954 $8_1 = $8_1 + 16 | 0; 15955 $9_1 = $9_1 - 4 | 0; 15956 if ($9_1) { 15957 continue 15958 } 15959 break; 15960 }; 15961 if (!$16_1) { 15962 break block2 15963 } 15964 } 15965 $9_1 = $16_1 << 2; 15966 while (1) { 15967 $6_1 = __wasm_i64_mul(HEAP32[$8_1 >> 2], 0, $15_1, $14_1) + $2_1 | 0; 15968 $5_1 = $4_1 + i64toi32_i32$HIGH_BITS | 0; 15969 $5_1 = $2_1 >>> 0 > $6_1 >>> 0 ? $5_1 + 1 | 0 : $5_1; 15970 HEAP32[$8_1 >> 2] = $6_1; 15971 $8_1 = $8_1 + 4 | 0; 15972 $4_1 = $6_1; 15973 $2_1 = 32; 15974 $3_1 = 0; 15975 if (($2_1 & 63) >>> 0 >= 32) { 15976 $7_1 = 0; 15977 $2_1 = $5_1 >>> $3_1 | 0; 15978 } else { 15979 $7_1 = $5_1 >>> $3_1 | 0; 15980 $2_1 = ((1 << $3_1) - 1 & $5_1) << 32 - $3_1 | $4_1 >>> $3_1; 15981 } 15982 $4_1 = $7_1; 15983 $9_1 = $9_1 - 4 | 0; 15984 if ($9_1) { 15985 continue 15986 } 15987 break; 15988 }; 15989 } 15990 if ($2_1 | $4_1) { 15991 if (($10_1 | 0) == 40) { 15992 break block3 15993 } 15994 HEAP32[$0_1 + $11_1 >> 2] = $2_1; 15995 $10_1 = $10_1 + 1 | 0; 15996 } 15997 HEAP32[$0_1 + 160 >> 2] = $10_1; 15998 break block; 15999 } 16000 $10_1 = HEAP32[$0_1 + 160 >> 2]; 16001 if ($10_1 >>> 0 > 40) { 16002 break block1 16003 } 16004 if (!$10_1) { 16005 HEAP32[$0_1 + 160 >> 2] = 0; 16006 return; 16007 } 16008 $15_1 = HEAP32[($1_1 << 2) + 1067100 >> 2]; 16009 $16_1 = $10_1 << 2; 16010 $9_1 = $16_1 - 4 | 0; 16011 $11_1 = ($9_1 >>> 2 | 0) + 1 | 0; 16012 $1_1 = $11_1 & 3; 16013 $8_1 = $0_1; 16014 block4 : { 16015 if ($9_1 >>> 0 >= 12) { 16016 $9_1 = $11_1 & 2147483644; 16017 while (1) { 16018 $5_1 = __wasm_i64_mul(HEAP32[$8_1 >> 2], 0, $15_1, $14_1); 16019 $6_1 = i64toi32_i32$HIGH_BITS + $4_1 | 0; 16020 $3_1 = $2_1 + $5_1 | 0; 16021 $6_1 = $2_1 >>> 0 > $3_1 >>> 0 ? $6_1 + 1 | 0 : $6_1; 16022 HEAP32[$8_1 >> 2] = $3_1; 16023 $11_1 = $8_1 + 4 | 0; 16024 $12_1 = $11_1; 16025 $13_1 = __wasm_i64_mul(HEAP32[$11_1 >> 2], 0, $15_1, $14_1); 16026 $11_1 = i64toi32_i32$HIGH_BITS; 16027 $5_1 = $6_1; 16028 $7_1 = $3_1; 16029 $2_1 = 32; 16030 $4_1 = 0; 16031 if (($2_1 & 63) >>> 0 >= 32) { 16032 $6_1 = 0; 16033 $2_1 = $5_1 >>> $4_1 | 0; 16034 } else { 16035 $6_1 = $5_1 >>> $4_1 | 0; 16036 $2_1 = ((1 << $4_1) - 1 & $5_1) << 32 - $4_1 | $7_1 >>> $4_1; 16037 } 16038 $3_1 = $6_1 + $11_1 | 0; 16039 $4_1 = $2_1 + $13_1 | 0; 16040 $3_1 = $2_1 >>> 0 > $4_1 >>> 0 ? $3_1 + 1 | 0 : $3_1; 16041 HEAP32[$12_1 >> 2] = $4_1; 16042 $11_1 = $8_1 + 8 | 0; 16043 $12_1 = $11_1; 16044 $13_1 = __wasm_i64_mul(HEAP32[$11_1 >> 2], 0, $15_1, $14_1); 16045 $11_1 = i64toi32_i32$HIGH_BITS; 16046 $5_1 = $3_1; 16047 $6_1 = $4_1; 16048 $2_1 = 32; 16049 $7_1 = 0; 16050 if (($2_1 & 63) >>> 0 >= 32) { 16051 $3_1 = 0; 16052 $2_1 = $5_1 >>> $7_1 | 0; 16053 } else { 16054 $3_1 = $5_1 >>> $7_1 | 0; 16055 $2_1 = ((1 << $7_1) - 1 & $5_1) << 32 - $7_1 | $6_1 >>> $7_1; 16056 } 16057 $4_1 = $3_1 + $11_1 | 0; 16058 $7_1 = $2_1 + $13_1 | 0; 16059 $4_1 = $2_1 >>> 0 > $7_1 >>> 0 ? $4_1 + 1 | 0 : $4_1; 16060 HEAP32[$12_1 >> 2] = $7_1; 16061 $11_1 = $8_1 + 12 | 0; 16062 $12_1 = $11_1; 16063 $13_1 = __wasm_i64_mul(HEAP32[$11_1 >> 2], 0, $15_1, $14_1); 16064 $11_1 = i64toi32_i32$HIGH_BITS; 16065 $5_1 = $4_1; 16066 $3_1 = $7_1; 16067 $2_1 = 32; 16068 $6_1 = 0; 16069 if (($2_1 & 63) >>> 0 >= 32) { 16070 $4_1 = 0; 16071 $2_1 = $5_1 >>> $6_1 | 0; 16072 } else { 16073 $4_1 = $5_1 >>> $6_1 | 0; 16074 $2_1 = ((1 << $6_1) - 1 & $5_1) << 32 - $6_1 | $3_1 >>> $6_1; 16075 } 16076 $7_1 = $4_1 + $11_1 | 0; 16077 $6_1 = $2_1 + $13_1 | 0; 16078 $7_1 = $6_1 >>> 0 < $2_1 >>> 0 ? $7_1 + 1 | 0 : $7_1; 16079 HEAP32[$12_1 >> 2] = $6_1; 16080 $4_1 = $6_1; 16081 $2_1 = 32; 16082 $3_1 = 0; 16083 if (($2_1 & 63) >>> 0 >= 32) { 16084 $5_1 = 0; 16085 $2_1 = $7_1 >>> $3_1 | 0; 16086 } else { 16087 $5_1 = $7_1 >>> $3_1 | 0; 16088 $2_1 = ((1 << $3_1) - 1 & $7_1) << 32 - $3_1 | $4_1 >>> $3_1; 16089 } 16090 $4_1 = $5_1; 16091 $8_1 = $8_1 + 16 | 0; 16092 $9_1 = $9_1 - 4 | 0; 16093 if ($9_1) { 16094 continue 16095 } 16096 break; 16097 }; 16098 if (!$1_1) { 16099 break block4 16100 } 16101 } 16102 $9_1 = $1_1 << 2; 16103 while (1) { 16104 $7_1 = __wasm_i64_mul(HEAP32[$8_1 >> 2], 0, $15_1, $14_1); 16105 $6_1 = $4_1 + i64toi32_i32$HIGH_BITS | 0; 16106 $3_1 = $2_1 + $7_1 | 0; 16107 $6_1 = $2_1 >>> 0 > $3_1 >>> 0 ? $6_1 + 1 | 0 : $6_1; 16108 HEAP32[$8_1 >> 2] = $3_1; 16109 $8_1 = $8_1 + 4 | 0; 16110 $4_1 = $3_1; 16111 $2_1 = 32; 16112 $5_1 = 0; 16113 if (($2_1 & 63) >>> 0 >= 32) { 16114 $7_1 = 0; 16115 $2_1 = $6_1 >>> $5_1 | 0; 16116 } else { 16117 $7_1 = $6_1 >>> $5_1 | 0; 16118 $2_1 = ((1 << $5_1) - 1 & $6_1) << 32 - $5_1 | $4_1 >>> $5_1; 16119 } 16120 $4_1 = $7_1; 16121 $9_1 = $9_1 - 4 | 0; 16122 if ($9_1) { 16123 continue 16124 } 16125 break; 16126 }; 16127 } 16128 if ($2_1 | $4_1) { 16129 if (($10_1 | 0) == 40) { 16130 break block3 16131 } 16132 HEAP32[$0_1 + $16_1 >> 2] = $2_1; 16133 $10_1 = $10_1 + 1 | 0; 16134 } 16135 HEAP32[$0_1 + 160 >> 2] = $10_1; 16136 return; 16137 } 16138 block7 : { 16139 if ($1_1 & 8) { 16140 $10_1 = HEAP32[$0_1 + 160 >> 2]; 16141 if ($10_1 >>> 0 > 40) { 16142 break block1 16143 } 16144 block5 : { 16145 if (!$10_1) { 16146 $10_1 = 0; 16147 break block5; 16148 } 16149 $11_1 = $10_1 << 2; 16150 $9_1 = $11_1 - 4 | 0; 16151 $3_1 = ($9_1 >>> 2 | 0) + 1 | 0; 16152 $16_1 = $3_1 & 3; 16153 $2_1 = 0; 16154 $4_1 = 0; 16155 $8_1 = $0_1; 16156 block6 : { 16157 if ($9_1 >>> 0 >= 12) { 16158 $9_1 = $3_1 & 2147483644; 16159 while (1) { 16160 $5_1 = __wasm_i64_mul(HEAP32[$8_1 >> 2], 0, 390625, 0) + $2_1 | 0; 16161 $3_1 = $4_1 + i64toi32_i32$HIGH_BITS | 0; 16162 $4_1 = $2_1 >>> 0 > $5_1 >>> 0 ? $3_1 + 1 | 0 : $3_1; 16163 HEAP32[$8_1 >> 2] = $5_1; 16164 $3_1 = $8_1 + 4 | 0; 16165 $12_1 = $3_1; 16166 $13_1 = __wasm_i64_mul(HEAP32[$3_1 >> 2], 0, 390625, 0); 16167 $14_1 = i64toi32_i32$HIGH_BITS; 16168 $6_1 = $4_1; 16169 $4_1 = $5_1; 16170 $2_1 = 32; 16171 $7_1 = 0; 16172 if (($2_1 & 63) >>> 0 >= 32) { 16173 $3_1 = 0; 16174 $2_1 = $6_1 >>> $7_1 | 0; 16175 } else { 16176 $3_1 = $6_1 >>> $7_1 | 0; 16177 $2_1 = ((1 << $7_1) - 1 & $6_1) << 32 - $7_1 | $4_1 >>> $7_1; 16178 } 16179 $5_1 = $3_1 + $14_1 | 0; 16180 $7_1 = $2_1 + $13_1 | 0; 16181 $5_1 = $2_1 >>> 0 > $7_1 >>> 0 ? $5_1 + 1 | 0 : $5_1; 16182 HEAP32[$12_1 >> 2] = $7_1; 16183 $3_1 = $8_1 + 8 | 0; 16184 $12_1 = $3_1; 16185 $13_1 = __wasm_i64_mul(HEAP32[$3_1 >> 2], 0, 390625, 0); 16186 $14_1 = i64toi32_i32$HIGH_BITS; 16187 $6_1 = $5_1; 16188 $3_1 = $7_1; 16189 $2_1 = 32; 16190 $4_1 = 0; 16191 if (($2_1 & 63) >>> 0 >= 32) { 16192 $5_1 = 0; 16193 $2_1 = $6_1 >>> $4_1 | 0; 16194 } else { 16195 $5_1 = $6_1 >>> $4_1 | 0; 16196 $2_1 = ((1 << $4_1) - 1 & $6_1) << 32 - $4_1 | $3_1 >>> $4_1; 16197 } 16198 $7_1 = $5_1 + $14_1 | 0; 16199 $4_1 = $2_1 + $13_1 | 0; 16200 $7_1 = $2_1 >>> 0 > $4_1 >>> 0 ? $7_1 + 1 | 0 : $7_1; 16201 HEAP32[$12_1 >> 2] = $4_1; 16202 $3_1 = $8_1 + 12 | 0; 16203 $12_1 = $3_1; 16204 $13_1 = __wasm_i64_mul(HEAP32[$3_1 >> 2], 0, 390625, 0); 16205 $14_1 = i64toi32_i32$HIGH_BITS; 16206 $6_1 = $7_1; 16207 $5_1 = $4_1; 16208 $2_1 = 32; 16209 $3_1 = 0; 16210 if (($2_1 & 63) >>> 0 >= 32) { 16211 $7_1 = 0; 16212 $2_1 = $6_1 >>> $3_1 | 0; 16213 } else { 16214 $7_1 = $6_1 >>> $3_1 | 0; 16215 $2_1 = ((1 << $3_1) - 1 & $6_1) << 32 - $3_1 | $5_1 >>> $3_1; 16216 } 16217 $4_1 = $7_1 + $14_1 | 0; 16218 $3_1 = $2_1 + $13_1 | 0; 16219 $4_1 = $2_1 >>> 0 > $3_1 >>> 0 ? $4_1 + 1 | 0 : $4_1; 16220 HEAP32[$12_1 >> 2] = $3_1; 16221 $7_1 = $3_1; 16222 $2_1 = 32; 16223 $5_1 = 0; 16224 if (($2_1 & 63) >>> 0 >= 32) { 16225 $6_1 = 0; 16226 $2_1 = $4_1 >>> $5_1 | 0; 16227 } else { 16228 $6_1 = $4_1 >>> $5_1 | 0; 16229 $2_1 = ((1 << $5_1) - 1 & $4_1) << 32 - $5_1 | $7_1 >>> $5_1; 16230 } 16231 $4_1 = $6_1; 16232 $8_1 = $8_1 + 16 | 0; 16233 $9_1 = $9_1 - 4 | 0; 16234 if ($9_1) { 16235 continue 16236 } 16237 break; 16238 }; 16239 if (!$16_1) { 16240 break block6 16241 } 16242 } 16243 $9_1 = $16_1 << 2; 16244 while (1) { 16245 $5_1 = __wasm_i64_mul(HEAP32[$8_1 >> 2], 0, 390625, 0) + $2_1 | 0; 16246 $3_1 = $4_1 + i64toi32_i32$HIGH_BITS | 0; 16247 $3_1 = $2_1 >>> 0 > $5_1 >>> 0 ? $3_1 + 1 | 0 : $3_1; 16248 HEAP32[$8_1 >> 2] = $5_1; 16249 $8_1 = $8_1 + 4 | 0; 16250 $7_1 = $5_1; 16251 $2_1 = 32; 16252 $6_1 = 0; 16253 if (($2_1 & 63) >>> 0 >= 32) { 16254 $4_1 = 0; 16255 $2_1 = $3_1 >>> $6_1 | 0; 16256 } else { 16257 $4_1 = $3_1 >>> $6_1 | 0; 16258 $2_1 = ((1 << $6_1) - 1 & $3_1) << 32 - $6_1 | $7_1 >>> $6_1; 16259 } 16260 $9_1 = $9_1 - 4 | 0; 16261 if ($9_1) { 16262 continue 16263 } 16264 break; 16265 }; 16266 } 16267 if (!($2_1 | $4_1)) { 16268 break block5 16269 } 16270 if (($10_1 | 0) == 40) { 16271 break block7 16272 } 16273 HEAP32[$0_1 + $11_1 >> 2] = $2_1; 16274 $10_1 = $10_1 + 1 | 0; 16275 } 16276 HEAP32[$0_1 + 160 >> 2] = $10_1; 16277 } 16278 if ($1_1 & 16) { 16279 $138($0_1, 1067140, 2) 16280 } 16281 if ($1_1 & 32) { 16282 $138($0_1, 1067148, 3) 16283 } 16284 if ($1_1 & 64) { 16285 $138($0_1, 1067160, 5) 16286 } 16287 if ($1_1 & 128) { 16288 $138($0_1, 1067180, 10) 16289 } 16290 if ($1_1 & 256) { 16291 $138($0_1, 1067220, 19) 16292 } 16293 $139($0_1, $1_1); 16294 return; 16295 } 16296 break block3; 16297 } 16298 $135(0, $10_1, 40, 1062848); 16299 wasm2js_trap(); 16300 } 16301 $137(40, 40, 1062848); 16302 wasm2js_trap(); 16303 } 16304 16305 function $158($0_1, $1_1) { 16306 $0_1 = $0_1 | 0; 16307 $1_1 = $1_1 | 0; 16308 var $2_1 = 0, $3_1 = 0, $4_1 = 0, $5_1 = 0, $6_1 = 0, $7_1 = 0, $8_1 = 0, $9_1 = 0, $10_1 = 0; 16309 $5_1 = global$0 - 16 | 0; 16310 global$0 = $5_1; 16311 $3_1 = 10; 16312 $8_1 = HEAP32[$0_1 >> 2]; 16313 $0_1 = $8_1 >> 31; 16314 $0_1 = ($0_1 ^ $8_1) - $0_1 | 0; 16315 if ($0_1 >>> 0 >= 1e3) { 16316 while (1) { 16317 $2_1 = $3_1 + ($5_1 + 6 | 0) | 0; 16318 $4_1 = $2_1 - 4 | 0; 16319 $6_1 = $0_1; 16320 $0_1 = ($0_1 >>> 0) / 1e4 | 0; 16321 $9_1 = $6_1 - Math_imul($0_1, 1e4) | 0; 16322 $10_1 = (($9_1 & 65535) >>> 0) / 100 | 0; 16323 $7_1 = $10_1 << 1; 16324 $7_1 = HEAPU8[$7_1 + 1063894 | 0] | HEAPU8[$7_1 + 1063895 | 0] << 8; 16325 HEAP8[$4_1 | 0] = $7_1; 16326 HEAP8[$4_1 + 1 | 0] = $7_1 >>> 8; 16327 $2_1 = $2_1 - 2 | 0; 16328 $4_1 = ($9_1 - Math_imul($10_1, 100) & 65535) << 1; 16329 $4_1 = HEAPU8[$4_1 + 1063894 | 0] | HEAPU8[$4_1 + 1063895 | 0] << 8; 16330 HEAP8[$2_1 | 0] = $4_1; 16331 HEAP8[$2_1 + 1 | 0] = $4_1 >>> 8; 16332 $3_1 = $3_1 - 4 | 0; 16333 if ($6_1 >>> 0 > 9999999) { 16334 continue 16335 } 16336 break; 16337 } 16338 } 16339 if ($0_1 >>> 0 > 9) { 16340 $3_1 = $3_1 - 2 | 0; 16341 $6_1 = $3_1 + ($5_1 + 6 | 0) | 0; 16342 $2_1 = $0_1; 16343 $0_1 = (($0_1 & 65535) >>> 0) / 100 | 0; 16344 $2_1 = ($2_1 - Math_imul($0_1, 100) & 65535) << 1; 16345 $2_1 = HEAPU8[$2_1 + 1063894 | 0] | HEAPU8[$2_1 + 1063895 | 0] << 8; 16346 HEAP8[$6_1 | 0] = $2_1; 16347 HEAP8[$6_1 + 1 | 0] = $2_1 >>> 8; 16348 } 16349 if (!($0_1 ? 0 : $8_1)) { 16350 $3_1 = $3_1 - 1 | 0; 16351 HEAP8[$3_1 + ($5_1 + 6 | 0) | 0] = HEAPU8[($0_1 << 1) + 1063895 | 0]; 16352 } 16353 $0_1 = $140($1_1, ($8_1 ^ -1) >>> 31 | 0, 1, 0, $3_1 + ($5_1 + 6 | 0) | 0, 10 - $3_1 | 0); 16354 global$0 = $5_1 + 16 | 0; 16355 return $0_1 | 0; 16356 } 16357 16358 function $159($0_1, $1_1, $2_1) { 16359 var $3_1 = 0, $4_1 = 0, $5_1 = 0, $6_1 = 0, $7_1 = 0, $8_1 = 0, $9_1 = 0, $10_1 = 0, $11_1 = 0, $12_1 = 0, $13_1 = 0, $14_1 = 0, $15_1 = 0, $16_1 = 0, $17_1 = 0, $18_1 = 0; 16360 $9_1 = global$0 - 16 | 0; 16361 global$0 = $9_1; 16362 $14_1 = 1; 16363 $10_1 = HEAP32[$2_1 >> 2]; 16364 $12_1 = HEAP32[$2_1 + 4 >> 2]; 16365 $13_1 = HEAP32[$12_1 + 16 >> 2]; 16366 block : { 16367 if (FUNCTION_TABLE[$13_1 | 0]($10_1, 34) | 0) { 16368 break block 16369 } 16370 block8 : { 16371 block12 : { 16372 block1 : { 16373 if (!$1_1) { 16374 $2_1 = 0; 16375 break block1; 16376 } 16377 $16_1 = 0 - $1_1 | 0; 16378 $4_1 = $1_1; 16379 $6_1 = $0_1; 16380 block3 : { 16381 while (1) { 16382 $17_1 = $4_1 + $6_1 | 0; 16383 $2_1 = 0; 16384 block2 : { 16385 while (1) { 16386 $5_1 = $2_1 + $6_1 | 0; 16387 $7_1 = HEAPU8[$5_1 | 0]; 16388 if (($7_1 - 127 & 255) >>> 0 < 161 | ($7_1 | 0) == 34 | ($7_1 | 0) == 92) { 16389 break block2 16390 } 16391 $2_1 = $2_1 + 1 | 0; 16392 if (($2_1 | 0) != ($4_1 | 0)) { 16393 continue 16394 } 16395 break; 16396 }; 16397 $2_1 = $4_1 + $11_1 | 0; 16398 break block3; 16399 } 16400 $6_1 = $5_1 + 1 | 0; 16401 $4_1 = HEAP8[$5_1 | 0]; 16402 block4 : { 16403 if (($4_1 | 0) >= 0) { 16404 $4_1 = $4_1 & 255; 16405 break block4; 16406 } 16407 $8_1 = HEAPU8[$6_1 | 0] & 63; 16408 $7_1 = $4_1 & 31; 16409 $6_1 = $5_1 + 2 | 0; 16410 if ($4_1 >>> 0 <= 4294967263) { 16411 $4_1 = $8_1 | $7_1 << 6; 16412 break block4; 16413 } 16414 $8_1 = HEAPU8[$6_1 | 0] & 63 | $8_1 << 6; 16415 $6_1 = $5_1 + 3 | 0; 16416 if ($4_1 >>> 0 < 4294967280) { 16417 $4_1 = $7_1 << 12 | $8_1; 16418 break block4; 16419 } 16420 $4_1 = $7_1 << 18 & 1835008 | (HEAPU8[$6_1 | 0] & 63 | $8_1 << 6); 16421 $6_1 = $5_1 + 4 | 0; 16422 } 16423 $136($9_1, $4_1, 65537); 16424 $7_1 = HEAPU8[$9_1 + 13 | 0]; 16425 $8_1 = HEAPU8[$9_1 + 12 | 0]; 16426 $15_1 = $7_1 - $8_1 | 0; 16427 if (($15_1 & 255) != 1) { 16428 block7 : { 16429 block5 : { 16430 $5_1 = $2_1 + $11_1 | 0; 16431 if ($5_1 >>> 0 < $3_1 >>> 0 | $1_1 >>> 0 < $5_1 >>> 0) { 16432 break block5 16433 } 16434 block6 : { 16435 if (($1_1 | 0) == ($3_1 | 0)) { 16436 break block6 16437 } 16438 if (HEAP8[$0_1 + $3_1 | 0] <= -65 ? $3_1 : 0) { 16439 break block5 16440 } 16441 if (!($5_1 + $16_1 | 0)) { 16442 break block6 16443 } 16444 if (HEAP8[$2_1 + ($0_1 + $11_1 | 0) | 0] <= -65) { 16445 break block5 16446 } 16447 } 16448 $5_1 = $0_1 + $3_1 | 0; 16449 $18_1 = $2_1 + ($11_1 - $3_1 | 0) | 0; 16450 $3_1 = HEAP32[$12_1 + 12 >> 2]; 16451 if (!(FUNCTION_TABLE[$3_1 | 0]($10_1, $5_1, $18_1) | 0)) { 16452 break block7 16453 } 16454 break block8; 16455 } 16456 $148($0_1, $1_1, $3_1, $5_1, 1067376); 16457 wasm2js_trap(); 16458 } 16459 block9 : { 16460 if ($7_1 >>> 0 >= 129) { 16461 if (FUNCTION_TABLE[$13_1 | 0]($10_1, HEAP32[$9_1 >> 2]) | 0) { 16462 break block8 16463 } 16464 break block9; 16465 } 16466 if (FUNCTION_TABLE[$3_1 | 0]($10_1, $8_1 + $9_1 | 0, $15_1) | 0) { 16467 break block8 16468 } 16469 } 16470 $3_1 = 1; 16471 block10 : { 16472 if ($4_1 >>> 0 < 128) { 16473 break block10 16474 } 16475 $3_1 = 2; 16476 if ($4_1 >>> 0 < 2048) { 16477 break block10 16478 } 16479 $3_1 = $4_1 >>> 0 < 65536 ? 3 : 4; 16480 } 16481 $3_1 = $2_1 + ($3_1 + $11_1 | 0) | 0; 16482 } 16483 $5_1 = 1; 16484 block11 : { 16485 if ($4_1 >>> 0 < 128) { 16486 break block11 16487 } 16488 $5_1 = 2; 16489 if ($4_1 >>> 0 < 2048) { 16490 break block11 16491 } 16492 $5_1 = $4_1 >>> 0 < 65536 ? 3 : 4; 16493 } 16494 $5_1 = $5_1 + $11_1 | 0; 16495 $11_1 = $2_1 + $5_1 | 0; 16496 $4_1 = $17_1 - $6_1 | 0; 16497 if ($4_1) { 16498 continue 16499 } 16500 break; 16501 }; 16502 $2_1 = $2_1 + $5_1 | 0; 16503 } 16504 if ($2_1 >>> 0 < $3_1 >>> 0 | $1_1 >>> 0 < $2_1 >>> 0) { 16505 break block12 16506 } 16507 if (($1_1 | 0) == ($3_1 | 0)) { 16508 break block1 16509 } 16510 if (HEAP8[$0_1 + $3_1 | 0] <= -65 ? $3_1 : 0) { 16511 break block12 16512 } 16513 if (($1_1 | 0) == ($2_1 | 0)) { 16514 break block1 16515 } 16516 if (HEAP8[$0_1 + $2_1 | 0] < -64) { 16517 break block12 16518 } 16519 } 16520 if (FUNCTION_TABLE[HEAP32[$12_1 + 12 >> 2]]($10_1, $0_1 + $3_1 | 0, $2_1 - $3_1 | 0) | 0) { 16521 break block 16522 } 16523 $14_1 = FUNCTION_TABLE[$13_1 | 0]($10_1, 34) | 0; 16524 break block; 16525 } 16526 $148($0_1, $1_1, $3_1, $2_1, 1067392); 16527 wasm2js_trap(); 16528 } 16529 } 16530 global$0 = $9_1 + 16 | 0; 16531 return $14_1; 16532 } 16533 16534 function $160($0_1, $1_1) { 16535 $0_1 = $0_1 | 0; 16536 $1_1 = $1_1 | 0; 16537 var $2_1 = 0, $3_1 = 0, $4_1 = 0, $5_1 = 0, $6_1 = 0, $7_1 = 0, $8_1 = 0; 16538 $5_1 = global$0 - 16 | 0; 16539 global$0 = $5_1; 16540 $0_1 = HEAP32[$0_1 >> 2]; 16541 block1 : { 16542 block : { 16543 $3_1 = HEAP32[$1_1 + 8 >> 2]; 16544 if (!($3_1 & 33554432)) { 16545 if ($3_1 & 67108864) { 16546 break block 16547 } 16548 $0_1 = $132($0_1, $1_1); 16549 break block1; 16550 } 16551 $2_1 = HEAP32[$0_1 >> 2]; 16552 $3_1 = HEAP32[$0_1 + 4 >> 2]; 16553 $0_1 = 0; 16554 while (1) { 16555 HEAP8[($0_1 + $5_1 | 0) + 15 | 0] = HEAPU8[($2_1 & 15) + 1062599 | 0]; 16556 $0_1 = $0_1 - 1 | 0; 16557 $6_1 = $3_1; 16558 $8_1 = 4; 16559 $4_1 = 4; 16560 if (($8_1 & 63) >>> 0 >= 32) { 16561 $7_1 = 0; 16562 $2_1 = $3_1 >>> $4_1 | 0; 16563 } else { 16564 $7_1 = $6_1 >>> $4_1 | 0; 16565 $2_1 = ((1 << $4_1) - 1 & $6_1) << 32 - $4_1 | $2_1 >>> $4_1; 16566 } 16567 $3_1 = $7_1; 16568 if ($2_1 | $3_1) { 16569 continue 16570 } 16571 break; 16572 }; 16573 $0_1 = $140($1_1, 1, 1067346, 2, ($0_1 + $5_1 | 0) + 16 | 0, 0 - $0_1 | 0); 16574 break block1; 16575 } 16576 $2_1 = HEAP32[$0_1 >> 2]; 16577 $3_1 = HEAP32[$0_1 + 4 >> 2]; 16578 $0_1 = 0; 16579 while (1) { 16580 HEAP8[($0_1 + $5_1 | 0) + 15 | 0] = HEAPU8[($2_1 & 15) + 1067348 | 0]; 16581 $0_1 = $0_1 - 1 | 0; 16582 $7_1 = $3_1; 16583 $8_1 = $2_1; 16584 $2_1 = 4; 16585 $4_1 = 4; 16586 if (($2_1 & 63) >>> 0 >= 32) { 16587 $6_1 = 0; 16588 $2_1 = $3_1 >>> $4_1 | 0; 16589 } else { 16590 $6_1 = $7_1 >>> $4_1 | 0; 16591 $2_1 = ((1 << $4_1) - 1 & $7_1) << 32 - $4_1 | $8_1 >>> $4_1; 16592 } 16593 $3_1 = $6_1; 16594 if ($2_1 | $3_1) { 16595 continue 16596 } 16597 break; 16598 }; 16599 $0_1 = $140($1_1, 1, 1067346, 2, ($0_1 + $5_1 | 0) + 16 | 0, 0 - $0_1 | 0); 16600 } 16601 global$0 = $5_1 + 16 | 0; 16602 return $0_1 | 0; 16603 } 16604 16605 function $161($0_1, $1_1) { 16606 $0_1 = $0_1 | 0; 16607 $1_1 = $1_1 | 0; 16608 var $2_1 = 0, $3_1 = 0, $4_1 = 0, $5_1 = 0, $6_1 = 0, $7_1 = 0, $8_1 = 0, $9_1 = 0, $10_1 = 0, $11_1 = 0, $12_1 = 0, $13_1 = 0; 16609 $9_1 = global$0 - 32 | 0; 16610 global$0 = $9_1; 16611 $7_1 = 20; 16612 $10_1 = HEAP32[$0_1 >> 2]; 16613 $11_1 = $10_1; 16614 $12_1 = HEAP32[$0_1 + 4 >> 2]; 16615 $0_1 = $12_1; 16616 $4_1 = $0_1; 16617 $6_1 = $10_1; 16618 $8_1 = 63; 16619 $3_1 = 31; 16620 if (($8_1 & 63) >>> 0 >= 32) { 16621 $2_1 = $0_1 >> 31; 16622 $5_1 = $0_1 >> $3_1; 16623 } else { 16624 $2_1 = $4_1 >> $3_1; 16625 $5_1 = ((1 << $3_1) - 1 & $4_1) << 32 - $3_1 | $6_1 >>> $3_1; 16626 } 16627 $8_1 = $5_1; 16628 $4_1 = $2_1; 16629 $6_1 = $2_1 ^ $0_1; 16630 $2_1 = $5_1 ^ $11_1; 16631 $5_1 = $2_1 - $5_1 | 0; 16632 $0_1 = $5_1; 16633 $3_1 = $6_1 - (($2_1 >>> 0 < $8_1 >>> 0) + $4_1 | 0) | 0; 16634 $4_1 = $3_1; 16635 $2_1 = 0; 16636 if (($3_1 | 0) == ($2_1 | 0) & $0_1 >>> 0 >= 1e3 | $3_1 >>> 0 > $2_1 >>> 0) { 16637 while (1) { 16638 $6_1 = $4_1; 16639 $11_1 = $5_1; 16640 $5_1 = __wasm_i64_udiv($5_1, $4_1, 1e4, 0); 16641 $4_1 = i64toi32_i32$HIGH_BITS; 16642 $13_1 = $11_1 - __wasm_i64_mul($5_1, $4_1, 1e4, 0) | 0; 16643 $0_1 = $7_1 + ($9_1 + 12 | 0) | 0; 16644 $3_1 = $0_1 - 4 | 0; 16645 $8_1 = (($13_1 & 65535) >>> 0) / 100 | 0; 16646 $2_1 = $8_1 << 1; 16647 $2_1 = HEAPU8[$2_1 + 1063894 | 0] | HEAPU8[$2_1 + 1063895 | 0] << 8; 16648 HEAP8[$3_1 | 0] = $2_1; 16649 HEAP8[$3_1 + 1 | 0] = $2_1 >>> 8; 16650 $2_1 = $0_1 - 2 | 0; 16651 $0_1 = ($13_1 - Math_imul($8_1, 100) & 65535) << 1; 16652 $0_1 = HEAPU8[$0_1 + 1063894 | 0] | HEAPU8[$0_1 + 1063895 | 0] << 8; 16653 HEAP8[$2_1 | 0] = $0_1; 16654 HEAP8[$2_1 + 1 | 0] = $0_1 >>> 8; 16655 $7_1 = $7_1 - 4 | 0; 16656 $8_1 = 0; 16657 $3_1 = $6_1; 16658 if (($8_1 | 0) == ($3_1 | 0) & $11_1 >>> 0 > 9999999 | $3_1 >>> 0 > $8_1 >>> 0) { 16659 continue 16660 } 16661 break; 16662 } 16663 } 16664 $3_1 = 0; 16665 if (($3_1 | 0) == ($4_1 | 0) & $5_1 >>> 0 > 9 | $4_1 >>> 0 > $3_1 >>> 0) { 16666 $7_1 = $7_1 - 2 | 0; 16667 $4_1 = $7_1 + ($9_1 + 12 | 0) | 0; 16668 $0_1 = (($5_1 & 65535) >>> 0) / 100 | 0; 16669 $6_1 = ($5_1 - Math_imul($0_1, 100) & 65535) << 1; 16670 $6_1 = HEAPU8[$6_1 + 1063894 | 0] | HEAPU8[$6_1 + 1063895 | 0] << 8; 16671 HEAP8[$4_1 | 0] = $6_1; 16672 HEAP8[$4_1 + 1 | 0] = $6_1 >>> 8; 16673 $5_1 = $0_1; 16674 $4_1 = 0; 16675 } 16676 if (!(!($4_1 | $5_1) & ($10_1 | $12_1) != 0)) { 16677 $7_1 = $7_1 - 1 | 0; 16678 HEAP8[$7_1 + ($9_1 + 12 | 0) | 0] = HEAPU8[($5_1 << 1) + 1063895 | 0]; 16679 } 16680 $8_1 = $10_1; 16681 $2_1 = $12_1; 16682 $6_1 = 0; 16683 if (($2_1 | 0) > ($6_1 | 0)) { 16684 $0_1 = 1 16685 } else { 16686 $0_1 = ($6_1 | 0) <= ($2_1 | 0) & $3_1 >>> 0 <= $8_1 >>> 0 16687 } 16688 $0_1 = $140($1_1, $0_1, 1, 0, $7_1 + ($9_1 + 12 | 0) | 0, 20 - $7_1 | 0); 16689 global$0 = $9_1 + 32 | 0; 16690 return $0_1 | 0; 16691 } 16692 16693 function $162($0_1, $1_1) { 16694 $0_1 = $0_1 | 0; 16695 $1_1 = $1_1 | 0; 16696 return FUNCTION_TABLE[HEAP32[HEAP32[267026] >> 2]](HEAP32[HEAP32[$0_1 >> 2] >> 2], $1_1) | 0; 16697 } 16698 16699 function $163($0_1, $1_1) { 16700 $0_1 = $0_1 | 0; 16701 $1_1 = $1_1 | 0; 16702 var $2_1 = 0, $3_1 = 0, $4_1 = 0, $5_1 = 0, $6_1 = 0, $7_1 = 0, $8_1 = 0, $9_1 = 0, $10_1 = 0, $11_1 = 0, $12_1 = 0, $13_1 = 0, $14_1 = 0, $15_1 = 0, $16_1 = 0, $17_1 = 0, $18_1 = 0, $19_1 = 0, $20_1 = 0, $21_1 = 0, $22_1 = 0, $23_1 = 0, $24_1 = 0, $25_1 = 0, $26_1 = 0, $27_1 = 0, $28_1 = 0, $29_1 = 0, $30_1 = 0, $31_1 = 0, $32_1 = 0, $33_1 = 0, $34_1 = 0, $35_1 = 0, $36_1 = 0, $37_1 = 0, $38_1 = 0, $39_1 = 0, $40_1 = 0, $41_1 = 0, $42_1 = 0, $43_1 = 0, $44_1 = 0, $45_1 = 0, $46_1 = 0, $47_1 = 0, $48_1 = 0, $49_1 = 0.0, $50_1 = 0, $51_1 = 0, $52_1 = 0, $53_1 = 0, $54_1 = 0, $55_1 = 0, $56_1 = 0, $57_1 = 0, $58_1 = 0; 16703 $8_1 = HEAP32[$1_1 + 8 >> 2]; 16704 $9_1 = $8_1 & 2097152; 16705 $49_1 = HEAPF64[$0_1 >> 3]; 16706 block91 : { 16707 block42 : { 16708 if (!($8_1 & 268435456)) { 16709 $29_1 = $1_1; 16710 $30_1 = ($9_1 | 0) != 0; 16711 $1_1 = 0; 16712 $27_1 = global$0 - 128 | 0; 16713 global$0 = $27_1; 16714 wasm2js_scratch_store_f64(+$49_1); 16715 $4_1 = wasm2js_scratch_load_i32(1) | 0; 16716 $42_1 = wasm2js_scratch_load_i32(0) | 0; 16717 $26_1 = $42_1; 16718 $0_1 = $26_1; 16719 $40_1 = $4_1; 16720 $5_1 = $4_1 & 1048575; 16721 $23_1 = $5_1; 16722 $13_1 = $0_1; 16723 $0_1 = $5_1 | 1048576; 16724 $7_1 = $4_1; 16725 $5_1 = $13_1; 16726 $6_1 = 1; 16727 $3_1 = 1; 16728 if (($6_1 & 63) >>> 0 >= 32) { 16729 $4_1 = $5_1 << $3_1; 16730 $2_1 = 0; 16731 } else { 16732 $4_1 = (1 << $3_1) - 1 & $5_1 >>> 32 - $3_1 | $7_1 << $3_1; 16733 $2_1 = $5_1 << $3_1; 16734 } 16735 $7_1 = $2_1 & -2; 16736 $2_1 = $4_1 & 2097151; 16737 $5_1 = $40_1; 16738 $4_1 = $42_1; 16739 $6_1 = 52; 16740 $3_1 = 20; 16741 if (($6_1 & 63) >>> 0 >= 32) { 16742 $4_1 = $5_1 >>> $3_1 | 0 16743 } else { 16744 $4_1 = ((1 << $3_1) - 1 & $5_1) << 32 - $3_1 | $4_1 >>> $3_1 16745 } 16746 $9_1 = $4_1 & 2047; 16747 $3_1 = $9_1; 16748 $10_1 = $3_1 ? $13_1 : $7_1; 16749 $6_1 = $10_1; 16750 $5_1 = $3_1 ? $0_1 : $2_1; 16751 $13_1 = $5_1; 16752 $18_1 = $6_1 & 1; 16753 $0_1 = 2; 16754 $8_1 = !($23_1 | $26_1); 16755 $26_1 = 0; 16756 $23_1 = $40_1 & 2146435072; 16757 $2_1 = $26_1 | $23_1 ? 4 : $8_1 ? 2 : 3; 16758 block4 : { 16759 block3 : { 16760 switch ((!$26_1 & ($23_1 | 0) == 2146435072 ? $8_1 : $2_1) - 1 | 0) { 16761 case 0: 16762 $0_1 = 3; 16763 break block4; 16764 case 1: 16765 $0_1 = 4; 16766 break block4; 16767 case 2: 16768 $1_1 = $9_1 - 1075 | 0; 16769 $0_1 = !($15_1 | $18_1); 16770 $25_1 = 1; 16771 break block4; 16772 case 3: 16773 break block3; 16774 default: 16775 break block4; 16776 }; 16777 } 16778 $6_1 = $13_1; 16779 $4_1 = $10_1; 16780 $5_1 = 1; 16781 $7_1 = 1; 16782 if (($5_1 & 63) >>> 0 >= 32) { 16783 $3_1 = $4_1 << $7_1; 16784 $0_1 = 0; 16785 } else { 16786 $3_1 = (1 << $7_1) - 1 & $4_1 >>> 32 - $7_1 | $6_1 << $7_1; 16787 $0_1 = $4_1 << $7_1; 16788 } 16789 $1_1 = !$10_1 & ($13_1 | 0) == 1048576; 16790 $7_1 = $1_1; 16791 $10_1 = $7_1 ? 0 : $0_1; 16792 $13_1 = $7_1 ? 4194304 : $3_1; 16793 $6_1 = $7_1; 16794 $25_1 = $6_1 ? 2 : 1; 16795 $0_1 = !($15_1 | $18_1); 16796 $1_1 = $9_1 + ($6_1 ? -1077 : -1076) | 0; 16797 } 16798 HEAP16[$27_1 + 120 >> 1] = $1_1; 16799 $3_1 = $27_1; 16800 HEAP32[$3_1 + 112 >> 2] = $25_1; 16801 HEAP32[$3_1 + 116 >> 2] = $17_1; 16802 HEAP32[$3_1 + 104 >> 2] = 1; 16803 HEAP32[$3_1 + 108 >> 2] = 0; 16804 HEAP32[$3_1 + 96 >> 2] = $10_1; 16805 HEAP32[$3_1 + 100 >> 2] = $13_1; 16806 HEAP8[$3_1 + 122 | 0] = $0_1; 16807 block90 : { 16808 block31 : { 16809 block30 : { 16810 block29 : { 16811 block28 : { 16812 block27 : { 16813 if (($0_1 & 255) >>> 0 <= 1) { 16814 $21_1 = $3_1 + 32 | 0; 16815 $24_1 = $3_1 + 15 | 0; 16816 $9_1 = global$0 - 80 | 0; 16817 global$0 = $9_1; 16818 block26 : { 16819 block10 : { 16820 block12 : { 16821 block11 : { 16822 block9 : { 16823 block8 : { 16824 block7 : { 16825 block6 : { 16826 block5 : { 16827 $0_1 = $3_1 + 96 | 0; 16828 $10_1 = HEAP32[$0_1 >> 2]; 16829 $13_1 = HEAP32[$0_1 + 4 >> 2]; 16830 if ($10_1 | $13_1) { 16831 $18_1 = HEAP32[$0_1 + 8 >> 2]; 16832 $15_1 = HEAP32[$0_1 + 12 >> 2]; 16833 if (!($18_1 | $15_1)) { 16834 break block5 16835 } 16836 $26_1 = HEAP32[$0_1 + 16 >> 2]; 16837 $23_1 = HEAP32[$0_1 + 20 >> 2]; 16838 if (!($26_1 | $23_1)) { 16839 break block6 16840 } 16841 $3_1 = $23_1; 16842 $2_1 = $3_1 + $13_1 | 0; 16843 $4_1 = $26_1; 16844 $5_1 = $10_1 + $4_1 | 0; 16845 $25_1 = $5_1; 16846 $17_1 = $5_1 >>> 0 < $4_1 >>> 0 ? $2_1 + 1 | 0 : $2_1; 16847 $6_1 = $17_1; 16848 if (($6_1 | 0) == ($3_1 | 0) & $5_1 >>> 0 < $4_1 >>> 0 | $3_1 >>> 0 > $6_1 >>> 0) { 16849 break block7 16850 } 16851 $3_1 = $13_1; 16852 $2_1 = $15_1; 16853 if (($3_1 | 0) == ($2_1 | 0) & $10_1 >>> 0 < $18_1 >>> 0 | $3_1 >>> 0 < $2_1 >>> 0) { 16854 break block8 16855 } 16856 $4_1 = $6_1; 16857 $3_1 = 536870912; 16858 if (($6_1 | 0) == ($3_1 | 0) | $3_1 >>> 0 < $6_1 >>> 0) { 16859 break block9 16860 } 16861 $0_1 = HEAPU16[$0_1 + 24 >> 1]; 16862 HEAP16[$9_1 + 64 >> 1] = $0_1; 16863 $2_1 = $10_1; 16864 $3_1 = $18_1; 16865 $26_1 = $2_1 - $3_1 | 0; 16866 $5_1 = $13_1 - (($3_1 >>> 0 > $2_1 >>> 0) + $15_1 | 0) | 0; 16867 $23_1 = $5_1; 16868 $2_1 = $9_1; 16869 HEAP32[$2_1 + 56 >> 2] = $26_1; 16870 HEAP32[$2_1 + 60 >> 2] = $5_1; 16871 $1_1 = $2_1; 16872 $6_1 = $5_1; 16873 $2_1 = $26_1; 16874 $3_1 = Math_clz32($4_1); 16875 $18_1 = ($3_1 | 0) == 32 ? Math_clz32($25_1) + 32 | 0 : $3_1; 16876 $3_1 = $18_1; 16877 $4_1 = $3_1 & 31; 16878 if (($3_1 & 63) >>> 0 >= 32) { 16879 $5_1 = $2_1 << $4_1; 16880 $34_1 = 0; 16881 } else { 16882 $5_1 = (1 << $4_1) - 1 & $2_1 >>> 32 - $4_1 | $6_1 << $4_1; 16883 $34_1 = $2_1 << $4_1; 16884 } 16885 $2_1 = $34_1; 16886 $33_1 = $5_1; 16887 $6_1 = $2_1; 16888 $4_1 = $18_1 & 31; 16889 if (($3_1 & 63) >>> 0 >= 32) { 16890 $2_1 = 0; 16891 $28_1 = $5_1 >>> $4_1 | 0; 16892 } else { 16893 $2_1 = $5_1 >>> $4_1 | 0; 16894 $28_1 = ((1 << $4_1) - 1 & $5_1) << 32 - $4_1 | $6_1 >>> $4_1; 16895 } 16896 $3_1 = $28_1; 16897 $6_1 = $1_1; 16898 HEAP32[$6_1 + 72 >> 2] = $3_1; 16899 HEAP32[$6_1 + 76 >> 2] = $2_1; 16900 if (($26_1 | 0) != ($3_1 | 0) | ($2_1 | 0) != ($23_1 | 0)) { 16901 break block10 16902 } 16903 HEAP16[$9_1 + 64 >> 1] = $0_1; 16904 $2_1 = $9_1; 16905 HEAP32[$2_1 + 56 >> 2] = $10_1; 16906 $5_1 = $13_1; 16907 HEAP32[$2_1 + 60 >> 2] = $5_1; 16908 $3_1 = $10_1; 16909 $6_1 = $18_1; 16910 $4_1 = $6_1 & 31; 16911 if (($6_1 & 63) >>> 0 >= 32) { 16912 $2_1 = $3_1 << $4_1; 16913 $26_1 = 0; 16914 } else { 16915 $2_1 = (1 << $4_1) - 1 & $3_1 >>> 32 - $4_1 | $5_1 << $4_1; 16916 $26_1 = $3_1 << $4_1; 16917 } 16918 $3_1 = $26_1; 16919 $23_1 = $2_1; 16920 $5_1 = $3_1; 16921 $4_1 = $18_1 & 31; 16922 if (($6_1 & 63) >>> 0 >= 32) { 16923 $3_1 = 0; 16924 $28_1 = $2_1 >>> $4_1 | 0; 16925 } else { 16926 $3_1 = $2_1 >>> $4_1 | 0; 16927 $28_1 = ((1 << $4_1) - 1 & $2_1) << 32 - $4_1 | $5_1 >>> $4_1; 16928 } 16929 $2_1 = $28_1; 16930 $5_1 = $1_1; 16931 HEAP32[$5_1 + 72 >> 2] = $2_1; 16932 HEAP32[$5_1 + 76 >> 2] = $3_1; 16933 if (($10_1 | 0) != ($2_1 | 0) | ($3_1 | 0) != ($13_1 | 0)) { 16934 break block10 16935 } 16936 $1_1 = $0_1 - $18_1 | 0; 16937 $0_1 = (Math_imul(-96 - $1_1 << 16 >> 16, 80) + 86960 | 0) / 2126 | 0; 16938 if ($0_1 >>> 0 <= 80) { 16939 $7_1 = $9_1 + 32 | 0; 16940 $0_1 = $0_1 << 4; 16941 $10_1 = HEAP32[$0_1 + 1064944 >> 2]; 16942 $13_1 = HEAP32[$0_1 + 1064948 >> 2]; 16943 $3_1 = $17_1; 16944 $6_1 = $25_1; 16945 $5_1 = $18_1; 16946 $4_1 = $5_1 & 31; 16947 if (($5_1 & 63) >>> 0 >= 32) { 16948 $2_1 = $6_1 << $4_1; 16949 $4_1 = 0; 16950 } else { 16951 $2_1 = (1 << $4_1) - 1 & $6_1 >>> 32 - $4_1 | $3_1 << $4_1; 16952 $4_1 = $6_1 << $4_1; 16953 } 16954 $169($7_1, $10_1, $13_1, $4_1, $2_1); 16955 $6_1 = $13_1; 16956 $169($9_1 + 16 | 0, $10_1, $6_1, $34_1, $33_1); 16957 $169($9_1, $10_1, $6_1, $26_1, $23_1); 16958 $6_1 = 0; 16959 $3_1 = 1; 16960 $1_1 = 0 - (HEAPU16[$0_1 + 1064952 >> 1] + $1_1 | 0) | 0; 16961 $10_1 = $1_1; 16962 $5_1 = $1_1; 16963 $4_1 = $5_1 & 31; 16964 if (($5_1 & 63) >>> 0 >= 32) { 16965 $2_1 = $3_1 << $4_1; 16966 $28_1 = 0; 16967 } else { 16968 $2_1 = (1 << $4_1) - 1 & $3_1 >>> 32 - $4_1 | $6_1 << $4_1; 16969 $28_1 = $3_1 << $4_1; 16970 } 16971 $6_1 = $28_1; 16972 $5_1 = 1; 16973 $36_1 = $6_1 - $5_1 | 0; 16974 $31_1 = $2_1; 16975 $22_1 = $2_1 - ($6_1 >>> 0 < $5_1 >>> 0) | 0; 16976 $2_1 = $9_1; 16977 $3_1 = HEAP32[$2_1 + 16 >> 2]; 16978 $6_1 = HEAP32[$2_1 + 20 >> 2]; 16979 $2_1 = $3_1; 16980 $5_1 = 63; 16981 $3_1 = 31; 16982 if (($5_1 & 63) >>> 0 >= 32) { 16983 $7_1 = $6_1 >> 31; 16984 $46_1 = $6_1 >> $3_1; 16985 } else { 16986 $7_1 = $6_1 >> $3_1; 16987 $46_1 = ((1 << $3_1) - 1 & $6_1) << 32 - $3_1 | $2_1 >>> $3_1; 16988 } 16989 $45_1 = $7_1; 16990 $6_1 = $9_1; 16991 $3_1 = HEAP32[$6_1 >> 2]; 16992 $2_1 = HEAP32[$6_1 + 4 >> 2]; 16993 $6_1 = $3_1; 16994 $3_1 = 31; 16995 if (($5_1 & 63) >>> 0 >= 32) { 16996 $7_1 = 0; 16997 $47_1 = $2_1 >>> $3_1 | 0; 16998 } else { 16999 $7_1 = $2_1 >>> $3_1 | 0; 17000 $47_1 = ((1 << $3_1) - 1 & $2_1) << 32 - $3_1 | $6_1 >>> $3_1; 17001 } 17002 $50_1 = $7_1; 17003 $2_1 = $9_1; 17004 $51_1 = HEAP32[$2_1 + 8 >> 2]; 17005 $52_1 = HEAP32[$2_1 + 12 >> 2]; 17006 $20_1 = HEAPU16[$0_1 + 1064954 >> 1]; 17007 $1_1 = $1_1 & 63; 17008 $53_1 = HEAP32[$2_1 + 24 >> 2]; 17009 $54_1 = HEAP32[$2_1 + 28 >> 2]; 17010 $55_1 = HEAP32[$2_1 + 40 >> 2]; 17011 $0_1 = $55_1; 17012 $56_1 = HEAP32[$2_1 + 44 >> 2]; 17013 $4_1 = $56_1; 17014 $7_1 = HEAP32[$2_1 + 36 >> 2]; 17015 $2_1 = HEAP32[$2_1 + 32 >> 2]; 17016 if (($5_1 & 63) >>> 0 >= 32) { 17017 $6_1 = 0; 17018 $48_1 = $7_1 >>> $3_1 | 0; 17019 } else { 17020 $6_1 = $7_1 >>> $3_1 | 0; 17021 $48_1 = ((1 << $3_1) - 1 & $7_1) << 32 - $3_1 | $2_1 >>> $3_1; 17022 } 17023 $5_1 = $48_1; 17024 $58_1 = $6_1; 17025 $4_1 = $6_1 + $4_1 | 0; 17026 $3_1 = $0_1 + $5_1 | 0; 17027 $4_1 = $3_1 >>> 0 < $5_1 >>> 0 ? $4_1 + 1 | 0 : $4_1; 17028 $37_1 = $3_1; 17029 $5_1 = 1; 17030 $2_1 = $3_1 + $5_1 | 0; 17031 $57_1 = $4_1; 17032 $3_1 = $4_1; 17033 $35_1 = $2_1; 17034 $3_1 = $2_1 >>> 0 < $5_1 >>> 0 ? $3_1 + 1 | 0 : $3_1; 17035 $16_1 = $3_1; 17036 $4_1 = $2_1; 17037 $5_1 = $10_1; 17038 $7_1 = $5_1 & 31; 17039 if (($5_1 & 63) >>> 0 >= 32) { 17040 $0_1 = $3_1 >>> $7_1 | 0 17041 } else { 17042 $0_1 = ((1 << $7_1) - 1 & $3_1) << 32 - $7_1 | $4_1 >>> $7_1 17043 } 17044 if ($0_1 >>> 0 >= 1e4) { 17045 if ($0_1 >>> 0 < 1e6) { 17046 break block11 17047 } 17048 if ($0_1 >>> 0 >= 1e8) { 17049 $8_1 = $0_1 >>> 0 < 1e9; 17050 $14_1 = $8_1 ? 8 : 9; 17051 $8_1 = $8_1 ? 1e8 : 1e9; 17052 break block12; 17053 } 17054 $8_1 = $0_1 >>> 0 < 1e7; 17055 $14_1 = $8_1 ? 6 : 7; 17056 $8_1 = $8_1 ? 1e6 : 1e7; 17057 break block12; 17058 } 17059 if ($0_1 >>> 0 >= 100) { 17060 $8_1 = $0_1 >>> 0 < 1e3; 17061 $14_1 = $8_1 ? 2 : 3; 17062 $8_1 = $8_1 ? 100 : 1e3; 17063 break block12; 17064 } 17065 $14_1 = $0_1 >>> 0 > 9; 17066 $8_1 = $14_1 ? 10 : 1; 17067 break block12; 17068 } 17069 $137($0_1, 81, 1066352); 17070 wasm2js_trap(); 17071 } 17072 $129(1066240, 28, 1066416); 17073 wasm2js_trap(); 17074 } 17075 $129(1066432, 29, 1066464); 17076 wasm2js_trap(); 17077 } 17078 $129(1066480, 28, 1066508); 17079 wasm2js_trap(); 17080 } 17081 $129(1066724, 54, 1066780); 17082 wasm2js_trap(); 17083 } 17084 $129(1066652, 55, 1066708); 17085 wasm2js_trap(); 17086 } 17087 $129(1066540, 45, 1066588); 17088 wasm2js_trap(); 17089 } 17090 $8_1 = $0_1 >>> 0 < 1e5; 17091 $14_1 = $8_1 ? 4 : 5; 17092 $8_1 = $8_1 ? 1e4 : 1e5; 17093 } 17094 $25_1 = $35_1 & $36_1; 17095 $17_1 = $16_1 & $22_1; 17096 $2_1 = $50_1 + $52_1 | 0; 17097 $5_1 = $51_1; 17098 $7_1 = $47_1 + $5_1 | 0; 17099 $39_1 = $7_1; 17100 $19_1 = $5_1 >>> 0 > $7_1 >>> 0 ? $2_1 + 1 | 0 : $2_1; 17101 $38_1 = $1_1; 17102 $1_1 = ($0_1 >>> 0) % ($8_1 >>> 0) | 0; 17103 $20_1 = ($14_1 - $20_1 | 0) + 1 | 0; 17104 $4_1 = $46_1; 17105 $5_1 = $53_1; 17106 $2_1 = $4_1 - $5_1 | 0; 17107 $3_1 = ($45_1 - (($5_1 >>> 0 > $4_1 >>> 0) + $54_1 | 0) | 0) + $16_1 | 0; 17108 $5_1 = $35_1; 17109 $6_1 = $2_1 + $5_1 | 0; 17110 $7_1 = $6_1; 17111 $6_1 = $6_1 >>> 0 < $5_1 >>> 0 ? $3_1 + 1 | 0 : $3_1; 17112 $5_1 = 1; 17113 $4_1 = $7_1 + $5_1 | 0; 17114 $6_1 = $4_1 >>> 0 < $5_1 >>> 0 ? $6_1 + 1 | 0 : $6_1; 17115 $44_1 = $4_1; 17116 $18_1 = $4_1 & $36_1; 17117 $41_1 = $6_1; 17118 $15_1 = $6_1 & $22_1; 17119 block23 : { 17120 block24 : { 17121 block19 : { 17122 block18 : { 17123 block21 : { 17124 block20 : { 17125 block14 : { 17126 block16 : { 17127 block13 : { 17128 block15 : { 17129 while (1) { 17130 $12_1 = $11_1 + $24_1 | 0; 17131 $32_1 = (($0_1 >>> 0) / ($8_1 >>> 0) | 0) + 48 | 0; 17132 HEAP8[$12_1 | 0] = $32_1; 17133 $23_1 = $41_1; 17134 $7_1 = 0; 17135 $0_1 = $1_1; 17136 $6_1 = $0_1; 17137 $5_1 = $38_1; 17138 $2_1 = $5_1 & 31; 17139 if (($5_1 & 63) >>> 0 >= 32) { 17140 $3_1 = $0_1 << $2_1; 17141 $43_1 = 0; 17142 } else { 17143 $3_1 = (1 << $2_1) - 1 & $6_1 >>> 32 - $2_1 | $7_1 << $2_1; 17144 $43_1 = $6_1 << $2_1; 17145 } 17146 $7_1 = $43_1; 17147 $1_1 = $3_1; 17148 $4_1 = $3_1 + $17_1 | 0; 17149 $5_1 = $25_1; 17150 $2_1 = $7_1 + $5_1 | 0; 17151 $10_1 = $2_1; 17152 $13_1 = $2_1 >>> 0 < $5_1 >>> 0 ? $4_1 + 1 | 0 : $4_1; 17153 $4_1 = $23_1; 17154 $7_1 = $13_1; 17155 if (($4_1 | 0) == ($7_1 | 0) & $2_1 >>> 0 < $44_1 >>> 0 | $4_1 >>> 0 > $7_1 >>> 0) { 17156 break block13 17157 } 17158 if (($11_1 | 0) == ($14_1 | 0)) { 17159 $8_1 = $11_1 + 1 | 0; 17160 if ($8_1 >>> 0 >= 17) { 17161 break block14 17162 } 17163 $26_1 = 1; 17164 $23_1 = 0; 17165 break block15; 17166 } 17167 if ($8_1 >>> 0 >= 10) { 17168 $8_1 = ($8_1 >>> 0) / 10 | 0; 17169 $1_1 = ($0_1 >>> 0) % ($8_1 >>> 0) | 0; 17170 $11_1 = $11_1 + 1 | 0; 17171 if (($11_1 | 0) == 17) { 17172 break block16 17173 } 17174 continue; 17175 } 17176 break; 17177 }; 17178 $155(1066604); 17179 wasm2js_trap(); 17180 } 17181 while (1) { 17182 block17 : { 17183 $25_1 = __wasm_i64_mul($25_1, $17_1, 10, 0); 17184 $2_1 = $25_1; 17185 $3_1 = i64toi32_i32$HIGH_BITS; 17186 $17_1 = $3_1; 17187 $5_1 = $2_1; 17188 $7_1 = $38_1; 17189 $6_1 = $7_1 & 31; 17190 $1_1 = $8_1 + $24_1 | 0; 17191 if (($7_1 & 63) >>> 0 >= 32) { 17192 $0_1 = $3_1 >>> $6_1 | 0 17193 } else { 17194 $0_1 = ((1 << $6_1) - 1 & $3_1) << 32 - $6_1 | $5_1 >>> $6_1 17195 } 17196 $11_1 = $0_1 + 48 | 0; 17197 HEAP8[$1_1 | 0] = $11_1; 17198 $10_1 = __wasm_i64_mul($26_1, $23_1, 10, 0); 17199 $13_1 = i64toi32_i32$HIGH_BITS; 17200 $34_1 = __wasm_i64_mul($18_1, $15_1, 10, 0); 17201 $4_1 = $34_1; 17202 $33_1 = i64toi32_i32$HIGH_BITS; 17203 $5_1 = $33_1; 17204 $17_1 = $17_1 & $22_1; 17205 $3_1 = $17_1; 17206 $25_1 = $25_1 & $36_1; 17207 if (($5_1 | 0) == ($3_1 | 0) & $25_1 >>> 0 < $4_1 >>> 0 | $3_1 >>> 0 < $5_1 >>> 0) { 17208 break block17 17209 } 17210 $18_1 = $4_1; 17211 $15_1 = $5_1; 17212 $26_1 = $10_1; 17213 $23_1 = $13_1; 17214 $8_1 = $8_1 + 1 | 0; 17215 if ($8_1 >>> 0 < 17) { 17216 continue 17217 } 17218 break block14; 17219 } 17220 break; 17221 }; 17222 $7_1 = $34_1; 17223 $3_1 = $25_1; 17224 $38_1 = $7_1 - $3_1 | 0; 17225 $4_1 = $38_1; 17226 $37_1 = $33_1 - (($3_1 >>> 0 > $7_1 >>> 0) + $17_1 | 0) | 0; 17227 $2_1 = $37_1; 17228 $7_1 = $31_1; 17229 $0_1 = ($2_1 | 0) == ($7_1 | 0) & $4_1 >>> 0 < $28_1 >>> 0 | $2_1 >>> 0 < $7_1 >>> 0; 17230 $3_1 = $35_1; 17231 $7_1 = $39_1; 17232 $36_1 = __wasm_i64_mul($10_1, $13_1, $3_1 - $7_1 | 0, $16_1 - (($3_1 >>> 0 < $7_1 >>> 0) + $19_1 | 0) | 0); 17233 $7_1 = $10_1; 17234 $2_1 = $36_1 + $7_1 | 0; 17235 $22_1 = i64toi32_i32$HIGH_BITS; 17236 $5_1 = $13_1 + $22_1 | 0; 17237 $35_1 = $2_1; 17238 $16_1 = $2_1 >>> 0 < $7_1 >>> 0 ? $5_1 + 1 | 0 : $5_1; 17239 $4_1 = $37_1; 17240 $5_1 = $31_1; 17241 $2_1 = ($4_1 | 0) == ($5_1 | 0) & $28_1 >>> 0 > $38_1 >>> 0 | $5_1 >>> 0 > $4_1 >>> 0; 17242 $7_1 = $36_1; 17243 $4_1 = $10_1; 17244 $36_1 = $7_1 - $4_1 | 0; 17245 $3_1 = $36_1; 17246 $10_1 = $2_1; 17247 $22_1 = $22_1 - (($4_1 >>> 0 > $7_1 >>> 0) + $13_1 | 0) | 0; 17248 $7_1 = $22_1; 17249 $2_1 = $17_1; 17250 if ($10_1 | (($7_1 | 0) == ($2_1 | 0) & $3_1 >>> 0 <= $25_1 >>> 0 | $2_1 >>> 0 > $7_1 >>> 0)) { 17251 break block18 17252 } 17253 $4_1 = $28_1; 17254 $38_1 = $4_1 - $3_1 | 0; 17255 $37_1 = $5_1 - (($4_1 >>> 0 < $3_1 >>> 0) + $22_1 | 0) | 0; 17256 $6_1 = 0; 17257 $7_1 = $25_1; 17258 $39_1 = $6_1 - $7_1 | 0; 17259 $19_1 = 0 - (($6_1 >>> 0 < $7_1 >>> 0) + $2_1 | 0) | 0; 17260 $3_1 = __wasm_i64_mul($18_1, $15_1, 10, 0); 17261 $18_1 = $3_1 - $4_1 | 0; 17262 $15_1 = i64toi32_i32$HIGH_BITS - (($3_1 >>> 0 < $4_1 >>> 0) + $5_1 | 0) | 0; 17263 while (1) { 17264 $4_1 = $17_1 + $31_1 | 0; 17265 $7_1 = $28_1; 17266 $6_1 = $7_1 + $25_1 | 0; 17267 $10_1 = $6_1; 17268 $4_1 = $6_1 >>> 0 < $7_1 >>> 0 ? $4_1 + 1 | 0 : $4_1; 17269 $13_1 = $4_1; 17270 $5_1 = $22_1; 17271 $7_1 = $36_1; 17272 $12_1 = ($4_1 | 0) == ($5_1 | 0) & $6_1 >>> 0 < $7_1 >>> 0 | $5_1 >>> 0 > $4_1 >>> 0; 17273 $5_1 = $39_1; 17274 $3_1 = $7_1 + $5_1 | 0; 17275 $6_1 = $22_1 + $19_1 | 0; 17276 $6_1 = $3_1 >>> 0 < $5_1 >>> 0 ? $6_1 + 1 | 0 : $6_1; 17277 $0_1 = $3_1; 17278 $3_1 = $17_1 + $37_1 | 0; 17279 $5_1 = $38_1; 17280 $4_1 = $25_1 + $5_1 | 0; 17281 $2_1 = $4_1 >>> 0 < $5_1 >>> 0 ? $3_1 + 1 | 0 : $3_1; 17282 $3_1 = $6_1; 17283 if (!(($2_1 | 0) == ($3_1 | 0) & $0_1 >>> 0 >= $4_1 >>> 0 | $3_1 >>> 0 > $2_1 >>> 0 | $12_1)) { 17284 $0_1 = 0; 17285 break block18; 17286 } 17287 $11_1 = $11_1 - 1 | 0; 17288 HEAP8[$1_1 | 0] = $11_1; 17289 $4_1 = $15_1 + $19_1 | 0; 17290 $2_1 = $39_1; 17291 $7_1 = $2_1 + $18_1 | 0; 17292 $4_1 = $7_1 >>> 0 < $2_1 >>> 0 ? $4_1 + 1 | 0 : $4_1; 17293 $41_1 = $4_1; 17294 $5_1 = $31_1; 17295 $0_1 = ($4_1 | 0) == ($5_1 | 0) & $7_1 >>> 0 < $28_1 >>> 0 | $5_1 >>> 0 > $4_1 >>> 0; 17296 $4_1 = $22_1; 17297 $6_1 = $13_1; 17298 if (($4_1 | 0) == ($6_1 | 0) & $10_1 >>> 0 >= $36_1 >>> 0 | $6_1 >>> 0 > $4_1 >>> 0) { 17299 break block19 17300 } 17301 $4_1 = $28_1; 17302 $39_1 = $2_1 - $4_1 | 0; 17303 $6_1 = $31_1; 17304 $19_1 = $19_1 - ($6_1 + ($2_1 >>> 0 < $4_1 >>> 0) | 0) | 0; 17305 $25_1 = $10_1; 17306 $17_1 = $13_1; 17307 $5_1 = $41_1; 17308 if (($6_1 | 0) == ($5_1 | 0) & $4_1 >>> 0 <= $7_1 >>> 0 | $6_1 >>> 0 < $5_1 >>> 0) { 17309 continue 17310 } 17311 break; 17312 }; 17313 break block19; 17314 } 17315 $4_1 = $44_1; 17316 $5_1 = $10_1; 17317 $18_1 = $4_1 - $5_1 | 0; 17318 $0_1 = $18_1; 17319 $15_1 = $41_1 - (($5_1 >>> 0 > $4_1 >>> 0) + $13_1 | 0) | 0; 17320 $6_1 = $15_1; 17321 $3_1 = 0; 17322 $2_1 = $8_1; 17323 $5_1 = $38_1; 17324 $7_1 = $5_1 & 31; 17325 if (($5_1 & 63) >>> 0 >= 32) { 17326 $4_1 = $2_1 << $7_1; 17327 $26_1 = 0; 17328 } else { 17329 $4_1 = (1 << $7_1) - 1 & $2_1 >>> 32 - $7_1 | $3_1 << $7_1; 17330 $26_1 = $2_1 << $7_1; 17331 } 17332 $5_1 = $26_1; 17333 $23_1 = $4_1; 17334 $2_1 = $4_1; 17335 $8_1 = ($2_1 | 0) == ($6_1 | 0) & $0_1 >>> 0 < $5_1 >>> 0 | $2_1 >>> 0 > $6_1 >>> 0; 17336 $5_1 = $35_1; 17337 $2_1 = $39_1; 17338 $28_1 = $5_1 - $2_1 | 0; 17339 $0_1 = $28_1; 17340 $6_1 = $16_1 - (($2_1 >>> 0 > $5_1 >>> 0) + $19_1 | 0) | 0; 17341 $31_1 = $6_1; 17342 $2_1 = 1; 17343 $4_1 = $2_1 + $0_1 | 0; 17344 $34_1 = $4_1; 17345 $33_1 = $2_1 >>> 0 > $4_1 >>> 0 ? $6_1 + 1 | 0 : $6_1; 17346 $7_1 = $15_1; 17347 $3_1 = $23_1; 17348 $6_1 = ($7_1 | 0) == ($3_1 | 0) & $18_1 >>> 0 < $26_1 >>> 0 | $3_1 >>> 0 > $7_1 >>> 0; 17349 $2_1 = $0_1; 17350 $3_1 = 1; 17351 $35_1 = $0_1 - $3_1 | 0; 17352 $0_1 = $35_1; 17353 $4_1 = $13_1; 17354 $16_1 = $31_1 - ($3_1 >>> 0 > $2_1 >>> 0) | 0; 17355 $2_1 = $16_1; 17356 if (($4_1 | 0) == ($2_1 | 0) & $0_1 >>> 0 <= $10_1 >>> 0 | $2_1 >>> 0 < $4_1 >>> 0 | $6_1) { 17357 break block20 17358 } 17359 $3_1 = $37_1; 17360 $2_1 = $39_1; 17361 $5_1 = $3_1 - $2_1 | 0; 17362 $0_1 = $57_1 - (($3_1 >>> 0 < $2_1 >>> 0) + $19_1 | 0) | 0; 17363 $7_1 = $1_1 + $17_1 | 0; 17364 $2_1 = $43_1; 17365 $4_1 = $2_1 + $25_1 | 0; 17366 $7_1 = $4_1 >>> 0 < $2_1 >>> 0 ? $7_1 + 1 | 0 : $7_1; 17367 $2_1 = $4_1; 17368 $36_1 = $5_1 - $2_1 | 0; 17369 $22_1 = $0_1 - (($2_1 >>> 0 > $5_1 >>> 0) + $7_1 | 0) | 0; 17370 $3_1 = $45_1 + $57_1 | 0; 17371 $2_1 = $37_1; 17372 $6_1 = $2_1 + $46_1 | 0; 17373 $3_1 = $6_1 >>> 0 < $2_1 >>> 0 ? $3_1 + 1 | 0 : $3_1; 17374 $2_1 = $53_1; 17375 $0_1 = $6_1 - $2_1 | 0; 17376 $3_1 = $3_1 - (($2_1 >>> 0 > $6_1 >>> 0) + $54_1 | 0) | 0; 17377 $5_1 = $17_1 + $23_1 | 0; 17378 $2_1 = $26_1; 17379 $7_1 = $2_1 + $25_1 | 0; 17380 $5_1 = $7_1 >>> 0 < $2_1 >>> 0 ? $5_1 + 1 | 0 : $5_1; 17381 $18_1 = $7_1; 17382 $15_1 = $5_1; 17383 $7_1 = $1_1 + $5_1 | 0; 17384 $2_1 = $43_1; 17385 $4_1 = $2_1 + $18_1 | 0; 17386 $7_1 = $4_1 >>> 0 < $2_1 >>> 0 ? $7_1 + 1 | 0 : $7_1; 17387 $5_1 = $0_1; 17388 $2_1 = $4_1; 17389 $0_1 = $0_1 - $2_1 | 0; 17390 $4_1 = $3_1 - (($2_1 >>> 0 > $5_1 >>> 0) + $7_1 | 0) | 0; 17391 $2_1 = 2; 17392 $6_1 = $2_1 + $0_1 | 0; 17393 $3_1 = $4_1; 17394 $39_1 = $6_1; 17395 $19_1 = $2_1 >>> 0 > $6_1 >>> 0 ? $3_1 + 1 | 0 : $3_1; 17396 $6_1 = $15_1 + $50_1 | 0; 17397 $2_1 = $47_1; 17398 $5_1 = $2_1 + $18_1 | 0; 17399 $6_1 = $5_1 >>> 0 < $2_1 >>> 0 ? $6_1 + 1 | 0 : $6_1; 17400 $3_1 = $5_1; 17401 $5_1 = $6_1 + $52_1 | 0; 17402 $2_1 = $51_1; 17403 $7_1 = $2_1 + $3_1 | 0; 17404 $5_1 = $7_1 >>> 0 < $2_1 >>> 0 ? $5_1 + 1 | 0 : $5_1; 17405 $6_1 = $7_1; 17406 $2_1 = $48_1; 17407 $0_1 = $6_1 - $2_1 | 0; 17408 $7_1 = $5_1 - (($2_1 >>> 0 > $6_1 >>> 0) + $58_1 | 0) | 0; 17409 $5_1 = $0_1; 17410 $2_1 = $55_1; 17411 $0_1 = $0_1 - $2_1 | 0; 17412 $3_1 = $1_1 + ($7_1 - (($2_1 >>> 0 > $5_1 >>> 0) + $56_1 | 0) | 0) | 0; 17413 $2_1 = $43_1; 17414 $6_1 = $2_1 + $0_1 | 0; 17415 $3_1 = $6_1 >>> 0 < $2_1 >>> 0 ? $3_1 + 1 | 0 : $3_1; 17416 $28_1 = $6_1; 17417 $31_1 = $3_1; 17418 $25_1 = 0; 17419 $17_1 = 0; 17420 while (1) { 17421 $6_1 = $13_1 + $23_1 | 0; 17422 $2_1 = $26_1; 17423 $5_1 = $2_1 + $10_1 | 0; 17424 $6_1 = $5_1 >>> 0 < $2_1 >>> 0 ? $6_1 + 1 | 0 : $6_1; 17425 $18_1 = $5_1; 17426 $4_1 = $16_1; 17427 $15_1 = $6_1; 17428 $0_1 = ($4_1 | 0) == ($6_1 | 0) & $5_1 >>> 0 < $35_1 >>> 0 | $6_1 >>> 0 < $4_1 >>> 0; 17429 $4_1 = $36_1; 17430 $7_1 = $25_1 + $4_1 | 0; 17431 $5_1 = $17_1 + $22_1 | 0; 17432 $5_1 = $4_1 >>> 0 > $7_1 >>> 0 ? $5_1 + 1 | 0 : $5_1; 17433 $2_1 = $31_1; 17434 if (!(($5_1 | 0) == ($2_1 | 0) & $7_1 >>> 0 >= $28_1 >>> 0 | $2_1 >>> 0 < $5_1 >>> 0 | $0_1)) { 17435 $8_1 = 0; 17436 break block20; 17437 } 17438 $32_1 = $32_1 - 1 | 0; 17439 HEAP8[$12_1 | 0] = $32_1; 17440 $7_1 = $17_1 + $19_1 | 0; 17441 $2_1 = $39_1; 17442 $6_1 = $2_1 + $25_1 | 0; 17443 $7_1 = $6_1 >>> 0 < $2_1 >>> 0 ? $7_1 + 1 | 0 : $7_1; 17444 $38_1 = $6_1; 17445 $4_1 = $23_1; 17446 $37_1 = $7_1; 17447 $8_1 = ($4_1 | 0) == ($7_1 | 0) & $6_1 >>> 0 < $26_1 >>> 0 | $4_1 >>> 0 > $7_1 >>> 0; 17448 $7_1 = $16_1; 17449 $3_1 = $15_1; 17450 if (($7_1 | 0) == ($3_1 | 0) & $18_1 >>> 0 >= $35_1 >>> 0 | $3_1 >>> 0 > $7_1 >>> 0) { 17451 break block21 17452 } 17453 $6_1 = $4_1 + $31_1 | 0; 17454 $7_1 = $28_1; 17455 $5_1 = $7_1 + $26_1 | 0; 17456 $6_1 = $5_1 >>> 0 < $7_1 >>> 0 ? $6_1 + 1 | 0 : $6_1; 17457 $28_1 = $5_1; 17458 $31_1 = $6_1; 17459 $2_1 = $25_1; 17460 $7_1 = $26_1; 17461 $25_1 = $2_1 - $7_1 | 0; 17462 $17_1 = $17_1 - ($4_1 + ($2_1 >>> 0 < $7_1 >>> 0) | 0) | 0; 17463 $10_1 = $18_1; 17464 $13_1 = $3_1; 17465 $5_1 = $4_1; 17466 $2_1 = $37_1; 17467 if (($5_1 | 0) == ($2_1 | 0) & $7_1 >>> 0 <= $38_1 >>> 0 | $2_1 >>> 0 > $5_1 >>> 0) { 17468 continue 17469 } 17470 break; 17471 }; 17472 break block21; 17473 } 17474 $137(17, 17, 1066620); 17475 wasm2js_trap(); 17476 } 17477 $137($8_1, 17, 1066636); 17478 wasm2js_trap(); 17479 } 17480 $18_1 = $10_1; 17481 $15_1 = $13_1; 17482 } 17483 block22 : { 17484 $5_1 = $33_1; 17485 $6_1 = $15_1; 17486 $2_1 = $34_1; 17487 if ($8_1 | (($5_1 | 0) == ($6_1 | 0) & $2_1 >>> 0 <= $18_1 >>> 0 | $6_1 >>> 0 > $5_1 >>> 0)) { 17488 break block22 17489 } 17490 $7_1 = $2_1; 17491 $0_1 = $5_1; 17492 $3_1 = $6_1 + $23_1 | 0; 17493 $5_1 = $26_1; 17494 $4_1 = $18_1 + $5_1 | 0; 17495 $3_1 = $4_1 >>> 0 < $5_1 >>> 0 ? $3_1 + 1 | 0 : $3_1; 17496 $10_1 = $4_1; 17497 $13_1 = $3_1; 17498 $3_1 = $0_1; 17499 $2_1 = $13_1; 17500 $1_1 = ($0_1 | 0) == ($2_1 | 0) & $4_1 >>> 0 >= $7_1 >>> 0 | $0_1 >>> 0 < $2_1 >>> 0; 17501 $5_1 = $7_1; 17502 $2_1 = $18_1; 17503 $4_1 = $5_1 - $2_1 | 0; 17504 $6_1 = $0_1 - (($2_1 >>> 0 > $5_1 >>> 0) + $6_1 | 0) | 0; 17505 $7_1 = $10_1; 17506 $2_1 = $5_1; 17507 $0_1 = $7_1 - $2_1 | 0; 17508 $7_1 = $13_1 - (($2_1 >>> 0 > $7_1 >>> 0) + $3_1 | 0) | 0; 17509 if ((($6_1 | 0) == ($7_1 | 0) & $0_1 >>> 0 > $4_1 >>> 0 | $6_1 >>> 0 < $7_1 >>> 0) & $1_1) { 17510 break block22 17511 } 17512 HEAP32[$21_1 >> 2] = 0; 17513 break block23; 17514 } 17515 $2_1 = $44_1; 17516 $7_1 = 4; 17517 $0_1 = $2_1 - $7_1 | 0; 17518 $3_1 = $15_1; 17519 $2_1 = $41_1 - ($2_1 >>> 0 < $7_1 >>> 0) | 0; 17520 $0_1 = ($3_1 | 0) == ($2_1 | 0) & $0_1 >>> 0 >= $18_1 >>> 0 | $3_1 >>> 0 < $2_1 >>> 0; 17521 $4_1 = $3_1; 17522 $3_1 = 0; 17523 if (!($0_1 & (($4_1 | 0) == ($3_1 | 0) & $18_1 >>> 0 >= 2 | $3_1 >>> 0 < $4_1 >>> 0))) { 17524 HEAP32[$21_1 >> 2] = 0; 17525 break block23; 17526 } 17527 HEAP16[$21_1 + 8 >> 1] = $20_1; 17528 HEAP32[$21_1 + 4 >> 2] = $11_1 + 1; 17529 break block24; 17530 } 17531 $10_1 = $25_1; 17532 $13_1 = $17_1; 17533 } 17534 block25 : { 17535 $4_1 = $16_1; 17536 $7_1 = $13_1; 17537 $3_1 = $35_1; 17538 if ($0_1 | (($4_1 | 0) == ($7_1 | 0) & $10_1 >>> 0 >= $3_1 >>> 0 | $4_1 >>> 0 < $7_1 >>> 0)) { 17539 break block25 17540 } 17541 $2_1 = $3_1; 17542 $0_1 = $4_1; 17543 $5_1 = $7_1 + $31_1 | 0; 17544 $4_1 = $28_1; 17545 $6_1 = $10_1 + $4_1 | 0; 17546 $18_1 = $6_1; 17547 $15_1 = $6_1 >>> 0 < $4_1 >>> 0 ? $5_1 + 1 | 0 : $5_1; 17548 $3_1 = $15_1; 17549 $1_1 = ($3_1 | 0) == ($0_1 | 0) & $2_1 >>> 0 <= $6_1 >>> 0 | $0_1 >>> 0 < $3_1 >>> 0; 17550 $4_1 = $2_1; 17551 $3_1 = $10_1; 17552 $6_1 = $2_1 - $3_1 | 0; 17553 $7_1 = $0_1 - (($3_1 >>> 0 > $2_1 >>> 0) + $7_1 | 0) | 0; 17554 $2_1 = $18_1; 17555 $3_1 = $4_1; 17556 $0_1 = $2_1 - $3_1 | 0; 17557 $2_1 = $15_1 - (($3_1 >>> 0 > $2_1 >>> 0) + $16_1 | 0) | 0; 17558 if ((($2_1 | 0) == ($7_1 | 0) & $0_1 >>> 0 > $6_1 >>> 0 | $2_1 >>> 0 > $7_1 >>> 0) & $1_1) { 17559 break block25 17560 } 17561 HEAP32[$21_1 >> 2] = 0; 17562 break block23; 17563 } 17564 $6_1 = $10_1; 17565 $0_1 = $13_1; 17566 $2_1 = __wasm_i64_mul($26_1, $23_1, -40, -1); 17567 $5_1 = $33_1 + i64toi32_i32$HIGH_BITS | 0; 17568 $4_1 = $2_1 + $34_1 | 0; 17569 $3_1 = $2_1 >>> 0 > $4_1 >>> 0 ? $5_1 + 1 | 0 : $5_1; 17570 $0_1 = ($0_1 | 0) == ($3_1 | 0) & $6_1 >>> 0 <= $4_1 >>> 0 | $0_1 >>> 0 < $3_1 >>> 0; 17571 $3_1 = __wasm_i64_mul($26_1, $23_1, 20, 0); 17572 $5_1 = i64toi32_i32$HIGH_BITS; 17573 $6_1 = $13_1; 17574 if (!((($5_1 | 0) == ($6_1 | 0) & $3_1 >>> 0 <= $10_1 >>> 0 | $6_1 >>> 0 > $5_1 >>> 0) & $0_1)) { 17575 HEAP32[$21_1 >> 2] = 0; 17576 break block23; 17577 } 17578 HEAP16[$21_1 + 8 >> 1] = $20_1; 17579 HEAP32[$21_1 + 4 >> 2] = $8_1 + 1; 17580 } 17581 HEAP32[$21_1 >> 2] = $24_1; 17582 } 17583 global$0 = $9_1 + 80 | 0; 17584 break block26; 17585 } 17586 $1_1 = global$0 - 16 | 0; 17587 global$0 = $1_1; 17588 HEAP32[$1_1 + 12 >> 2] = $9_1 + 56; 17589 HEAP32[$1_1 + 8 >> 2] = $9_1 + 72; 17590 $0_1 = global$0 + -64 | 0; 17591 global$0 = $0_1; 17592 HEAP32[$0_1 + 4 >> 2] = 1062616; 17593 HEAP32[$0_1 >> 2] = $1_1 + 8; 17594 HEAP32[$0_1 + 12 >> 2] = 1062616; 17595 HEAP32[$0_1 + 8 >> 2] = $1_1 + 12; 17596 HEAP32[$0_1 + 20 >> 2] = HEAPU8[1067420]; 17597 HEAP32[$0_1 + 16 >> 2] = HEAP32[266852]; 17598 HEAP32[$0_1 + 48 >> 2] = $0_1 + 8; 17599 HEAP32[$0_1 + 52 >> 2] = 53; 17600 HEAP32[$0_1 + 40 >> 2] = $0_1; 17601 HEAP32[$0_1 + 44 >> 2] = 53; 17602 HEAP32[$0_1 + 32 >> 2] = $0_1 + 16; 17603 HEAP32[$0_1 + 36 >> 2] = 55; 17604 $134(1049070, $0_1 + 32 | 0, 1062776); 17605 wasm2js_trap(); 17606 } 17607 $3_1 = $42_1; 17608 $5_1 = 0; 17609 $6_1 = 0; 17610 $2_1 = $40_1; 17611 if (($6_1 | 0) > ($2_1 | 0)) { 17612 $0_1 = 1 17613 } else { 17614 $0_1 = $3_1 >>> 0 < $5_1 >>> 0 & ($2_1 | 0) <= ($6_1 | 0) 17615 } 17616 $34_1 = $0_1 ? 1062711 : 1; 17617 $39_1 = $0_1 ? 1062711 : 1062712; 17618 $3_1 = $40_1; 17619 $5_1 = $42_1; 17620 $6_1 = 63; 17621 $7_1 = 31; 17622 if (($6_1 & 63) >>> 0 >= 32) { 17623 $41_1 = $3_1 >>> $7_1 | 0 17624 } else { 17625 $41_1 = ((1 << $7_1) - 1 & $3_1) << 32 - $7_1 | $5_1 >>> $7_1 17626 } 17627 if (!HEAP32[$27_1 + 32 >> 2]) { 17628 break block27 17629 } 17630 HEAP32[$27_1 + 88 >> 2] = HEAP32[$27_1 + 40 >> 2]; 17631 $3_1 = $27_1; 17632 $0_1 = HEAP32[$3_1 + 32 >> 2]; 17633 $5_1 = HEAP32[$3_1 + 36 >> 2]; 17634 HEAP32[$3_1 + 80 >> 2] = $0_1; 17635 HEAP32[$3_1 + 84 >> 2] = $5_1; 17636 break block28; 17637 } 17638 $8_1 = $0_1 - 2 | 0; 17639 if (!($8_1 & 255)) { 17640 break block29 17641 } 17642 $0_1 = 1; 17643 $3_1 = $42_1; 17644 $6_1 = 0; 17645 $5_1 = $40_1; 17646 $2_1 = 0; 17647 if (($5_1 | 0) < ($2_1 | 0)) { 17648 $1_1 = 1 17649 } else { 17650 $1_1 = $3_1 >>> 0 < $6_1 >>> 0 & ($2_1 | 0) >= ($5_1 | 0) 17651 } 17652 $1_1 = $30_1 ? ($1_1 ? 1062711 : 1062712) : $1_1 ? 1062711 : 1; 17653 $3_1 = $40_1; 17654 $6_1 = $42_1; 17655 $2_1 = 63; 17656 $7_1 = 31; 17657 if (($2_1 & 63) >>> 0 >= 32) { 17658 $2_1 = $3_1 >>> $7_1 | 0 17659 } else { 17660 $2_1 = ((1 << $7_1) - 1 & $3_1) << 32 - $7_1 | $6_1 >>> $7_1 17661 } 17662 $9_1 = $2_1 | $30_1; 17663 if (($8_1 & 255) != 2) { 17664 break block30 17665 } 17666 HEAP16[$27_1 + 32 >> 1] = 2; 17667 HEAP32[$27_1 + 40 >> 2] = 1; 17668 HEAP32[$27_1 + 36 >> 2] = 1062719; 17669 $8_1 = $27_1 + 32 | 0; 17670 break block31; 17671 } 17672 $28_1 = $27_1 + 80 | 0; 17673 $22_1 = $27_1 + 15 | 0; 17674 $8_1 = 0; 17675 $11_1 = 0; 17676 $1_1 = global$0 - 1312 | 0; 17677 global$0 = $1_1; 17678 block89 : { 17679 block59 : { 17680 block41 : { 17681 block47 : { 17682 block88 : { 17683 block87 : { 17684 block69 : { 17685 block35 : { 17686 block34 : { 17687 block33 : { 17688 block32 : { 17689 $0_1 = $27_1 + 96 | 0; 17690 $10_1 = HEAP32[$0_1 >> 2]; 17691 $13_1 = HEAP32[$0_1 + 4 >> 2]; 17692 if ($10_1 | $13_1) { 17693 $25_1 = HEAP32[$0_1 + 8 >> 2]; 17694 $17_1 = HEAP32[$0_1 + 12 >> 2]; 17695 if (!($25_1 | $17_1)) { 17696 break block32 17697 } 17698 $18_1 = HEAP32[$0_1 + 16 >> 2]; 17699 $15_1 = HEAP32[$0_1 + 20 >> 2]; 17700 if (!($18_1 | $15_1)) { 17701 break block33 17702 } 17703 $4_1 = $13_1 + $15_1 | 0; 17704 $2_1 = $18_1; 17705 $7_1 = $2_1 + $10_1 | 0; 17706 $4_1 = $7_1 >>> 0 < $2_1 >>> 0 ? $4_1 + 1 | 0 : $4_1; 17707 $26_1 = $7_1; 17708 $23_1 = $4_1; 17709 $3_1 = $15_1; 17710 if (($4_1 | 0) == ($3_1 | 0) & $7_1 >>> 0 < $2_1 >>> 0 | $3_1 >>> 0 > $4_1 >>> 0) { 17711 break block34 17712 } 17713 $4_1 = $17_1; 17714 $6_1 = $13_1; 17715 $2_1 = $10_1; 17716 if (($4_1 | 0) == ($6_1 | 0) & $2_1 >>> 0 < $25_1 >>> 0 | $6_1 >>> 0 < $4_1 >>> 0) { 17717 break block35 17718 } 17719 $31_1 = HEAP8[$0_1 + 26 | 0]; 17720 $0_1 = HEAP16[$0_1 + 24 >> 1]; 17721 HEAP32[$1_1 >> 2] = $2_1; 17722 $2_1 = $6_1; 17723 $3_1 = $10_1; 17724 $4_1 = 32; 17725 $5_1 = 0; 17726 if (($4_1 & 63) >>> 0 >= 32) { 17727 $6_1 = 0; 17728 $10_1 = $2_1 >>> $5_1 | 0; 17729 } else { 17730 $6_1 = $2_1 >>> $5_1 | 0; 17731 $10_1 = ((1 << $5_1) - 1 & $2_1) << 32 - $5_1 | $3_1 >>> $5_1; 17732 } 17733 $2_1 = $10_1; 17734 HEAP32[$1_1 + 4 >> 2] = $2_1; 17735 HEAP32[$1_1 + 160 >> 2] = $6_1 | $2_1 ? 2 : 1; 17736 wasm2js_memory_fill($1_1 + 8 | 0, 0, 152); 17737 HEAP32[$1_1 + 164 >> 2] = $25_1; 17738 $6_1 = $17_1; 17739 $2_1 = $25_1; 17740 if (($4_1 & 63) >>> 0 >= 32) { 17741 $3_1 = 0; 17742 $10_1 = $6_1 >>> $5_1 | 0; 17743 } else { 17744 $3_1 = $6_1 >>> $5_1 | 0; 17745 $10_1 = ((1 << $5_1) - 1 & $6_1) << 32 - $5_1 | $2_1 >>> $5_1; 17746 } 17747 $2_1 = $10_1; 17748 HEAP32[$1_1 + 168 >> 2] = $2_1; 17749 HEAP32[$1_1 + 324 >> 2] = $3_1 | $2_1 ? 2 : 1; 17750 wasm2js_memory_fill($1_1 + 172 | 0, 0, 152); 17751 HEAP32[$1_1 + 328 >> 2] = $18_1; 17752 $3_1 = $15_1; 17753 $6_1 = $18_1; 17754 if (($4_1 & 63) >>> 0 >= 32) { 17755 $2_1 = 0; 17756 $10_1 = $3_1 >>> $5_1 | 0; 17757 } else { 17758 $2_1 = $3_1 >>> $5_1 | 0; 17759 $10_1 = ((1 << $5_1) - 1 & $3_1) << 32 - $5_1 | $6_1 >>> $5_1; 17760 } 17761 $3_1 = $10_1; 17762 HEAP32[$1_1 + 332 >> 2] = $3_1; 17763 HEAP32[$1_1 + 488 >> 2] = $2_1 | $3_1 ? 2 : 1; 17764 wasm2js_memory_fill($1_1 + 336 | 0, 0, 152); 17765 wasm2js_memory_fill($1_1 + 496 | 0, 0, 156); 17766 HEAP32[$1_1 + 492 >> 2] = 1; 17767 HEAP32[$1_1 + 652 >> 2] = 1; 17768 $3_1 = $26_1; 17769 $4_1 = 1; 17770 $2_1 = Math_clz32($3_1 - $4_1 | 0) + 32 | 0; 17771 $4_1 = Math_clz32($23_1 - ($3_1 >>> 0 < $4_1 >>> 0) | 0); 17772 $4_1 = ($4_1 | 0) == 32 ? $2_1 : $4_1; 17773 $2_1 = __wasm_i64_mul($0_1 - $4_1 | 0, ($0_1 >> 31) - ($0_1 >>> 0 < $4_1 >>> 0) | 0, 1292913986, 0); 17774 $4_1 = 1142116480; 17775 $7_1 = $2_1 + $4_1 | 0; 17776 $6_1 = i64toi32_i32$HIGH_BITS + 19 | 0; 17777 $6_1 = $4_1 >>> 0 > $7_1 >>> 0 ? $6_1 + 1 | 0 : $6_1; 17778 $5_1 = $7_1; 17779 $4_1 = 32; 17780 $3_1 = 0; 17781 if (($4_1 & 63) >>> 0 >= 32) { 17782 $9_1 = $6_1 >>> $3_1 | 0 17783 } else { 17784 $9_1 = ((1 << $3_1) - 1 & $6_1) << 32 - $3_1 | $5_1 >>> $3_1 17785 } 17786 $12_1 = $9_1 << 16 >> 16; 17787 block36 : { 17788 if (($0_1 | 0) >= 0) { 17789 $139($1_1, $0_1); 17790 $139($1_1 + 164 | 0, $0_1); 17791 $139($1_1 + 328 | 0, $0_1); 17792 break block36; 17793 } 17794 $139($1_1 + 492 | 0, 0 - $0_1 << 16 >> 16); 17795 } 17796 block37 : { 17797 if (($12_1 | 0) < 0) { 17798 $0_1 = 0 - $12_1 & 65535; 17799 $157($1_1, $0_1); 17800 $157($1_1 + 164 | 0, $0_1); 17801 $157($1_1 + 328 | 0, $0_1); 17802 break block37; 17803 } 17804 $157($1_1 + 492 | 0, $9_1 & 32767); 17805 } 17806 wasm2js_memory_copy($1_1 + 1148 | 0, $1_1, 164); 17807 $21_1 = HEAP32[$1_1 + 488 >> 2]; 17808 $0_1 = HEAP32[$1_1 + 1308 >> 2]; 17809 $9_1 = $0_1 >>> 0 < $21_1 >>> 0 ? $21_1 : $0_1; 17810 if ($9_1 >>> 0 > 40) { 17811 break block91 17812 } 17813 block39 : { 17814 if (!$9_1) { 17815 $9_1 = 0; 17816 break block39; 17817 } 17818 block40 : { 17819 if (($9_1 | 0) != 1) { 17820 $2_1 = $9_1 & 1; 17821 $32_1 = $9_1 & 62; 17822 $0_1 = $1_1 + 1148 | 0; 17823 $14_1 = $1_1 + 328 | 0; 17824 while (1) { 17825 $16_1 = HEAP32[$14_1 >> 2]; 17826 $24_1 = $16_1 + HEAP32[$0_1 >> 2] | 0; 17827 $19_1 = $24_1 + ($8_1 & 1) | 0; 17828 HEAP32[$0_1 >> 2] = $19_1; 17829 $8_1 = $0_1 + 4 | 0; 17830 $4_1 = $8_1; 17831 $17_1 = HEAP32[$14_1 + 4 >> 2]; 17832 $8_1 = $17_1 + HEAP32[$8_1 >> 2] | 0; 17833 $24_1 = $8_1 + ($19_1 >>> 0 < $24_1 >>> 0 | $16_1 >>> 0 > $24_1 >>> 0) | 0; 17834 HEAP32[$4_1 >> 2] = $24_1; 17835 $8_1 = $8_1 >>> 0 < $17_1 >>> 0 | $8_1 >>> 0 > $24_1 >>> 0; 17836 $14_1 = $14_1 + 8 | 0; 17837 $0_1 = $0_1 + 8 | 0; 17838 $11_1 = $11_1 + 2 | 0; 17839 if (($11_1 | 0) != ($32_1 | 0)) { 17840 continue 17841 } 17842 break; 17843 }; 17844 if (!$2_1) { 17845 break block40 17846 } 17847 } 17848 $0_1 = $11_1 << 2; 17849 $11_1 = $0_1 + ($1_1 + 1148 | 0) | 0; 17850 $14_1 = HEAP32[$0_1 + ($1_1 + 328 | 0) >> 2]; 17851 $0_1 = $14_1 + HEAP32[$11_1 >> 2] | 0; 17852 $8_1 = $0_1 + $8_1 | 0; 17853 HEAP32[$11_1 >> 2] = $8_1; 17854 $8_1 = $0_1 >>> 0 < $14_1 >>> 0 | $0_1 >>> 0 > $8_1 >>> 0; 17855 } 17856 if (!$8_1) { 17857 break block39 17858 } 17859 if (($9_1 | 0) == 40) { 17860 break block41 17861 } 17862 HEAP32[($1_1 + 1148 | 0) + ($9_1 << 2) >> 2] = 1; 17863 $9_1 = $9_1 + 1 | 0; 17864 } 17865 HEAP32[$1_1 + 1308 >> 2] = $9_1; 17866 $16_1 = HEAP32[$1_1 + 652 >> 2]; 17867 $0_1 = $9_1 >>> 0 > $16_1 >>> 0 ? $9_1 : $16_1; 17868 if ($0_1 >>> 0 >= 41) { 17869 break block42 17870 } 17871 $14_1 = 0; 17872 block43 : { 17873 if (!$0_1) { 17874 break block43 17875 } 17876 $0_1 = $0_1 << 2; 17877 $11_1 = $1_1 + 1144 | 0; 17878 $24_1 = $1_1 + 488 | 0; 17879 while (1) { 17880 $9_1 = HEAP32[$0_1 + $24_1 >> 2]; 17881 $8_1 = HEAP32[$0_1 + $11_1 >> 2]; 17882 if (($9_1 | 0) == ($8_1 | 0)) { 17883 $0_1 = $0_1 - 4 | 0; 17884 if ($0_1) { 17885 continue 17886 } 17887 break block43; 17888 } 17889 break; 17890 }; 17891 $14_1 = ($8_1 >>> 0 < $9_1 >>> 0) - ($8_1 >>> 0 > $9_1 >>> 0) | 0; 17892 } 17893 block55 : { 17894 if (($14_1 | 0) >= ($31_1 | 0)) { 17895 block44 : { 17896 block48 : { 17897 block46 : { 17898 block45 : { 17899 $8_1 = HEAP32[$1_1 + 160 >> 2]; 17900 if ($8_1 >>> 0 <= 40) { 17901 if (!$8_1) { 17902 $8_1 = 0; 17903 break block44; 17904 } 17905 $11_1 = $8_1 << 2; 17906 $0_1 = $11_1 - 4 | 0; 17907 $14_1 = ($0_1 >>> 2 | 0) + 1 | 0; 17908 $9_1 = $14_1 & 3; 17909 if ($0_1 >>> 0 >= 12) { 17910 break block45 17911 } 17912 $10_1 = 0; 17913 $13_1 = 0; 17914 $0_1 = $1_1; 17915 break block46; 17916 } 17917 break block47; 17918 } 17919 $14_1 = $14_1 & 2147483644; 17920 $10_1 = 0; 17921 $13_1 = 0; 17922 $0_1 = $1_1; 17923 while (1) { 17924 $4_1 = $10_1; 17925 $3_1 = __wasm_i64_mul(HEAP32[$0_1 >> 2], 0, 10, 0) + $4_1 | 0; 17926 $7_1 = $13_1 + i64toi32_i32$HIGH_BITS | 0; 17927 HEAP32[$0_1 >> 2] = $3_1; 17928 $24_1 = $0_1 + 4 | 0; 17929 $17_1 = $24_1; 17930 $10_1 = __wasm_i64_mul(HEAP32[$17_1 >> 2], 0, 10, 0); 17931 $15_1 = i64toi32_i32$HIGH_BITS; 17932 $6_1 = $3_1 >>> 0 < $4_1 >>> 0 ? $7_1 + 1 | 0 : $7_1; 17933 $5_1 = $3_1; 17934 $4_1 = 32; 17935 $2_1 = 0; 17936 if (($4_1 & 63) >>> 0 >= 32) { 17937 $7_1 = 0; 17938 $4_1 = $6_1 >>> $2_1 | 0; 17939 } else { 17940 $7_1 = $6_1 >>> $2_1 | 0; 17941 $4_1 = ((1 << $2_1) - 1 & $6_1) << 32 - $2_1 | $5_1 >>> $2_1; 17942 } 17943 $2_1 = $10_1 + $4_1 | 0; 17944 $3_1 = $7_1 + $15_1 | 0; 17945 HEAP32[$17_1 >> 2] = $2_1; 17946 $24_1 = $0_1 + 8 | 0; 17947 $17_1 = $24_1; 17948 $10_1 = __wasm_i64_mul(HEAP32[$17_1 >> 2], 0, 10, 0); 17949 $15_1 = i64toi32_i32$HIGH_BITS; 17950 $6_1 = $2_1 >>> 0 < $4_1 >>> 0 ? $3_1 + 1 | 0 : $3_1; 17951 $7_1 = $2_1; 17952 $4_1 = 32; 17953 $5_1 = 0; 17954 if (($4_1 & 63) >>> 0 >= 32) { 17955 $3_1 = 0; 17956 $4_1 = $6_1 >>> $5_1 | 0; 17957 } else { 17958 $3_1 = $6_1 >>> $5_1 | 0; 17959 $4_1 = ((1 << $5_1) - 1 & $6_1) << 32 - $5_1 | $7_1 >>> $5_1; 17960 } 17961 $5_1 = $10_1 + $4_1 | 0; 17962 $2_1 = $3_1 + $15_1 | 0; 17963 HEAP32[$17_1 >> 2] = $5_1; 17964 $24_1 = $0_1 + 12 | 0; 17965 $17_1 = $24_1; 17966 $10_1 = __wasm_i64_mul(HEAP32[$17_1 >> 2], 0, 10, 0); 17967 $15_1 = i64toi32_i32$HIGH_BITS; 17968 $6_1 = $5_1 >>> 0 < $4_1 >>> 0 ? $2_1 + 1 | 0 : $2_1; 17969 $3_1 = $5_1; 17970 $4_1 = 32; 17971 $7_1 = 0; 17972 if (($4_1 & 63) >>> 0 >= 32) { 17973 $2_1 = 0; 17974 $4_1 = $6_1 >>> $7_1 | 0; 17975 } else { 17976 $2_1 = $6_1 >>> $7_1 | 0; 17977 $4_1 = ((1 << $7_1) - 1 & $6_1) << 32 - $7_1 | $3_1 >>> $7_1; 17978 } 17979 $7_1 = $10_1 + $4_1 | 0; 17980 $5_1 = $2_1 + $15_1 | 0; 17981 $5_1 = $4_1 >>> 0 > $7_1 >>> 0 ? $5_1 + 1 | 0 : $5_1; 17982 HEAP32[$17_1 >> 2] = $7_1; 17983 $2_1 = $7_1; 17984 $4_1 = 32; 17985 $3_1 = 0; 17986 if (($4_1 & 63) >>> 0 >= 32) { 17987 $6_1 = 0; 17988 $10_1 = $5_1 >>> $3_1 | 0; 17989 } else { 17990 $6_1 = $5_1 >>> $3_1 | 0; 17991 $10_1 = ((1 << $3_1) - 1 & $5_1) << 32 - $3_1 | $2_1 >>> $3_1; 17992 } 17993 $13_1 = $6_1; 17994 $0_1 = $0_1 + 16 | 0; 17995 $14_1 = $14_1 - 4 | 0; 17996 if ($14_1) { 17997 continue 17998 } 17999 break; 18000 }; 18001 if (!$9_1) { 18002 break block48 18003 } 18004 } 18005 $14_1 = $9_1 << 2; 18006 while (1) { 18007 $4_1 = $10_1; 18008 $3_1 = __wasm_i64_mul(HEAP32[$0_1 >> 2], 0, 10, 0) + $4_1 | 0; 18009 $7_1 = i64toi32_i32$HIGH_BITS + $13_1 | 0; 18010 $7_1 = $3_1 >>> 0 < $4_1 >>> 0 ? $7_1 + 1 | 0 : $7_1; 18011 HEAP32[$0_1 >> 2] = $3_1; 18012 $0_1 = $0_1 + 4 | 0; 18013 $2_1 = $3_1; 18014 $4_1 = 32; 18015 $6_1 = 0; 18016 if (($4_1 & 63) >>> 0 >= 32) { 18017 $5_1 = 0; 18018 $10_1 = $7_1 >>> $6_1 | 0; 18019 } else { 18020 $5_1 = $7_1 >>> $6_1 | 0; 18021 $10_1 = ((1 << $6_1) - 1 & $7_1) << 32 - $6_1 | $2_1 >>> $6_1; 18022 } 18023 $13_1 = $5_1; 18024 $14_1 = $14_1 - 4 | 0; 18025 if ($14_1) { 18026 continue 18027 } 18028 break; 18029 }; 18030 } 18031 if (!($10_1 | $13_1)) { 18032 break block44 18033 } 18034 if (($8_1 | 0) == 40) { 18035 break block41 18036 } 18037 HEAP32[$1_1 + $11_1 >> 2] = $10_1; 18038 $8_1 = $8_1 + 1 | 0; 18039 } 18040 HEAP32[$1_1 + 160 >> 2] = $8_1; 18041 block49 : { 18042 block52 : { 18043 block51 : { 18044 block50 : { 18045 $9_1 = HEAP32[$1_1 + 324 >> 2]; 18046 if ($9_1 >>> 0 <= 40) { 18047 $0_1 = 0; 18048 if (!$9_1) { 18049 break block49 18050 } 18051 $11_1 = $9_1 << 2; 18052 $0_1 = $11_1 - 4 | 0; 18053 $14_1 = ($0_1 >>> 2 | 0) + 1 | 0; 18054 $8_1 = $14_1 & 3; 18055 if ($0_1 >>> 0 >= 12) { 18056 break block50 18057 } 18058 $10_1 = 0; 18059 $13_1 = 0; 18060 $0_1 = $1_1 + 164 | 0; 18061 break block51; 18062 } 18063 break block91; 18064 } 18065 $14_1 = $14_1 & 2147483644; 18066 $10_1 = 0; 18067 $13_1 = 0; 18068 $0_1 = $1_1 + 164 | 0; 18069 while (1) { 18070 $4_1 = $10_1; 18071 $6_1 = __wasm_i64_mul(HEAP32[$0_1 >> 2], 0, 10, 0) + $4_1 | 0; 18072 $3_1 = i64toi32_i32$HIGH_BITS + $13_1 | 0; 18073 HEAP32[$0_1 >> 2] = $6_1; 18074 $24_1 = $0_1 + 4 | 0; 18075 $17_1 = $24_1; 18076 $10_1 = __wasm_i64_mul(HEAP32[$17_1 >> 2], 0, 10, 0); 18077 $15_1 = i64toi32_i32$HIGH_BITS; 18078 $7_1 = $6_1 >>> 0 < $4_1 >>> 0 ? $3_1 + 1 | 0 : $3_1; 18079 $2_1 = $6_1; 18080 $4_1 = 32; 18081 $5_1 = 0; 18082 if (($4_1 & 63) >>> 0 >= 32) { 18083 $3_1 = 0; 18084 $4_1 = $7_1 >>> $5_1 | 0; 18085 } else { 18086 $3_1 = $7_1 >>> $5_1 | 0; 18087 $4_1 = ((1 << $5_1) - 1 & $7_1) << 32 - $5_1 | $2_1 >>> $5_1; 18088 } 18089 $6_1 = $3_1 + $15_1 | 0; 18090 $5_1 = $4_1 + $10_1 | 0; 18091 $6_1 = $5_1 >>> 0 < $4_1 >>> 0 ? $6_1 + 1 | 0 : $6_1; 18092 HEAP32[$17_1 >> 2] = $5_1; 18093 $24_1 = $0_1 + 8 | 0; 18094 $17_1 = $24_1; 18095 $10_1 = __wasm_i64_mul(HEAP32[$17_1 >> 2], 0, 10, 0); 18096 $15_1 = i64toi32_i32$HIGH_BITS; 18097 $7_1 = $6_1; 18098 $3_1 = $5_1; 18099 $4_1 = 32; 18100 $2_1 = 0; 18101 if (($4_1 & 63) >>> 0 >= 32) { 18102 $6_1 = 0; 18103 $4_1 = $7_1 >>> $2_1 | 0; 18104 } else { 18105 $6_1 = $7_1 >>> $2_1 | 0; 18106 $4_1 = ((1 << $2_1) - 1 & $7_1) << 32 - $2_1 | $3_1 >>> $2_1; 18107 } 18108 $5_1 = $6_1 + $15_1 | 0; 18109 $2_1 = $4_1 + $10_1 | 0; 18110 $5_1 = $2_1 >>> 0 < $4_1 >>> 0 ? $5_1 + 1 | 0 : $5_1; 18111 HEAP32[$17_1 >> 2] = $2_1; 18112 $24_1 = $0_1 + 12 | 0; 18113 $17_1 = $24_1; 18114 $10_1 = __wasm_i64_mul(HEAP32[$17_1 >> 2], 0, 10, 0); 18115 $15_1 = i64toi32_i32$HIGH_BITS; 18116 $7_1 = $5_1; 18117 $6_1 = $2_1; 18118 $4_1 = 32; 18119 $3_1 = 0; 18120 if (($4_1 & 63) >>> 0 >= 32) { 18121 $5_1 = 0; 18122 $4_1 = $7_1 >>> $3_1 | 0; 18123 } else { 18124 $5_1 = $7_1 >>> $3_1 | 0; 18125 $4_1 = ((1 << $3_1) - 1 & $7_1) << 32 - $3_1 | $6_1 >>> $3_1; 18126 } 18127 $2_1 = $5_1 + $15_1 | 0; 18128 $3_1 = $4_1 + $10_1 | 0; 18129 $2_1 = $3_1 >>> 0 < $4_1 >>> 0 ? $2_1 + 1 | 0 : $2_1; 18130 HEAP32[$17_1 >> 2] = $3_1; 18131 $5_1 = $3_1; 18132 $4_1 = 32; 18133 $6_1 = 0; 18134 if (($4_1 & 63) >>> 0 >= 32) { 18135 $7_1 = 0; 18136 $10_1 = $2_1 >>> $6_1 | 0; 18137 } else { 18138 $7_1 = $2_1 >>> $6_1 | 0; 18139 $10_1 = ((1 << $6_1) - 1 & $2_1) << 32 - $6_1 | $5_1 >>> $6_1; 18140 } 18141 $13_1 = $7_1; 18142 $0_1 = $0_1 + 16 | 0; 18143 $14_1 = $14_1 - 4 | 0; 18144 if ($14_1) { 18145 continue 18146 } 18147 break; 18148 }; 18149 if (!$8_1) { 18150 break block52 18151 } 18152 } 18153 $14_1 = $8_1 << 2; 18154 while (1) { 18155 $4_1 = $10_1; 18156 $6_1 = __wasm_i64_mul(HEAP32[$0_1 >> 2], 0, 10, 0) + $4_1 | 0; 18157 $3_1 = $13_1 + i64toi32_i32$HIGH_BITS | 0; 18158 $3_1 = $6_1 >>> 0 < $4_1 >>> 0 ? $3_1 + 1 | 0 : $3_1; 18159 HEAP32[$0_1 >> 2] = $6_1; 18160 $0_1 = $0_1 + 4 | 0; 18161 $5_1 = $6_1; 18162 $4_1 = 32; 18163 $7_1 = 0; 18164 if (($4_1 & 63) >>> 0 >= 32) { 18165 $2_1 = 0; 18166 $10_1 = $3_1 >>> $7_1 | 0; 18167 } else { 18168 $2_1 = $3_1 >>> $7_1 | 0; 18169 $10_1 = ((1 << $7_1) - 1 & $3_1) << 32 - $7_1 | $5_1 >>> $7_1; 18170 } 18171 $13_1 = $2_1; 18172 $14_1 = $14_1 - 4 | 0; 18173 if ($14_1) { 18174 continue 18175 } 18176 break; 18177 }; 18178 } 18179 $0_1 = $9_1; 18180 if (!($10_1 | $13_1)) { 18181 break block49 18182 } 18183 if (($0_1 | 0) == 40) { 18184 break block41 18185 } 18186 HEAP32[$11_1 + ($1_1 + 164 | 0) >> 2] = $10_1; 18187 $0_1 = $0_1 + 1 | 0; 18188 } 18189 HEAP32[$1_1 + 324 >> 2] = $0_1; 18190 if ($21_1) { 18191 $8_1 = $21_1 << 2; 18192 $0_1 = $8_1 - 4 | 0; 18193 $11_1 = ($0_1 >>> 2 | 0) + 1 | 0; 18194 $9_1 = $11_1 & 3; 18195 block54 : { 18196 block53 : { 18197 if ($0_1 >>> 0 < 12) { 18198 $10_1 = 0; 18199 $13_1 = 0; 18200 $0_1 = $1_1 + 328 | 0; 18201 break block53; 18202 } 18203 $14_1 = $11_1 & 2147483644; 18204 $10_1 = 0; 18205 $13_1 = 0; 18206 $0_1 = $1_1 + 328 | 0; 18207 while (1) { 18208 $4_1 = $10_1; 18209 $7_1 = __wasm_i64_mul(HEAP32[$0_1 >> 2], 0, 10, 0) + $4_1 | 0; 18210 $6_1 = $13_1 + i64toi32_i32$HIGH_BITS | 0; 18211 HEAP32[$0_1 >> 2] = $7_1; 18212 $11_1 = $0_1 + 4 | 0; 18213 $17_1 = $11_1; 18214 $10_1 = __wasm_i64_mul(HEAP32[$11_1 >> 2], 0, 10, 0); 18215 $15_1 = i64toi32_i32$HIGH_BITS; 18216 $3_1 = $4_1 >>> 0 > $7_1 >>> 0 ? $6_1 + 1 | 0 : $6_1; 18217 $5_1 = $7_1; 18218 $4_1 = 32; 18219 $2_1 = 0; 18220 if (($4_1 & 63) >>> 0 >= 32) { 18221 $6_1 = 0; 18222 $4_1 = $3_1 >>> $2_1 | 0; 18223 } else { 18224 $6_1 = $3_1 >>> $2_1 | 0; 18225 $4_1 = ((1 << $2_1) - 1 & $3_1) << 32 - $2_1 | $5_1 >>> $2_1; 18226 } 18227 $2_1 = $10_1 + $4_1 | 0; 18228 $7_1 = $6_1 + $15_1 | 0; 18229 HEAP32[$17_1 >> 2] = $2_1; 18230 $11_1 = $0_1 + 8 | 0; 18231 $17_1 = $11_1; 18232 $10_1 = __wasm_i64_mul(HEAP32[$11_1 >> 2], 0, 10, 0); 18233 $15_1 = i64toi32_i32$HIGH_BITS; 18234 $3_1 = $2_1 >>> 0 < $4_1 >>> 0 ? $7_1 + 1 | 0 : $7_1; 18235 $6_1 = $2_1; 18236 $4_1 = 32; 18237 $5_1 = 0; 18238 if (($4_1 & 63) >>> 0 >= 32) { 18239 $7_1 = 0; 18240 $4_1 = $3_1 >>> $5_1 | 0; 18241 } else { 18242 $7_1 = $3_1 >>> $5_1 | 0; 18243 $4_1 = ((1 << $5_1) - 1 & $3_1) << 32 - $5_1 | $6_1 >>> $5_1; 18244 } 18245 $2_1 = $7_1 + $15_1 | 0; 18246 $5_1 = $4_1 + $10_1 | 0; 18247 $2_1 = $5_1 >>> 0 < $4_1 >>> 0 ? $2_1 + 1 | 0 : $2_1; 18248 HEAP32[$17_1 >> 2] = $5_1; 18249 $11_1 = $0_1 + 12 | 0; 18250 $17_1 = $11_1; 18251 $10_1 = __wasm_i64_mul(HEAP32[$11_1 >> 2], 0, 10, 0); 18252 $15_1 = i64toi32_i32$HIGH_BITS; 18253 $3_1 = $2_1; 18254 $7_1 = $5_1; 18255 $4_1 = 32; 18256 $6_1 = 0; 18257 if (($4_1 & 63) >>> 0 >= 32) { 18258 $2_1 = 0; 18259 $4_1 = $3_1 >>> $6_1 | 0; 18260 } else { 18261 $2_1 = $3_1 >>> $6_1 | 0; 18262 $4_1 = ((1 << $6_1) - 1 & $3_1) << 32 - $6_1 | $7_1 >>> $6_1; 18263 } 18264 $6_1 = $10_1 + $4_1 | 0; 18265 $5_1 = $2_1 + $15_1 | 0; 18266 $5_1 = $6_1 >>> 0 < $4_1 >>> 0 ? $5_1 + 1 | 0 : $5_1; 18267 HEAP32[$17_1 >> 2] = $6_1; 18268 $2_1 = $6_1; 18269 $4_1 = 32; 18270 $7_1 = 0; 18271 if (($4_1 & 63) >>> 0 >= 32) { 18272 $3_1 = 0; 18273 $10_1 = $5_1 >>> $7_1 | 0; 18274 } else { 18275 $3_1 = $5_1 >>> $7_1 | 0; 18276 $10_1 = ((1 << $7_1) - 1 & $5_1) << 32 - $7_1 | $2_1 >>> $7_1; 18277 } 18278 $13_1 = $3_1; 18279 $0_1 = $0_1 + 16 | 0; 18280 $14_1 = $14_1 - 4 | 0; 18281 if ($14_1) { 18282 continue 18283 } 18284 break; 18285 }; 18286 if (!$9_1) { 18287 break block54 18288 } 18289 } 18290 $14_1 = $9_1 << 2; 18291 while (1) { 18292 $4_1 = $10_1; 18293 $7_1 = __wasm_i64_mul(HEAP32[$0_1 >> 2], 0, 10, 0) + $4_1 | 0; 18294 $6_1 = i64toi32_i32$HIGH_BITS + $13_1 | 0; 18295 $6_1 = $4_1 >>> 0 > $7_1 >>> 0 ? $6_1 + 1 | 0 : $6_1; 18296 HEAP32[$0_1 >> 2] = $7_1; 18297 $0_1 = $0_1 + 4 | 0; 18298 $2_1 = $7_1; 18299 $4_1 = 32; 18300 $3_1 = 0; 18301 if (($4_1 & 63) >>> 0 >= 32) { 18302 $5_1 = 0; 18303 $10_1 = $6_1 >>> $3_1 | 0; 18304 } else { 18305 $5_1 = $6_1 >>> $3_1 | 0; 18306 $10_1 = ((1 << $3_1) - 1 & $6_1) << 32 - $3_1 | $2_1 >>> $3_1; 18307 } 18308 $13_1 = $5_1; 18309 $14_1 = $14_1 - 4 | 0; 18310 if ($14_1) { 18311 continue 18312 } 18313 break; 18314 }; 18315 } 18316 if (!($10_1 | $13_1)) { 18317 HEAP32[$1_1 + 488 >> 2] = $21_1; 18318 break block55; 18319 } 18320 if (($21_1 | 0) == 40) { 18321 break block41 18322 } 18323 HEAP32[$8_1 + ($1_1 + 328 | 0) >> 2] = $10_1; 18324 $0_1 = $21_1 + 1 | 0; 18325 } else { 18326 $0_1 = 0 18327 } 18328 HEAP32[$1_1 + 488 >> 2] = $0_1; 18329 break block55; 18330 } 18331 $12_1 = $12_1 + 1 | 0; 18332 } 18333 $9_1 = $1_1 + 656 | 0; 18334 $0_1 = $1_1 + 492 | 0; 18335 wasm2js_memory_copy($9_1, $0_1, 164); 18336 $26_1 = $139($9_1, 1); 18337 $9_1 = $1_1 + 820 | 0; 18338 wasm2js_memory_copy($9_1, $0_1, 164); 18339 $35_1 = $139($9_1, 2); 18340 $9_1 = $1_1 + 984 | 0; 18341 wasm2js_memory_copy($9_1, $0_1, 164); 18342 block85 : { 18343 block75 : { 18344 block74 : { 18345 $38_1 = $139($9_1, 3); 18346 $17_1 = HEAP32[$38_1 + 160 >> 2]; 18347 $11_1 = HEAP32[$1_1 + 160 >> 2]; 18348 $9_1 = $11_1 >>> 0 < $17_1 >>> 0 ? $17_1 : $11_1; 18349 if ($9_1 >>> 0 <= 40) { 18350 $45_1 = $1_1 + 1144 | 0; 18351 $36_1 = $1_1 + 160 | 0; 18352 $33_1 = $1_1 + 488 | 0; 18353 $44_1 = $1_1 + 652 | 0; 18354 $42_1 = $1_1 + 816 | 0; 18355 $43_1 = $1_1 + 980 | 0; 18356 $19_1 = $1_1 - 4 | 0; 18357 $37_1 = HEAP32[$26_1 + 160 >> 2]; 18358 $40_1 = HEAP32[$35_1 + 160 >> 2]; 18359 $8_1 = 0; 18360 while (1) { 18361 $21_1 = $8_1; 18362 block57 : { 18363 block56 : { 18364 if (!$9_1) { 18365 break block56 18366 } 18367 $0_1 = $9_1 << 2; 18368 while (1) { 18369 $8_1 = HEAP32[$0_1 + $19_1 >> 2]; 18370 $14_1 = HEAP32[$0_1 + $43_1 >> 2]; 18371 if (($8_1 | 0) == ($14_1 | 0)) { 18372 $0_1 = $0_1 - 4 | 0; 18373 if ($0_1) { 18374 continue 18375 } 18376 break block56; 18377 } 18378 break; 18379 }; 18380 $32_1 = 0; 18381 if ($8_1 >>> 0 < $14_1 >>> 0) { 18382 break block57 18383 } 18384 } 18385 if ($9_1) { 18386 $11_1 = 1; 18387 $14_1 = 0; 18388 block58 : { 18389 if (($9_1 | 0) != 1) { 18390 $2_1 = $9_1 & 1; 18391 $32_1 = $9_1 & 62; 18392 $0_1 = $1_1; 18393 $20_1 = $0_1 + 984 | 0; 18394 while (1) { 18395 $15_1 = HEAP32[$0_1 >> 2]; 18396 $8_1 = $15_1 + (HEAP32[$20_1 >> 2] ^ -1) | 0; 18397 $23_1 = $8_1 + ($11_1 & 1) | 0; 18398 HEAP32[$0_1 >> 2] = $23_1; 18399 $11_1 = $0_1 + 4 | 0; 18400 $4_1 = $11_1; 18401 $18_1 = HEAP32[$11_1 >> 2]; 18402 $11_1 = $18_1 + (HEAP32[$20_1 + 4 >> 2] ^ -1) | 0; 18403 $8_1 = $11_1 + ($8_1 >>> 0 < $15_1 >>> 0 | $8_1 >>> 0 > $23_1 >>> 0) | 0; 18404 HEAP32[$4_1 >> 2] = $8_1; 18405 $11_1 = $8_1 >>> 0 < $11_1 >>> 0 | $11_1 >>> 0 < $18_1 >>> 0; 18406 $20_1 = $20_1 + 8 | 0; 18407 $0_1 = $0_1 + 8 | 0; 18408 $14_1 = $14_1 + 2 | 0; 18409 if (($14_1 | 0) != ($32_1 | 0)) { 18410 continue 18411 } 18412 break; 18413 }; 18414 if (!$2_1) { 18415 break block58 18416 } 18417 } 18418 $0_1 = $14_1 << 2; 18419 $8_1 = $0_1 + $1_1 | 0; 18420 $2_1 = $8_1; 18421 $8_1 = HEAP32[$8_1 >> 2]; 18422 $0_1 = $8_1 + (HEAP32[$0_1 + $38_1 >> 2] ^ -1) | 0; 18423 $11_1 = $0_1 + $11_1 | 0; 18424 HEAP32[$2_1 >> 2] = $11_1; 18425 $11_1 = $0_1 >>> 0 < $8_1 >>> 0 | $0_1 >>> 0 > $11_1 >>> 0; 18426 } 18427 if (!$11_1) { 18428 break block59 18429 } 18430 } 18431 HEAP32[$1_1 + 160 >> 2] = $9_1; 18432 $11_1 = $9_1; 18433 $32_1 = 8; 18434 } 18435 $9_1 = $11_1 >>> 0 < $40_1 >>> 0 ? $40_1 : $11_1; 18436 if ($9_1 >>> 0 >= 41) { 18437 break block91 18438 } 18439 block61 : { 18440 block60 : { 18441 if (!$9_1) { 18442 break block60 18443 } 18444 $0_1 = $9_1 << 2; 18445 while (1) { 18446 $8_1 = HEAP32[$0_1 + $19_1 >> 2]; 18447 $14_1 = HEAP32[$0_1 + $42_1 >> 2]; 18448 if (($8_1 | 0) == ($14_1 | 0)) { 18449 $0_1 = $0_1 - 4 | 0; 18450 if ($0_1) { 18451 continue 18452 } 18453 break block60; 18454 } 18455 break; 18456 }; 18457 if ($8_1 >>> 0 >= $14_1 >>> 0) { 18458 break block60 18459 } 18460 $9_1 = $11_1; 18461 break block61; 18462 } 18463 if ($9_1) { 18464 $11_1 = 1; 18465 $14_1 = 0; 18466 block62 : { 18467 if (($9_1 | 0) != 1) { 18468 $2_1 = $9_1 & 1; 18469 $15_1 = $9_1 & 62; 18470 $0_1 = $1_1; 18471 $20_1 = $0_1 + 820 | 0; 18472 while (1) { 18473 $23_1 = HEAP32[$0_1 >> 2]; 18474 $8_1 = $23_1 + (HEAP32[$20_1 >> 2] ^ -1) | 0; 18475 $18_1 = $8_1 + ($11_1 & 1) | 0; 18476 HEAP32[$0_1 >> 2] = $18_1; 18477 $11_1 = $0_1 + 4 | 0; 18478 $4_1 = $11_1; 18479 $25_1 = HEAP32[$11_1 >> 2]; 18480 $11_1 = $25_1 + (HEAP32[$20_1 + 4 >> 2] ^ -1) | 0; 18481 $8_1 = $11_1 + ($8_1 >>> 0 < $23_1 >>> 0 | $8_1 >>> 0 > $18_1 >>> 0) | 0; 18482 HEAP32[$4_1 >> 2] = $8_1; 18483 $11_1 = $8_1 >>> 0 < $11_1 >>> 0 | $11_1 >>> 0 < $25_1 >>> 0; 18484 $20_1 = $20_1 + 8 | 0; 18485 $0_1 = $0_1 + 8 | 0; 18486 $14_1 = $14_1 + 2 | 0; 18487 if (($14_1 | 0) != ($15_1 | 0)) { 18488 continue 18489 } 18490 break; 18491 }; 18492 if (!$2_1) { 18493 break block62 18494 } 18495 } 18496 $0_1 = $14_1 << 2; 18497 $8_1 = $0_1 + $1_1 | 0; 18498 $2_1 = $8_1; 18499 $8_1 = HEAP32[$8_1 >> 2]; 18500 $0_1 = $8_1 + (HEAP32[$0_1 + $35_1 >> 2] ^ -1) | 0; 18501 $11_1 = $0_1 + $11_1 | 0; 18502 HEAP32[$2_1 >> 2] = $11_1; 18503 $11_1 = $0_1 >>> 0 < $8_1 >>> 0 | $0_1 >>> 0 > $11_1 >>> 0; 18504 } 18505 if (!$11_1) { 18506 break block59 18507 } 18508 } 18509 HEAP32[$1_1 + 160 >> 2] = $9_1; 18510 $32_1 = $32_1 | 4; 18511 } 18512 $8_1 = $9_1 >>> 0 < $37_1 >>> 0 ? $37_1 : $9_1; 18513 if ($8_1 >>> 0 >= 41) { 18514 break block47 18515 } 18516 block64 : { 18517 block63 : { 18518 if (!$8_1) { 18519 break block63 18520 } 18521 $0_1 = $8_1 << 2; 18522 while (1) { 18523 $11_1 = HEAP32[$0_1 + $19_1 >> 2]; 18524 $14_1 = HEAP32[$0_1 + $44_1 >> 2]; 18525 if (($11_1 | 0) == ($14_1 | 0)) { 18526 $0_1 = $0_1 - 4 | 0; 18527 if ($0_1) { 18528 continue 18529 } 18530 break block63; 18531 } 18532 break; 18533 }; 18534 if ($11_1 >>> 0 >= $14_1 >>> 0) { 18535 break block63 18536 } 18537 $8_1 = $9_1; 18538 break block64; 18539 } 18540 if ($8_1) { 18541 $11_1 = 1; 18542 $14_1 = 0; 18543 block65 : { 18544 if (($8_1 | 0) != 1) { 18545 $2_1 = $8_1 & 1; 18546 $15_1 = $8_1 & 62; 18547 $0_1 = $1_1; 18548 $20_1 = $0_1 + 656 | 0; 18549 while (1) { 18550 $23_1 = HEAP32[$0_1 >> 2]; 18551 $9_1 = $23_1 + (HEAP32[$20_1 >> 2] ^ -1) | 0; 18552 $18_1 = $9_1 + ($11_1 & 1) | 0; 18553 HEAP32[$0_1 >> 2] = $18_1; 18554 $11_1 = $0_1 + 4 | 0; 18555 $4_1 = $11_1; 18556 $25_1 = HEAP32[$11_1 >> 2]; 18557 $11_1 = $25_1 + (HEAP32[$20_1 + 4 >> 2] ^ -1) | 0; 18558 $9_1 = $11_1 + ($9_1 >>> 0 < $23_1 >>> 0 | $9_1 >>> 0 > $18_1 >>> 0) | 0; 18559 HEAP32[$4_1 >> 2] = $9_1; 18560 $11_1 = $9_1 >>> 0 < $11_1 >>> 0 | $11_1 >>> 0 < $25_1 >>> 0; 18561 $20_1 = $20_1 + 8 | 0; 18562 $0_1 = $0_1 + 8 | 0; 18563 $14_1 = $14_1 + 2 | 0; 18564 if (($14_1 | 0) != ($15_1 | 0)) { 18565 continue 18566 } 18567 break; 18568 }; 18569 if (!$2_1) { 18570 break block65 18571 } 18572 } 18573 $0_1 = $14_1 << 2; 18574 $9_1 = $0_1 + $1_1 | 0; 18575 $2_1 = $9_1; 18576 $9_1 = HEAP32[$9_1 >> 2]; 18577 $0_1 = $9_1 + (HEAP32[$0_1 + $26_1 >> 2] ^ -1) | 0; 18578 $11_1 = $0_1 + $11_1 | 0; 18579 HEAP32[$2_1 >> 2] = $11_1; 18580 $11_1 = $0_1 >>> 0 < $9_1 >>> 0 | $0_1 >>> 0 > $11_1 >>> 0; 18581 } 18582 if (!$11_1) { 18583 break block59 18584 } 18585 } 18586 HEAP32[$1_1 + 160 >> 2] = $8_1; 18587 $32_1 = $32_1 + 2 | 0; 18588 } 18589 $9_1 = $8_1 >>> 0 < $16_1 >>> 0 ? $16_1 : $8_1; 18590 if ($9_1 >>> 0 >= 41) { 18591 break block91 18592 } 18593 block67 : { 18594 block66 : { 18595 if (!$9_1) { 18596 break block66 18597 } 18598 $0_1 = $9_1 << 2; 18599 while (1) { 18600 $11_1 = HEAP32[$0_1 + $19_1 >> 2]; 18601 $14_1 = HEAP32[$0_1 + $33_1 >> 2]; 18602 if (($11_1 | 0) == ($14_1 | 0)) { 18603 $0_1 = $0_1 - 4 | 0; 18604 if ($0_1) { 18605 continue 18606 } 18607 break block66; 18608 } 18609 break; 18610 }; 18611 if ($11_1 >>> 0 >= $14_1 >>> 0) { 18612 break block66 18613 } 18614 $9_1 = $8_1; 18615 break block67; 18616 } 18617 if ($9_1) { 18618 $11_1 = 1; 18619 $14_1 = 0; 18620 block68 : { 18621 if (($9_1 | 0) != 1) { 18622 $2_1 = $9_1 & 1; 18623 $15_1 = $9_1 & 62; 18624 $0_1 = $1_1; 18625 $20_1 = $0_1 + 492 | 0; 18626 while (1) { 18627 $23_1 = HEAP32[$0_1 >> 2]; 18628 $8_1 = $23_1 + (HEAP32[$20_1 >> 2] ^ -1) | 0; 18629 $18_1 = $8_1 + ($11_1 & 1) | 0; 18630 HEAP32[$0_1 >> 2] = $18_1; 18631 $11_1 = $0_1 + 4 | 0; 18632 $4_1 = $11_1; 18633 $25_1 = HEAP32[$11_1 >> 2]; 18634 $11_1 = $25_1 + (HEAP32[$20_1 + 4 >> 2] ^ -1) | 0; 18635 $8_1 = $11_1 + ($8_1 >>> 0 < $23_1 >>> 0 | $8_1 >>> 0 > $18_1 >>> 0) | 0; 18636 HEAP32[$4_1 >> 2] = $8_1; 18637 $11_1 = $8_1 >>> 0 < $11_1 >>> 0 | $11_1 >>> 0 < $25_1 >>> 0; 18638 $20_1 = $20_1 + 8 | 0; 18639 $0_1 = $0_1 + 8 | 0; 18640 $14_1 = $14_1 + 2 | 0; 18641 if (($14_1 | 0) != ($15_1 | 0)) { 18642 continue 18643 } 18644 break; 18645 }; 18646 if (!$2_1) { 18647 break block68 18648 } 18649 } 18650 $0_1 = $14_1 << 2; 18651 $8_1 = $0_1 + $1_1 | 0; 18652 $2_1 = $8_1; 18653 $8_1 = HEAP32[$8_1 >> 2]; 18654 $0_1 = $8_1 + (HEAP32[$0_1 + ($1_1 + 492 | 0) >> 2] ^ -1) | 0; 18655 $11_1 = $0_1 + $11_1 | 0; 18656 HEAP32[$2_1 >> 2] = $11_1; 18657 $11_1 = $0_1 >>> 0 < $8_1 >>> 0 | $0_1 >>> 0 > $11_1 >>> 0; 18658 } 18659 if (!$11_1) { 18660 break block59 18661 } 18662 } 18663 HEAP32[$1_1 + 160 >> 2] = $9_1; 18664 $32_1 = $32_1 + 1 | 0; 18665 } 18666 if (($21_1 | 0) == 17) { 18667 break block69 18668 } 18669 HEAP8[$22_1 + $21_1 | 0] = $32_1 + 48; 18670 $24_1 = HEAP32[$1_1 + 324 >> 2]; 18671 $0_1 = $9_1 >>> 0 < $24_1 >>> 0 ? $24_1 : $9_1; 18672 if ($0_1 >>> 0 >= 41) { 18673 break block42 18674 } 18675 $15_1 = 0; 18676 block70 : { 18677 if (!$0_1) { 18678 break block70 18679 } 18680 $0_1 = $0_1 << 2; 18681 while (1) { 18682 $8_1 = HEAP32[$0_1 + $19_1 >> 2]; 18683 $11_1 = HEAP32[$0_1 + $36_1 >> 2]; 18684 if (($8_1 | 0) == ($11_1 | 0)) { 18685 $0_1 = $0_1 - 4 | 0; 18686 if ($0_1) { 18687 continue 18688 } 18689 break block70; 18690 } 18691 break; 18692 }; 18693 $15_1 = ($8_1 >>> 0 > $11_1 >>> 0) - ($8_1 >>> 0 < $11_1 >>> 0) | 0; 18694 } 18695 wasm2js_memory_copy($1_1 + 1148 | 0, $1_1, 164); 18696 $32_1 = HEAP32[$1_1 + 488 >> 2]; 18697 $0_1 = HEAP32[$1_1 + 1308 >> 2]; 18698 $8_1 = $0_1 >>> 0 < $32_1 >>> 0 ? $32_1 : $0_1; 18699 if ($8_1 >>> 0 > 40) { 18700 break block47 18701 } 18702 block71 : { 18703 if (!$8_1) { 18704 $8_1 = 0; 18705 break block71; 18706 } 18707 $11_1 = 0; 18708 $14_1 = 0; 18709 block72 : { 18710 if (($8_1 | 0) != 1) { 18711 $13_1 = $8_1 & 1; 18712 $25_1 = $8_1 & 62; 18713 $0_1 = $1_1 + 1148 | 0; 18714 $20_1 = $1_1 + 328 | 0; 18715 while (1) { 18716 $6_1 = HEAP32[$20_1 >> 2]; 18717 $23_1 = $6_1 + HEAP32[$0_1 >> 2] | 0; 18718 $2_1 = $23_1 + ($11_1 & 1) | 0; 18719 HEAP32[$0_1 >> 2] = $2_1; 18720 $11_1 = $0_1 + 4 | 0; 18721 $4_1 = $11_1; 18722 $3_1 = HEAP32[$20_1 + 4 >> 2]; 18723 $11_1 = $3_1 + HEAP32[$11_1 >> 2] | 0; 18724 $23_1 = $11_1 + ($2_1 >>> 0 < $23_1 >>> 0 | $6_1 >>> 0 > $23_1 >>> 0) | 0; 18725 HEAP32[$4_1 >> 2] = $23_1; 18726 $11_1 = $3_1 >>> 0 > $11_1 >>> 0 | $11_1 >>> 0 > $23_1 >>> 0; 18727 $20_1 = $20_1 + 8 | 0; 18728 $0_1 = $0_1 + 8 | 0; 18729 $14_1 = $14_1 + 2 | 0; 18730 if (($14_1 | 0) != ($25_1 | 0)) { 18731 continue 18732 } 18733 break; 18734 }; 18735 if (!$13_1) { 18736 break block72 18737 } 18738 } 18739 $0_1 = $14_1 << 2; 18740 $14_1 = $0_1 + ($1_1 + 1148 | 0) | 0; 18741 $20_1 = HEAP32[$0_1 + ($1_1 + 328 | 0) >> 2]; 18742 $0_1 = $20_1 + HEAP32[$14_1 >> 2] | 0; 18743 $11_1 = $0_1 + $11_1 | 0; 18744 HEAP32[$14_1 >> 2] = $11_1; 18745 $11_1 = $0_1 >>> 0 < $20_1 >>> 0 | $0_1 >>> 0 > $11_1 >>> 0; 18746 } 18747 if (!$11_1) { 18748 break block71 18749 } 18750 if (($8_1 | 0) == 40) { 18751 break block41 18752 } 18753 HEAP32[($1_1 + 1148 | 0) + ($8_1 << 2) >> 2] = 1; 18754 $8_1 = $8_1 + 1 | 0; 18755 } 18756 HEAP32[$1_1 + 1308 >> 2] = $8_1; 18757 $0_1 = $8_1 >>> 0 > $16_1 >>> 0 ? $8_1 : $16_1; 18758 if ($0_1 >>> 0 >= 41) { 18759 break block42 18760 } 18761 $11_1 = 0; 18762 block73 : { 18763 if (!$0_1) { 18764 break block73 18765 } 18766 $0_1 = $0_1 << 2; 18767 while (1) { 18768 $8_1 = HEAP32[$0_1 + $33_1 >> 2]; 18769 $14_1 = HEAP32[$0_1 + $45_1 >> 2]; 18770 if (($8_1 | 0) == ($14_1 | 0)) { 18771 $0_1 = $0_1 - 4 | 0; 18772 if ($0_1) { 18773 continue 18774 } 18775 break block73; 18776 } 18777 break; 18778 }; 18779 $11_1 = ($8_1 >>> 0 > $14_1 >>> 0) - ($8_1 >>> 0 < $14_1 >>> 0) | 0; 18780 } 18781 $8_1 = $21_1 + 1 | 0; 18782 if (($15_1 | 0) < ($31_1 | 0)) { 18783 break block74 18784 } 18785 if (($11_1 | 0) < ($31_1 | 0)) { 18786 break block75 18787 } 18788 $14_1 = 0; 18789 $11_1 = 0; 18790 block76 : { 18791 if (!$9_1) { 18792 break block76 18793 } 18794 $21_1 = $9_1 << 2; 18795 $0_1 = $21_1 - 4 | 0; 18796 $20_1 = ($0_1 >>> 2 | 0) + 1 | 0; 18797 $11_1 = $20_1 & 3; 18798 block78 : { 18799 block77 : { 18800 if ($0_1 >>> 0 < 12) { 18801 $10_1 = 0; 18802 $13_1 = 0; 18803 $0_1 = $1_1; 18804 break block77; 18805 } 18806 $20_1 = $20_1 & 2147483644; 18807 $10_1 = 0; 18808 $13_1 = 0; 18809 $0_1 = $1_1; 18810 while (1) { 18811 $4_1 = $10_1; 18812 $3_1 = __wasm_i64_mul(HEAP32[$0_1 >> 2], 0, 10, 0) + $4_1 | 0; 18813 $7_1 = i64toi32_i32$HIGH_BITS + $13_1 | 0; 18814 HEAP32[$0_1 >> 2] = $3_1; 18815 $15_1 = $0_1 + 4 | 0; 18816 $23_1 = $15_1; 18817 $10_1 = __wasm_i64_mul(HEAP32[$15_1 >> 2], 0, 10, 0); 18818 $15_1 = i64toi32_i32$HIGH_BITS; 18819 $6_1 = $3_1 >>> 0 < $4_1 >>> 0 ? $7_1 + 1 | 0 : $7_1; 18820 $2_1 = $3_1; 18821 $4_1 = 32; 18822 $5_1 = 0; 18823 if (($4_1 & 63) >>> 0 >= 32) { 18824 $7_1 = 0; 18825 $4_1 = $6_1 >>> $5_1 | 0; 18826 } else { 18827 $7_1 = $6_1 >>> $5_1 | 0; 18828 $4_1 = ((1 << $5_1) - 1 & $6_1) << 32 - $5_1 | $2_1 >>> $5_1; 18829 } 18830 $3_1 = $7_1 + $15_1 | 0; 18831 $5_1 = $4_1 + $10_1 | 0; 18832 $3_1 = $5_1 >>> 0 < $4_1 >>> 0 ? $3_1 + 1 | 0 : $3_1; 18833 HEAP32[$23_1 >> 2] = $5_1; 18834 $15_1 = $0_1 + 8 | 0; 18835 $23_1 = $15_1; 18836 $10_1 = __wasm_i64_mul(HEAP32[$15_1 >> 2], 0, 10, 0); 18837 $15_1 = i64toi32_i32$HIGH_BITS; 18838 $6_1 = $3_1; 18839 $7_1 = $5_1; 18840 $4_1 = 32; 18841 $2_1 = 0; 18842 if (($4_1 & 63) >>> 0 >= 32) { 18843 $3_1 = 0; 18844 $4_1 = $6_1 >>> $2_1 | 0; 18845 } else { 18846 $3_1 = $6_1 >>> $2_1 | 0; 18847 $4_1 = ((1 << $2_1) - 1 & $6_1) << 32 - $2_1 | $7_1 >>> $2_1; 18848 } 18849 $2_1 = $10_1 + $4_1 | 0; 18850 $5_1 = $3_1 + $15_1 | 0; 18851 HEAP32[$23_1 >> 2] = $2_1; 18852 $15_1 = $0_1 + 12 | 0; 18853 $23_1 = $15_1; 18854 $10_1 = __wasm_i64_mul(HEAP32[$15_1 >> 2], 0, 10, 0); 18855 $15_1 = i64toi32_i32$HIGH_BITS; 18856 $6_1 = $2_1 >>> 0 < $4_1 >>> 0 ? $5_1 + 1 | 0 : $5_1; 18857 $3_1 = $2_1; 18858 $4_1 = 32; 18859 $7_1 = 0; 18860 if (($4_1 & 63) >>> 0 >= 32) { 18861 $5_1 = 0; 18862 $4_1 = $6_1 >>> $7_1 | 0; 18863 } else { 18864 $5_1 = $6_1 >>> $7_1 | 0; 18865 $4_1 = ((1 << $7_1) - 1 & $6_1) << 32 - $7_1 | $3_1 >>> $7_1; 18866 } 18867 $2_1 = $5_1 + $15_1 | 0; 18868 $7_1 = $4_1 + $10_1 | 0; 18869 $2_1 = $7_1 >>> 0 < $4_1 >>> 0 ? $2_1 + 1 | 0 : $2_1; 18870 HEAP32[$23_1 >> 2] = $7_1; 18871 $5_1 = $7_1; 18872 $4_1 = 32; 18873 $3_1 = 0; 18874 if (($4_1 & 63) >>> 0 >= 32) { 18875 $6_1 = 0; 18876 $10_1 = $2_1 >>> $3_1 | 0; 18877 } else { 18878 $6_1 = $2_1 >>> $3_1 | 0; 18879 $10_1 = ((1 << $3_1) - 1 & $2_1) << 32 - $3_1 | $5_1 >>> $3_1; 18880 } 18881 $13_1 = $6_1; 18882 $0_1 = $0_1 + 16 | 0; 18883 $20_1 = $20_1 - 4 | 0; 18884 if ($20_1) { 18885 continue 18886 } 18887 break; 18888 }; 18889 if (!$11_1) { 18890 break block78 18891 } 18892 } 18893 $20_1 = $11_1 << 2; 18894 while (1) { 18895 $4_1 = $10_1; 18896 $3_1 = __wasm_i64_mul(HEAP32[$0_1 >> 2], 0, 10, 0) + $4_1 | 0; 18897 $7_1 = $13_1 + i64toi32_i32$HIGH_BITS | 0; 18898 $7_1 = $3_1 >>> 0 < $4_1 >>> 0 ? $7_1 + 1 | 0 : $7_1; 18899 HEAP32[$0_1 >> 2] = $3_1; 18900 $0_1 = $0_1 + 4 | 0; 18901 $5_1 = $3_1; 18902 $4_1 = 32; 18903 $6_1 = 0; 18904 if (($4_1 & 63) >>> 0 >= 32) { 18905 $2_1 = 0; 18906 $10_1 = $7_1 >>> $6_1 | 0; 18907 } else { 18908 $2_1 = $7_1 >>> $6_1 | 0; 18909 $10_1 = ((1 << $6_1) - 1 & $7_1) << 32 - $6_1 | $5_1 >>> $6_1; 18910 } 18911 $13_1 = $2_1; 18912 $20_1 = $20_1 - 4 | 0; 18913 if ($20_1) { 18914 continue 18915 } 18916 break; 18917 }; 18918 } 18919 $11_1 = $9_1; 18920 if (!($10_1 | $13_1)) { 18921 break block76 18922 } 18923 if (($9_1 | 0) == 40) { 18924 break block41 18925 } 18926 HEAP32[$1_1 + $21_1 >> 2] = $10_1; 18927 $11_1 = $9_1 + 1 | 0; 18928 } 18929 HEAP32[$1_1 + 160 >> 2] = $11_1; 18930 block79 : { 18931 if (!$24_1) { 18932 break block79 18933 } 18934 $21_1 = $24_1 << 2; 18935 $0_1 = $21_1 - 4 | 0; 18936 $14_1 = ($0_1 >>> 2 | 0) + 1 | 0; 18937 $9_1 = $14_1 & 3; 18938 block81 : { 18939 block80 : { 18940 if ($0_1 >>> 0 < 12) { 18941 $10_1 = 0; 18942 $13_1 = 0; 18943 $0_1 = $1_1 + 164 | 0; 18944 break block80; 18945 } 18946 $20_1 = $14_1 & 2147483644; 18947 $10_1 = 0; 18948 $13_1 = 0; 18949 $0_1 = $1_1 + 164 | 0; 18950 while (1) { 18951 $4_1 = $10_1; 18952 $6_1 = __wasm_i64_mul(HEAP32[$0_1 >> 2], 0, 10, 0) + $4_1 | 0; 18953 $3_1 = $13_1 + i64toi32_i32$HIGH_BITS | 0; 18954 HEAP32[$0_1 >> 2] = $6_1; 18955 $14_1 = $0_1 + 4 | 0; 18956 $23_1 = $14_1; 18957 $10_1 = __wasm_i64_mul(HEAP32[$14_1 >> 2], 0, 10, 0); 18958 $15_1 = i64toi32_i32$HIGH_BITS; 18959 $7_1 = $6_1 >>> 0 < $4_1 >>> 0 ? $3_1 + 1 | 0 : $3_1; 18960 $5_1 = $6_1; 18961 $4_1 = 32; 18962 $2_1 = 0; 18963 if (($4_1 & 63) >>> 0 >= 32) { 18964 $3_1 = 0; 18965 $4_1 = $7_1 >>> $2_1 | 0; 18966 } else { 18967 $3_1 = $7_1 >>> $2_1 | 0; 18968 $4_1 = ((1 << $2_1) - 1 & $7_1) << 32 - $2_1 | $5_1 >>> $2_1; 18969 } 18970 $2_1 = $10_1 + $4_1 | 0; 18971 $6_1 = $3_1 + $15_1 | 0; 18972 HEAP32[$23_1 >> 2] = $2_1; 18973 $14_1 = $0_1 + 8 | 0; 18974 $23_1 = $14_1; 18975 $10_1 = __wasm_i64_mul(HEAP32[$14_1 >> 2], 0, 10, 0); 18976 $15_1 = i64toi32_i32$HIGH_BITS; 18977 $7_1 = $2_1 >>> 0 < $4_1 >>> 0 ? $6_1 + 1 | 0 : $6_1; 18978 $3_1 = $2_1; 18979 $4_1 = 32; 18980 $5_1 = 0; 18981 if (($4_1 & 63) >>> 0 >= 32) { 18982 $6_1 = 0; 18983 $4_1 = $7_1 >>> $5_1 | 0; 18984 } else { 18985 $6_1 = $7_1 >>> $5_1 | 0; 18986 $4_1 = ((1 << $5_1) - 1 & $7_1) << 32 - $5_1 | $3_1 >>> $5_1; 18987 } 18988 $2_1 = $6_1 + $15_1 | 0; 18989 $5_1 = $4_1 + $10_1 | 0; 18990 $2_1 = $5_1 >>> 0 < $4_1 >>> 0 ? $2_1 + 1 | 0 : $2_1; 18991 HEAP32[$23_1 >> 2] = $5_1; 18992 $14_1 = $0_1 + 12 | 0; 18993 $23_1 = $14_1; 18994 $10_1 = __wasm_i64_mul(HEAP32[$14_1 >> 2], 0, 10, 0); 18995 $15_1 = i64toi32_i32$HIGH_BITS; 18996 $7_1 = $2_1; 18997 $6_1 = $5_1; 18998 $4_1 = 32; 18999 $3_1 = 0; 19000 if (($4_1 & 63) >>> 0 >= 32) { 19001 $2_1 = 0; 19002 $4_1 = $7_1 >>> $3_1 | 0; 19003 } else { 19004 $2_1 = $7_1 >>> $3_1 | 0; 19005 $4_1 = ((1 << $3_1) - 1 & $7_1) << 32 - $3_1 | $6_1 >>> $3_1; 19006 } 19007 $3_1 = $10_1 + $4_1 | 0; 19008 $5_1 = $2_1 + $15_1 | 0; 19009 $5_1 = $3_1 >>> 0 < $4_1 >>> 0 ? $5_1 + 1 | 0 : $5_1; 19010 HEAP32[$23_1 >> 2] = $3_1; 19011 $2_1 = $3_1; 19012 $4_1 = 32; 19013 $6_1 = 0; 19014 if (($4_1 & 63) >>> 0 >= 32) { 19015 $7_1 = 0; 19016 $10_1 = $5_1 >>> $6_1 | 0; 19017 } else { 19018 $7_1 = $5_1 >>> $6_1 | 0; 19019 $10_1 = ((1 << $6_1) - 1 & $5_1) << 32 - $6_1 | $2_1 >>> $6_1; 19020 } 19021 $13_1 = $7_1; 19022 $0_1 = $0_1 + 16 | 0; 19023 $20_1 = $20_1 - 4 | 0; 19024 if ($20_1) { 19025 continue 19026 } 19027 break; 19028 }; 19029 if (!$9_1) { 19030 break block81 19031 } 19032 } 19033 $20_1 = $9_1 << 2; 19034 while (1) { 19035 $4_1 = $10_1; 19036 $6_1 = __wasm_i64_mul(HEAP32[$0_1 >> 2], 0, 10, 0) + $4_1 | 0; 19037 $3_1 = i64toi32_i32$HIGH_BITS + $13_1 | 0; 19038 $3_1 = $6_1 >>> 0 < $4_1 >>> 0 ? $3_1 + 1 | 0 : $3_1; 19039 HEAP32[$0_1 >> 2] = $6_1; 19040 $0_1 = $0_1 + 4 | 0; 19041 $2_1 = $6_1; 19042 $4_1 = 32; 19043 $7_1 = 0; 19044 if (($4_1 & 63) >>> 0 >= 32) { 19045 $5_1 = 0; 19046 $10_1 = $3_1 >>> $7_1 | 0; 19047 } else { 19048 $5_1 = $3_1 >>> $7_1 | 0; 19049 $10_1 = ((1 << $7_1) - 1 & $3_1) << 32 - $7_1 | $2_1 >>> $7_1; 19050 } 19051 $13_1 = $5_1; 19052 $20_1 = $20_1 - 4 | 0; 19053 if ($20_1) { 19054 continue 19055 } 19056 break; 19057 }; 19058 } 19059 if (!($10_1 | $13_1)) { 19060 $14_1 = $24_1; 19061 break block79; 19062 } 19063 if (($24_1 | 0) == 40) { 19064 break block41 19065 } 19066 HEAP32[$21_1 + ($1_1 + 164 | 0) >> 2] = $10_1; 19067 $14_1 = $24_1 + 1 | 0; 19068 } 19069 HEAP32[$1_1 + 324 >> 2] = $14_1; 19070 block82 : { 19071 if (!$32_1) { 19072 $32_1 = 0; 19073 break block82; 19074 } 19075 $21_1 = $32_1 << 2; 19076 $0_1 = $21_1 - 4 | 0; 19077 $14_1 = ($0_1 >>> 2 | 0) + 1 | 0; 19078 $9_1 = $14_1 & 3; 19079 block84 : { 19080 block83 : { 19081 if ($0_1 >>> 0 < 12) { 19082 $10_1 = 0; 19083 $13_1 = 0; 19084 $0_1 = $1_1 + 328 | 0; 19085 break block83; 19086 } 19087 $20_1 = $14_1 & 2147483644; 19088 $10_1 = 0; 19089 $13_1 = 0; 19090 $0_1 = $1_1 + 328 | 0; 19091 while (1) { 19092 $4_1 = $10_1; 19093 $7_1 = __wasm_i64_mul(HEAP32[$0_1 >> 2], 0, 10, 0) + $4_1 | 0; 19094 $6_1 = i64toi32_i32$HIGH_BITS + $13_1 | 0; 19095 HEAP32[$0_1 >> 2] = $7_1; 19096 $14_1 = $0_1 + 4 | 0; 19097 $23_1 = $14_1; 19098 $10_1 = __wasm_i64_mul(HEAP32[$14_1 >> 2], 0, 10, 0); 19099 $15_1 = i64toi32_i32$HIGH_BITS; 19100 $3_1 = $4_1 >>> 0 > $7_1 >>> 0 ? $6_1 + 1 | 0 : $6_1; 19101 $2_1 = $7_1; 19102 $4_1 = 32; 19103 $5_1 = 0; 19104 if (($4_1 & 63) >>> 0 >= 32) { 19105 $6_1 = 0; 19106 $4_1 = $3_1 >>> $5_1 | 0; 19107 } else { 19108 $6_1 = $3_1 >>> $5_1 | 0; 19109 $4_1 = ((1 << $5_1) - 1 & $3_1) << 32 - $5_1 | $2_1 >>> $5_1; 19110 } 19111 $7_1 = $6_1 + $15_1 | 0; 19112 $5_1 = $4_1 + $10_1 | 0; 19113 $7_1 = $5_1 >>> 0 < $4_1 >>> 0 ? $7_1 + 1 | 0 : $7_1; 19114 HEAP32[$23_1 >> 2] = $5_1; 19115 $14_1 = $0_1 + 8 | 0; 19116 $23_1 = $14_1; 19117 $10_1 = __wasm_i64_mul(HEAP32[$14_1 >> 2], 0, 10, 0); 19118 $15_1 = i64toi32_i32$HIGH_BITS; 19119 $3_1 = $7_1; 19120 $6_1 = $5_1; 19121 $4_1 = 32; 19122 $2_1 = 0; 19123 if (($4_1 & 63) >>> 0 >= 32) { 19124 $7_1 = 0; 19125 $4_1 = $3_1 >>> $2_1 | 0; 19126 } else { 19127 $7_1 = $3_1 >>> $2_1 | 0; 19128 $4_1 = ((1 << $2_1) - 1 & $3_1) << 32 - $2_1 | $6_1 >>> $2_1; 19129 } 19130 $5_1 = $7_1 + $15_1 | 0; 19131 $2_1 = $4_1 + $10_1 | 0; 19132 $5_1 = $2_1 >>> 0 < $4_1 >>> 0 ? $5_1 + 1 | 0 : $5_1; 19133 HEAP32[$23_1 >> 2] = $2_1; 19134 $14_1 = $0_1 + 12 | 0; 19135 $23_1 = $14_1; 19136 $10_1 = __wasm_i64_mul(HEAP32[$14_1 >> 2], 0, 10, 0); 19137 $15_1 = i64toi32_i32$HIGH_BITS; 19138 $3_1 = $5_1; 19139 $7_1 = $2_1; 19140 $4_1 = 32; 19141 $6_1 = 0; 19142 if (($4_1 & 63) >>> 0 >= 32) { 19143 $5_1 = 0; 19144 $4_1 = $3_1 >>> $6_1 | 0; 19145 } else { 19146 $5_1 = $3_1 >>> $6_1 | 0; 19147 $4_1 = ((1 << $6_1) - 1 & $3_1) << 32 - $6_1 | $7_1 >>> $6_1; 19148 } 19149 $2_1 = $5_1 + $15_1 | 0; 19150 $6_1 = $4_1 + $10_1 | 0; 19151 $2_1 = $6_1 >>> 0 < $4_1 >>> 0 ? $2_1 + 1 | 0 : $2_1; 19152 HEAP32[$23_1 >> 2] = $6_1; 19153 $5_1 = $6_1; 19154 $4_1 = 32; 19155 $7_1 = 0; 19156 if (($4_1 & 63) >>> 0 >= 32) { 19157 $3_1 = 0; 19158 $10_1 = $2_1 >>> $7_1 | 0; 19159 } else { 19160 $3_1 = $2_1 >>> $7_1 | 0; 19161 $10_1 = ((1 << $7_1) - 1 & $2_1) << 32 - $7_1 | $5_1 >>> $7_1; 19162 } 19163 $13_1 = $3_1; 19164 $0_1 = $0_1 + 16 | 0; 19165 $20_1 = $20_1 - 4 | 0; 19166 if ($20_1) { 19167 continue 19168 } 19169 break; 19170 }; 19171 if (!$9_1) { 19172 break block84 19173 } 19174 } 19175 $20_1 = $9_1 << 2; 19176 while (1) { 19177 $4_1 = $10_1; 19178 $7_1 = __wasm_i64_mul(HEAP32[$0_1 >> 2], 0, 10, 0) + $4_1 | 0; 19179 $6_1 = $13_1 + i64toi32_i32$HIGH_BITS | 0; 19180 $6_1 = $4_1 >>> 0 > $7_1 >>> 0 ? $6_1 + 1 | 0 : $6_1; 19181 HEAP32[$0_1 >> 2] = $7_1; 19182 $0_1 = $0_1 + 4 | 0; 19183 $5_1 = $7_1; 19184 $4_1 = 32; 19185 $3_1 = 0; 19186 if (($4_1 & 63) >>> 0 >= 32) { 19187 $2_1 = 0; 19188 $10_1 = $6_1 >>> $3_1 | 0; 19189 } else { 19190 $2_1 = $6_1 >>> $3_1 | 0; 19191 $10_1 = ((1 << $3_1) - 1 & $6_1) << 32 - $3_1 | $5_1 >>> $3_1; 19192 } 19193 $13_1 = $2_1; 19194 $20_1 = $20_1 - 4 | 0; 19195 if ($20_1) { 19196 continue 19197 } 19198 break; 19199 }; 19200 } 19201 if (!($10_1 | $13_1)) { 19202 break block82 19203 } 19204 if (($32_1 | 0) == 40) { 19205 break block41 19206 } 19207 HEAP32[$21_1 + ($1_1 + 328 | 0) >> 2] = $10_1; 19208 $32_1 = $32_1 + 1 | 0; 19209 } 19210 HEAP32[$1_1 + 488 >> 2] = $32_1; 19211 $9_1 = $11_1 >>> 0 < $17_1 >>> 0 ? $17_1 : $11_1; 19212 if ($9_1 >>> 0 < 41) { 19213 continue 19214 } 19215 break; 19216 }; 19217 } 19218 break block91; 19219 } 19220 if (($11_1 | 0) >= ($31_1 | 0)) { 19221 break block85 19222 } 19223 $139($1_1, 1); 19224 $0_1 = HEAP32[$1_1 + 160 >> 2]; 19225 $0_1 = $0_1 >>> 0 < $16_1 >>> 0 ? $16_1 : $0_1; 19226 if ($0_1 >>> 0 >= 41) { 19227 break block42 19228 } 19229 if (!$0_1) { 19230 break block75 19231 } 19232 $0_1 = $0_1 << 2; 19233 $9_1 = $1_1 + 488 | 0; 19234 $11_1 = $1_1 - 4 | 0; 19235 while (1) { 19236 $14_1 = HEAP32[$0_1 + $11_1 >> 2]; 19237 $24_1 = HEAP32[$0_1 + $9_1 >> 2]; 19238 if (($14_1 | 0) == ($24_1 | 0)) { 19239 $0_1 = $0_1 - 4 | 0; 19240 if ($0_1) { 19241 continue 19242 } 19243 break block75; 19244 } 19245 break; 19246 }; 19247 if ($14_1 >>> 0 < $24_1 >>> 0) { 19248 break block85 19249 } 19250 } 19251 $2_1 = $8_1 + $22_1 | 0; 19252 $14_1 = 0; 19253 $0_1 = $21_1; 19254 block86 : { 19255 while (1) { 19256 $9_1 = $0_1 + $22_1 | 0; 19257 if (HEAPU8[$9_1 | 0] == 57) { 19258 $14_1 = $14_1 + 1 | 0; 19259 $0_1 = $0_1 - 1 | 0; 19260 if (($0_1 | 0) != -1) { 19261 continue 19262 } 19263 break block86; 19264 } 19265 break; 19266 }; 19267 HEAP8[$9_1 | 0] = HEAPU8[$9_1 | 0] + 1; 19268 if (!$14_1) { 19269 break block85 19270 } 19271 wasm2js_memory_fill($9_1 + 1 | 0, 48, $14_1); 19272 break block85; 19273 } 19274 HEAP8[$22_1 | 0] = 49; 19275 if ($21_1) { 19276 wasm2js_memory_fill($22_1 + 1 | 0, 48, $21_1) 19277 } 19278 if ($8_1 >>> 0 >= 17) { 19279 break block87 19280 } 19281 HEAP8[$2_1 | 0] = 48; 19282 $12_1 = $12_1 + 1 | 0; 19283 $8_1 = $21_1 + 2 | 0; 19284 } 19285 if ($8_1 >>> 0 <= 17) { 19286 break block88 19287 } 19288 $135(0, $8_1, 17, 1067052); 19289 wasm2js_trap(); 19290 } 19291 $129(1066240, 28, 1066956); 19292 wasm2js_trap(); 19293 } 19294 $129(1066432, 29, 1066972); 19295 wasm2js_trap(); 19296 } 19297 $129(1066480, 28, 1066988); 19298 wasm2js_trap(); 19299 } 19300 $129(1066724, 54, 1067084); 19301 wasm2js_trap(); 19302 } 19303 $129(1066652, 55, 1067068); 19304 wasm2js_trap(); 19305 } 19306 $137(17, 17, 1067020); 19307 wasm2js_trap(); 19308 } 19309 $137($8_1, 17, 1067036); 19310 wasm2js_trap(); 19311 } 19312 HEAP16[$28_1 + 8 >> 1] = $12_1; 19313 HEAP32[$28_1 + 4 >> 2] = $8_1; 19314 HEAP32[$28_1 >> 2] = $22_1; 19315 global$0 = $1_1 + 1312 | 0; 19316 break block89; 19317 } 19318 $135(0, $8_1, 40, 1062848); 19319 wasm2js_trap(); 19320 } 19321 $137(40, 40, 1062848); 19322 wasm2js_trap(); 19323 } 19324 $129(1062819, 26, 1062848); 19325 wasm2js_trap(); 19326 } 19327 } 19328 $1_1 = $30_1 ? $39_1 : $34_1; 19329 $9_1 = $30_1 | $41_1; 19330 $130($27_1, HEAP32[$27_1 + 80 >> 2], HEAP32[$27_1 + 84 >> 2], HEAPU16[$27_1 + 88 >> 1], 0, $27_1 + 32 | 0); 19331 $0_1 = HEAP32[$27_1 + 4 >> 2]; 19332 $8_1 = HEAP32[$27_1 >> 2]; 19333 break block31; 19334 } 19335 HEAP32[$27_1 + 40 >> 2] = 3; 19336 HEAP32[$27_1 + 36 >> 2] = 1062713; 19337 HEAP16[$27_1 + 32 >> 1] = 2; 19338 $1_1 = 1; 19339 $9_1 = 0; 19340 $0_1 = 1; 19341 $8_1 = $27_1 + 32 | 0; 19342 break block31; 19343 } 19344 HEAP32[$27_1 + 40 >> 2] = 3; 19345 HEAP32[$27_1 + 36 >> 2] = 1062716; 19346 HEAP16[$27_1 + 32 >> 1] = 2; 19347 $8_1 = $27_1 + 32 | 0; 19348 } 19349 HEAP32[$27_1 + 92 >> 2] = $0_1; 19350 HEAP32[$27_1 + 88 >> 2] = $8_1; 19351 HEAP32[$27_1 + 84 >> 2] = $9_1; 19352 HEAP32[$27_1 + 80 >> 2] = $1_1; 19353 $0_1 = $131($29_1, $27_1 + 80 | 0); 19354 global$0 = $27_1 + 128 | 0; 19355 break block90; 19356 } 19357 return $0_1 | 0; 19358 } 19359 $35_1 = ($9_1 | 0) != 0; 19360 $32_1 = $1_1; 19361 $14_1 = HEAPU16[$1_1 + 14 >> 1]; 19362 $0_1 = 0; 19363 $22_1 = global$0 - 1136 | 0; 19364 global$0 = $22_1; 19365 wasm2js_scratch_store_f64(+$49_1); 19366 $2_1 = wasm2js_scratch_load_i32(1) | 0; 19367 $18_1 = wasm2js_scratch_load_i32(0) | 0; 19368 $34_1 = $18_1; 19369 $1_1 = $18_1; 19370 $15_1 = $2_1; 19371 $5_1 = $2_1 & 1048575; 19372 $33_1 = $5_1; 19373 $13_1 = $5_1 | 1048576; 19374 $6_1 = $2_1; 19375 $5_1 = $1_1; 19376 $4_1 = 1; 19377 $3_1 = 1; 19378 if (($4_1 & 63) >>> 0 >= 32) { 19379 $2_1 = $5_1 << $3_1; 19380 $4_1 = 0; 19381 } else { 19382 $2_1 = (1 << $3_1) - 1 & $5_1 >>> 32 - $3_1 | $6_1 << $3_1; 19383 $4_1 = $5_1 << $3_1; 19384 } 19385 $7_1 = $4_1 & -2; 19386 $6_1 = $2_1 & 2097151; 19387 $5_1 = $15_1; 19388 $2_1 = $18_1; 19389 $4_1 = 52; 19390 $3_1 = 20; 19391 $10_1 = $1_1; 19392 if (($4_1 & 63) >>> 0 >= 32) { 19393 $1_1 = $5_1 >>> $3_1 | 0 19394 } else { 19395 $1_1 = ((1 << $3_1) - 1 & $5_1) << 32 - $3_1 | $2_1 >>> $3_1 19396 } 19397 $1_1 = $1_1 & 2047; 19398 $3_1 = $1_1; 19399 $10_1 = $3_1 ? $10_1 : $7_1; 19400 $2_1 = $10_1; 19401 $5_1 = $3_1 ? $13_1 : $6_1; 19402 $13_1 = $5_1; 19403 $26_1 = $2_1 & 1; 19404 $9_1 = 2; 19405 $8_1 = !($33_1 | $34_1); 19406 $34_1 = 0; 19407 $33_1 = $15_1 & 2146435072; 19408 $2_1 = $34_1 | $33_1 ? 4 : $8_1 ? 2 : 3; 19409 block96 : { 19410 block95 : { 19411 switch ((!$34_1 & ($33_1 | 0) == 2146435072 ? $8_1 : $2_1) - 1 | 0) { 19412 case 0: 19413 $9_1 = 3; 19414 break block96; 19415 case 1: 19416 $9_1 = 4; 19417 break block96; 19418 case 2: 19419 $0_1 = $1_1 - 1075 | 0; 19420 $9_1 = !($23_1 | $26_1); 19421 $25_1 = 1; 19422 break block96; 19423 case 3: 19424 break block95; 19425 default: 19426 break block96; 19427 }; 19428 } 19429 $4_1 = $13_1; 19430 $2_1 = $10_1; 19431 $5_1 = 1; 19432 $6_1 = 1; 19433 if (($5_1 & 63) >>> 0 >= 32) { 19434 $3_1 = $2_1 << $6_1; 19435 $2_1 = 0; 19436 } else { 19437 $3_1 = (1 << $6_1) - 1 & $2_1 >>> 32 - $6_1 | $4_1 << $6_1; 19438 $2_1 = $2_1 << $6_1; 19439 } 19440 $0_1 = !$10_1 & ($13_1 | 0) == 1048576; 19441 $10_1 = $0_1 ? 0 : $2_1; 19442 $13_1 = $0_1 ? 4194304 : $3_1; 19443 $25_1 = $0_1 ? 2 : 1; 19444 $9_1 = !($23_1 | $26_1); 19445 $0_1 = $1_1 + ($0_1 ? -1077 : -1076) | 0; 19446 } 19447 HEAP16[$22_1 + 1128 >> 1] = $0_1; 19448 $3_1 = $22_1; 19449 HEAP32[$3_1 + 1120 >> 2] = $25_1; 19450 HEAP32[$3_1 + 1124 >> 2] = $17_1; 19451 HEAP32[$3_1 + 1112 >> 2] = 1; 19452 HEAP32[$3_1 + 1116 >> 2] = 0; 19453 HEAP32[$3_1 + 1104 >> 2] = $10_1; 19454 HEAP32[$3_1 + 1108 >> 2] = $13_1; 19455 HEAP8[$3_1 + 1130 | 0] = $9_1; 19456 block100 : { 19457 block97 : { 19458 if (($9_1 & 255) >>> 0 <= 1) { 19459 $0_1 = $0_1 << 16 >> 16; 19460 $0_1 = Math_imul(($0_1 | 0) < 0 ? -12 : 5, $0_1); 19461 if ($0_1 >>> 0 < 16064) { 19462 break block97 19463 } 19464 $129(1062722, 37, 1062760); 19465 wasm2js_trap(); 19466 } 19467 block99 : { 19468 block98 : { 19469 $8_1 = $9_1 - 2 | 0; 19470 if ($8_1 & 255) { 19471 $9_1 = 1; 19472 $4_1 = $18_1; 19473 $2_1 = 0; 19474 $6_1 = $15_1; 19475 $3_1 = 0; 19476 if (($6_1 | 0) < ($3_1 | 0)) { 19477 $0_1 = 1 19478 } else { 19479 $0_1 = $2_1 >>> 0 > $4_1 >>> 0 & ($3_1 | 0) >= ($6_1 | 0) 19480 } 19481 $0_1 = $35_1 ? ($0_1 ? 1062711 : 1062712) : $0_1 ? 1062711 : 1; 19482 $4_1 = $15_1; 19483 $2_1 = $18_1; 19484 $3_1 = 63; 19485 $5_1 = 31; 19486 if (($3_1 & 63) >>> 0 >= 32) { 19487 $1_1 = $4_1 >>> $5_1 | 0 19488 } else { 19489 $1_1 = ((1 << $5_1) - 1 & $4_1) << 32 - $5_1 | $2_1 >>> $5_1 19490 } 19491 $1_1 = $1_1 | $35_1; 19492 if (($8_1 & 255) != 2) { 19493 break block98 19494 } 19495 HEAP16[$22_1 + 1040 >> 1] = 2; 19496 if ($14_1) { 19497 break block99 19498 } 19499 HEAP32[$22_1 + 1048 >> 2] = 1; 19500 HEAP32[$22_1 + 1044 >> 2] = 1062719; 19501 $8_1 = $22_1 + 1040 | 0; 19502 break block100; 19503 } 19504 HEAP32[$22_1 + 1048 >> 2] = 3; 19505 HEAP32[$22_1 + 1044 >> 2] = 1062713; 19506 HEAP16[$22_1 + 1040 >> 1] = 2; 19507 $0_1 = 1; 19508 $1_1 = 0; 19509 $9_1 = 1; 19510 $8_1 = $22_1 + 1040 | 0; 19511 break block100; 19512 } 19513 HEAP32[$22_1 + 1048 >> 2] = 3; 19514 HEAP32[$22_1 + 1044 >> 2] = 1062716; 19515 HEAP16[$22_1 + 1040 >> 1] = 2; 19516 $8_1 = $22_1 + 1040 | 0; 19517 break block100; 19518 } 19519 HEAP32[$22_1 + 1056 >> 2] = $14_1; 19520 HEAP16[$22_1 + 1052 >> 1] = 0; 19521 $9_1 = 2; 19522 HEAP32[$22_1 + 1048 >> 2] = 2; 19523 HEAP32[$22_1 + 1044 >> 2] = 1062720; 19524 $8_1 = $22_1 + 1040 | 0; 19525 break block100; 19526 } 19527 $4_1 = $18_1; 19528 $3_1 = 0; 19529 $6_1 = $15_1; 19530 $2_1 = 0; 19531 if (($6_1 | 0) < ($2_1 | 0)) { 19532 $1_1 = 1 19533 } else { 19534 $1_1 = $3_1 >>> 0 > $4_1 >>> 0 & ($2_1 | 0) >= ($6_1 | 0) 19535 } 19536 $38_1 = $1_1 ? 1062711 : 1; 19537 $45_1 = $1_1 ? 1062711 : 1062712; 19538 $4_1 = $15_1; 19539 $3_1 = $18_1; 19540 $2_1 = 63; 19541 $5_1 = 31; 19542 if (($2_1 & 63) >>> 0 >= 32) { 19543 $36_1 = $4_1 >>> $5_1 | 0 19544 } else { 19545 $36_1 = ((1 << $5_1) - 1 & $4_1) << 32 - $5_1 | $3_1 >>> $5_1 19546 } 19547 $20_1 = $22_1 + 1040 | 0; 19548 $27_1 = $22_1 + 16 | 0; 19549 $11_1 = ($0_1 >>> 4 | 0) + 21 | 0; 19550 $24_1 = $14_1 << 16 >> 16 < 0 ? -32768 : 0 - $14_1 | 0; 19551 $16_1 = global$0 - 16 | 0; 19552 global$0 = $16_1; 19553 block108 : { 19554 block104 : { 19555 block106 : { 19556 block105 : { 19557 block103 : { 19558 block102 : { 19559 block101 : { 19560 $0_1 = $22_1 + 1104 | 0; 19561 $10_1 = HEAP32[$0_1 >> 2]; 19562 $13_1 = HEAP32[$0_1 + 4 >> 2]; 19563 if ($10_1 | $13_1) { 19564 $4_1 = $10_1; 19565 $6_1 = 536870912; 19566 $3_1 = $13_1; 19567 if (1 & ($6_1 | 0) == ($3_1 | 0) | $3_1 >>> 0 > $6_1 >>> 0) { 19568 break block101 19569 } 19570 if (!$11_1) { 19571 break block102 19572 } 19573 $6_1 = Math_clz32($3_1); 19574 $18_1 = ($6_1 | 0) == 32 ? Math_clz32($4_1) + 32 | 0 : $6_1; 19575 $9_1 = HEAPU16[$0_1 + 24 >> 1] - $18_1 | 0; 19576 $0_1 = (Math_imul(-96 - $9_1 << 16 >> 16, 80) + 86960 | 0) / 2126 | 0; 19577 if ($0_1 >>> 0 > 80) { 19578 break block103 19579 } 19580 $1_1 = $0_1 << 4; 19581 $3_1 = $1_1; 19582 $7_1 = HEAP32[$3_1 + 1064944 >> 2]; 19583 $17_1 = HEAP32[$3_1 + 1064948 >> 2]; 19584 $4_1 = $13_1; 19585 $3_1 = $10_1; 19586 $6_1 = $18_1; 19587 $5_1 = $6_1 & 31; 19588 if (($6_1 & 63) >>> 0 >= 32) { 19589 $2_1 = $3_1 << $5_1; 19590 $0_1 = 0; 19591 } else { 19592 $2_1 = (1 << $5_1) - 1 & $3_1 >>> 32 - $5_1 | $4_1 << $5_1; 19593 $0_1 = $3_1 << $5_1; 19594 } 19595 $169($16_1, $7_1, $17_1, $0_1, $2_1); 19596 $4_1 = $16_1; 19597 $0_1 = HEAP32[$4_1 + 8 >> 2]; 19598 $13_1 = HEAP32[$4_1 + 12 >> 2]; 19599 $3_1 = HEAP32[$4_1 + 4 >> 2]; 19600 $4_1 = HEAP32[$4_1 >> 2]; 19601 $6_1 = 63; 19602 $5_1 = 31; 19603 if (($6_1 & 63) >>> 0 >= 32) { 19604 $2_1 = 0; 19605 $6_1 = $3_1 >>> $5_1 | 0; 19606 } else { 19607 $2_1 = $3_1 >>> $5_1 | 0; 19608 $6_1 = ((1 << $5_1) - 1 & $3_1) << 32 - $5_1 | $4_1 >>> $5_1; 19609 } 19610 $7_1 = $2_1 + $13_1 | 0; 19611 $5_1 = $0_1 + $6_1 | 0; 19612 $7_1 = $6_1 >>> 0 > $5_1 >>> 0 ? $7_1 + 1 | 0 : $7_1; 19613 $25_1 = $5_1; 19614 $17_1 = $7_1; 19615 $2_1 = $5_1; 19616 $9_1 = -64 - (HEAPU16[$1_1 + 1064952 >> 1] + $9_1 | 0) | 0; 19617 $10_1 = $9_1; 19618 $6_1 = $9_1; 19619 $4_1 = $6_1 & 31; 19620 if (($6_1 & 63) >>> 0 >= 32) { 19621 $0_1 = $7_1 >>> $4_1 | 0 19622 } else { 19623 $0_1 = ((1 << $4_1) - 1 & $7_1) << 32 - $4_1 | $2_1 >>> $4_1 19624 } 19625 $1_1 = HEAPU16[$1_1 + 1064954 >> 1]; 19626 $3_1 = 0; 19627 $7_1 = 1; 19628 $4_1 = $10_1 & 31; 19629 if (($6_1 & 63) >>> 0 >= 32) { 19630 $2_1 = $7_1 << $4_1; 19631 $26_1 = 0; 19632 } else { 19633 $2_1 = (1 << $4_1) - 1 & $7_1 >>> 32 - $4_1 | $3_1 << $4_1; 19634 $26_1 = $7_1 << $4_1; 19635 } 19636 $3_1 = $26_1; 19637 $6_1 = 1; 19638 $34_1 = $3_1 - $6_1 | 0; 19639 $10_1 = $34_1 & $25_1; 19640 $23_1 = $2_1; 19641 $33_1 = $2_1 - ($3_1 >>> 0 < $6_1 >>> 0) | 0; 19642 $13_1 = $17_1 & $33_1; 19643 if (!($10_1 | $13_1)) { 19644 if ($11_1 >>> 0 > 10) { 19645 break block104 19646 } 19647 if ($0_1 >>> 0 < HEAPU32[($11_1 << 2) + 1067096 >> 2]) { 19648 break block104 19649 } 19650 } 19651 $8_1 = $9_1 & 63; 19652 if ($0_1 >>> 0 >= 1e4) { 19653 if ($0_1 >>> 0 < 1e6) { 19654 break block105 19655 } 19656 if ($0_1 >>> 0 >= 1e8) { 19657 $21_1 = $0_1 >>> 0 < 1e9; 19658 $29_1 = $21_1 ? 8 : 9; 19659 $21_1 = $21_1 ? 1e8 : 1e9; 19660 break block106; 19661 } 19662 $21_1 = $0_1 >>> 0 < 1e7; 19663 $29_1 = $21_1 ? 6 : 7; 19664 $21_1 = $21_1 ? 1e6 : 1e7; 19665 break block106; 19666 } 19667 if ($0_1 >>> 0 >= 100) { 19668 $21_1 = $0_1 >>> 0 < 1e3; 19669 $29_1 = $21_1 ? 2 : 3; 19670 $21_1 = $21_1 ? 100 : 1e3; 19671 break block106; 19672 } 19673 $29_1 = $0_1 >>> 0 > 9; 19674 $21_1 = $29_1 ? 10 : 1; 19675 break block106; 19676 } 19677 $129(1066240, 28, 1066268); 19678 wasm2js_trap(); 19679 } 19680 $129(1066284, 36, 1066320); 19681 wasm2js_trap(); 19682 } 19683 $129(1064388, 33, 1066336); 19684 wasm2js_trap(); 19685 } 19686 $137($0_1, 81, 1066352); 19687 wasm2js_trap(); 19688 } 19689 $21_1 = $0_1 >>> 0 < 1e5; 19690 $29_1 = $21_1 ? 4 : 5; 19691 $21_1 = $21_1 ? 1e4 : 1e5; 19692 } 19693 $18_1 = $8_1; 19694 block107 : { 19695 $12_1 = ($29_1 - $1_1 | 0) + 1 << 16 >> 16; 19696 $1_1 = $24_1 << 16 >> 16; 19697 if (($12_1 | 0) > ($1_1 | 0)) { 19698 $30_1 = $9_1 & 65535; 19699 $19_1 = $11_1 >>> 0 > $12_1 - $1_1 >>> 0 ? $12_1 - $24_1 << 16 >> 16 : $11_1; 19700 $31_1 = $19_1 - 1 | 0; 19701 $1_1 = ($0_1 >>> 0) % ($21_1 >>> 0) | 0; 19702 $8_1 = 0; 19703 break block107; 19704 } 19705 $3_1 = 0; 19706 $5_1 = $21_1; 19707 $6_1 = $18_1; 19708 $7_1 = $6_1 & 31; 19709 $1_1 = __wasm_i64_udiv($25_1, $17_1, 10, 0); 19710 $4_1 = i64toi32_i32$HIGH_BITS; 19711 if (($6_1 & 63) >>> 0 >= 32) { 19712 $2_1 = $5_1 << $7_1; 19713 $0_1 = 0; 19714 } else { 19715 $2_1 = (1 << $7_1) - 1 & $5_1 >>> 32 - $7_1 | $3_1 << $7_1; 19716 $0_1 = $5_1 << $7_1; 19717 } 19718 $156($20_1, $27_1, $11_1, 0, $12_1, $24_1, $1_1, $4_1, $0_1, $2_1, $26_1, $23_1); 19719 break block108; 19720 } 19721 block112 : { 19722 block109 : { 19723 block111 : { 19724 block110 : { 19725 while (1) { 19726 $9_1 = $1_1; 19727 HEAP8[$8_1 + $27_1 | 0] = (($0_1 >>> 0) / ($21_1 >>> 0) | 0) + 48; 19728 if (($8_1 | 0) == ($31_1 | 0)) { 19729 break block109 19730 } 19731 if (($8_1 | 0) == ($29_1 | 0)) { 19732 break block110 19733 } 19734 if ($21_1 >>> 0 >= 10) { 19735 $21_1 = ($21_1 >>> 0) / 10 | 0; 19736 $1_1 = ($1_1 >>> 0) % ($21_1 >>> 0) | 0; 19737 $0_1 = $9_1; 19738 $8_1 = $8_1 + 1 | 0; 19739 if (($8_1 | 0) == ($11_1 | 0)) { 19740 break block111 19741 } 19742 continue; 19743 } 19744 break; 19745 }; 19746 $155(1066368); 19747 wasm2js_trap(); 19748 } 19749 $8_1 = $8_1 + 1 | 0; 19750 $28_1 = $30_1 - 1 & 63; 19751 $25_1 = 1; 19752 $17_1 = 0; 19753 while (1) { 19754 $3_1 = $17_1; 19755 $2_1 = $25_1; 19756 $6_1 = $28_1; 19757 $7_1 = $6_1 & 31; 19758 if (($6_1 & 63) >>> 0 >= 32) { 19759 $5_1 = 0; 19760 $0_1 = $3_1 >>> $7_1 | 0; 19761 } else { 19762 $5_1 = $3_1 >>> $7_1 | 0; 19763 $0_1 = ((1 << $7_1) - 1 & $3_1) << 32 - $7_1 | $2_1 >>> $7_1; 19764 } 19765 if ($0_1 | $5_1) { 19766 HEAP32[$20_1 >> 2] = 0; 19767 break block108; 19768 } 19769 if ($8_1 >>> 0 >= $11_1 >>> 0) { 19770 break block112 19771 } 19772 $10_1 = __wasm_i64_mul($10_1, $13_1, 10, 0); 19773 $1_1 = $10_1; 19774 $5_1 = i64toi32_i32$HIGH_BITS; 19775 $13_1 = $5_1; 19776 $3_1 = $1_1; 19777 $6_1 = $18_1; 19778 $7_1 = $6_1 & 31; 19779 $1_1 = $8_1 + $27_1 | 0; 19780 if (($6_1 & 63) >>> 0 >= 32) { 19781 $0_1 = $5_1 >>> $7_1 | 0 19782 } else { 19783 $0_1 = ((1 << $7_1) - 1 & $5_1) << 32 - $7_1 | $3_1 >>> $7_1 19784 } 19785 HEAP8[$1_1 | 0] = $0_1 + 48; 19786 $25_1 = __wasm_i64_mul($25_1, $17_1, 10, 0); 19787 $17_1 = i64toi32_i32$HIGH_BITS; 19788 $10_1 = $10_1 & $34_1; 19789 $13_1 = $13_1 & $33_1; 19790 $8_1 = $8_1 + 1 | 0; 19791 if (($8_1 | 0) != ($19_1 | 0)) { 19792 continue 19793 } 19794 break; 19795 }; 19796 $156($20_1, $27_1, $11_1, $19_1, $12_1, $24_1, $10_1, $13_1, $26_1, $23_1, $25_1, $17_1); 19797 break block108; 19798 } 19799 $137($11_1, $11_1, 1066384); 19800 wasm2js_trap(); 19801 } 19802 $2_1 = 0; 19803 $3_1 = $9_1; 19804 $6_1 = $18_1; 19805 $7_1 = $6_1 & 31; 19806 if (($6_1 & 63) >>> 0 >= 32) { 19807 $5_1 = $3_1 << $7_1; 19808 $2_1 = 0; 19809 } else { 19810 $5_1 = (1 << $7_1) - 1 & $3_1 >>> 32 - $7_1 | $2_1 << $7_1; 19811 $2_1 = $3_1 << $7_1; 19812 } 19813 $4_1 = $5_1 + $13_1 | 0; 19814 $6_1 = $10_1; 19815 $7_1 = $2_1 + $6_1 | 0; 19816 $4_1 = $7_1 >>> 0 < $6_1 >>> 0 ? $4_1 + 1 | 0 : $4_1; 19817 $0_1 = $4_1; 19818 $4_1 = 0; 19819 $5_1 = $21_1; 19820 $6_1 = $18_1; 19821 $3_1 = $6_1 & 31; 19822 if (($6_1 & 63) >>> 0 >= 32) { 19823 $2_1 = $5_1 << $3_1; 19824 $1_1 = 0; 19825 } else { 19826 $2_1 = (1 << $3_1) - 1 & $5_1 >>> 32 - $3_1 | $4_1 << $3_1; 19827 $1_1 = $5_1 << $3_1; 19828 } 19829 $156($20_1, $27_1, $11_1, $19_1, $12_1, $24_1, $7_1, $0_1, $1_1, $2_1, $26_1, $23_1); 19830 break block108; 19831 } 19832 $137($8_1, $11_1, 1066400); 19833 wasm2js_trap(); 19834 } 19835 HEAP32[$20_1 >> 2] = 0; 19836 } 19837 global$0 = $16_1 + 16 | 0; 19838 $33_1 = $24_1 << 16 >> 16; 19839 block113 : { 19840 if (HEAP32[$22_1 + 1040 >> 2]) { 19841 HEAP32[$22_1 + 1096 >> 2] = HEAP32[$22_1 + 1048 >> 2]; 19842 $2_1 = $22_1; 19843 $0_1 = HEAP32[$2_1 + 1040 >> 2]; 19844 $5_1 = HEAP32[$2_1 + 1044 >> 2]; 19845 HEAP32[$2_1 + 1088 >> 2] = $0_1; 19846 HEAP32[$2_1 + 1092 >> 2] = $5_1; 19847 break block113; 19848 } 19849 $26_1 = $22_1 + 1088 | 0; 19850 $28_1 = $22_1 + 16 | 0; 19851 $30_1 = 0; 19852 $16_1 = global$0 - 832 | 0; 19853 global$0 = $16_1; 19854 block171 : { 19855 block142 : { 19856 block138 : { 19857 block131 : { 19858 block123 : { 19859 block158 : { 19860 block136 : { 19861 block156 : { 19862 block124 : { 19863 block117 : { 19864 block116 : { 19865 block115 : { 19866 block114 : { 19867 $0_1 = $22_1 + 1104 | 0; 19868 $10_1 = HEAP32[$0_1 >> 2]; 19869 $13_1 = HEAP32[$0_1 + 4 >> 2]; 19870 if ($10_1 | $13_1) { 19871 $18_1 = HEAP32[$0_1 + 8 >> 2]; 19872 $15_1 = HEAP32[$0_1 + 12 >> 2]; 19873 if (!($18_1 | $15_1)) { 19874 break block114 19875 } 19876 $25_1 = HEAP32[$0_1 + 16 >> 2]; 19877 $17_1 = HEAP32[$0_1 + 20 >> 2]; 19878 if (!($25_1 | $17_1)) { 19879 break block115 19880 } 19881 $5_1 = $17_1; 19882 $2_1 = $13_1 ^ -1; 19883 if (($5_1 | 0) == ($2_1 | 0) & ($10_1 ^ -1) >>> 0 < $25_1 >>> 0 | $2_1 >>> 0 < $5_1 >>> 0) { 19884 break block116 19885 } 19886 $4_1 = $13_1; 19887 $5_1 = $15_1; 19888 $6_1 = $10_1; 19889 if (($4_1 | 0) == ($5_1 | 0) & $18_1 >>> 0 > $6_1 >>> 0 | $5_1 >>> 0 > $4_1 >>> 0) { 19890 break block117 19891 } 19892 $0_1 = HEAP16[$0_1 + 24 >> 1]; 19893 HEAP32[$16_1 + 12 >> 2] = $6_1; 19894 $6_1 = $4_1; 19895 $2_1 = $10_1; 19896 $5_1 = 32; 19897 $3_1 = 0; 19898 if (($5_1 & 63) >>> 0 >= 32) { 19899 $4_1 = 0; 19900 $18_1 = $6_1 >>> $3_1 | 0; 19901 } else { 19902 $4_1 = $6_1 >>> $3_1 | 0; 19903 $18_1 = ((1 << $3_1) - 1 & $6_1) << 32 - $3_1 | $2_1 >>> $3_1; 19904 } 19905 $1_1 = $18_1; 19906 HEAP32[$16_1 + 16 >> 2] = $1_1; 19907 HEAP32[$16_1 + 172 >> 2] = $4_1 | $1_1 ? 2 : 1; 19908 wasm2js_memory_fill($16_1 + 20 | 0, 0, 152); 19909 wasm2js_memory_fill($16_1 + 180 | 0, 0, 156); 19910 HEAP32[$16_1 + 176 >> 2] = 1; 19911 HEAP32[$16_1 + 336 >> 2] = 1; 19912 $6_1 = $10_1; 19913 $5_1 = 1; 19914 $1_1 = Math_clz32($6_1 - $5_1 | 0) + 32 | 0; 19915 $5_1 = Math_clz32($13_1 - ($6_1 >>> 0 < $5_1 >>> 0) | 0); 19916 $5_1 = ($5_1 | 0) == 32 ? $1_1 : $5_1; 19917 $1_1 = __wasm_i64_mul($0_1 - $5_1 | 0, ($0_1 >> 31) - ($0_1 >>> 0 < $5_1 >>> 0) | 0, 1292913986, 0); 19918 $5_1 = 1142116480; 19919 $7_1 = $1_1 + $5_1 | 0; 19920 $2_1 = i64toi32_i32$HIGH_BITS + 19 | 0; 19921 $2_1 = $5_1 >>> 0 > $7_1 >>> 0 ? $2_1 + 1 | 0 : $2_1; 19922 $3_1 = $7_1; 19923 $5_1 = 32; 19924 $6_1 = 0; 19925 if (($5_1 & 63) >>> 0 >= 32) { 19926 $1_1 = $2_1 >>> $6_1 | 0 19927 } else { 19928 $1_1 = ((1 << $6_1) - 1 & $2_1) << 32 - $6_1 | $3_1 >>> $6_1 19929 } 19930 $31_1 = $1_1 << 16 >> 16; 19931 block118 : { 19932 if (($0_1 | 0) >= 0) { 19933 $139($16_1 + 12 | 0, $0_1); 19934 break block118; 19935 } 19936 $139($16_1 + 176 | 0, 0 - $0_1 << 16 >> 16); 19937 } 19938 block119 : { 19939 if (($31_1 | 0) < 0) { 19940 $157($16_1 + 12 | 0, 0 - $31_1 & 65535); 19941 break block119; 19942 } 19943 $157($16_1 + 176 | 0, $1_1 & 32767); 19944 } 19945 wasm2js_memory_copy($16_1 + 668 | 0, $16_1 + 176 | 0, 164); 19946 $8_1 = $11_1; 19947 if ($8_1 >>> 0 >= 10) { 19948 $9_1 = $16_1 + 660 | 0; 19949 while (1) { 19950 block120 : { 19951 block122 : { 19952 block121 : { 19953 $12_1 = HEAP32[$16_1 + 828 >> 2]; 19954 if ($12_1 >>> 0 <= 40) { 19955 if (!$12_1) { 19956 break block120 19957 } 19958 $0_1 = $12_1 << 2; 19959 $1_1 = $0_1 - 4 | 0; 19960 if ($1_1) { 19961 break block121 19962 } 19963 $10_1 = 0; 19964 $13_1 = 0; 19965 $0_1 = $0_1 + ($16_1 + 668 | 0) | 0; 19966 break block122; 19967 } 19968 break block123; 19969 } 19970 $12_1 = $0_1 + $9_1 | 0; 19971 $19_1 = ($1_1 >>> 2 | 0) + 1 & 2147483646; 19972 $10_1 = 0; 19973 $13_1 = 0; 19974 while (1) { 19975 $0_1 = $12_1 + 4 | 0; 19976 $15_1 = $0_1; 19977 $0_1 = HEAP32[$0_1 >> 2]; 19978 $7_1 = 0; 19979 $3_1 = $13_1; 19980 $2_1 = $10_1; 19981 $5_1 = 32; 19982 $6_1 = 0; 19983 if (($5_1 & 63) >>> 0 >= 32) { 19984 $4_1 = $2_1 << $6_1; 19985 $2_1 = 0; 19986 } else { 19987 $4_1 = (1 << $6_1) - 1 & $2_1 >>> 32 - $6_1 | $3_1 << $6_1; 19988 $2_1 = $2_1 << $6_1; 19989 } 19990 $10_1 = $2_1 | $0_1; 19991 $13_1 = $4_1 | $7_1; 19992 $18_1 = __wasm_i64_udiv($10_1, $13_1, 1e9, 0); 19993 HEAP32[$15_1 >> 2] = $18_1; 19994 $0_1 = HEAP32[$12_1 >> 2]; 19995 $4_1 = $10_1; 19996 $5_1 = __wasm_i64_mul($18_1, i64toi32_i32$HIGH_BITS, 1e9, 0); 19997 $3_1 = $4_1 - $5_1 | 0; 19998 $7_1 = $13_1 - (i64toi32_i32$HIGH_BITS + ($5_1 >>> 0 > $4_1 >>> 0) | 0) | 0; 19999 $5_1 = 32; 20000 $2_1 = 0; 20001 if (($5_1 & 63) >>> 0 >= 32) { 20002 $4_1 = $3_1 << $2_1; 20003 $2_1 = 0; 20004 } else { 20005 $4_1 = (1 << $2_1) - 1 & $3_1 >>> 32 - $2_1 | $7_1 << $2_1; 20006 $2_1 = $3_1 << $2_1; 20007 } 20008 $10_1 = $2_1 | $0_1; 20009 $13_1 = $6_1 | $4_1; 20010 $18_1 = __wasm_i64_udiv($10_1, $13_1, 1e9, 0); 20011 HEAP32[$12_1 >> 2] = $18_1; 20012 $4_1 = $10_1; 20013 $5_1 = __wasm_i64_mul($18_1, i64toi32_i32$HIGH_BITS, 1e9, 0); 20014 $10_1 = $4_1 - $5_1 | 0; 20015 $13_1 = $13_1 - (i64toi32_i32$HIGH_BITS + ($5_1 >>> 0 > $4_1 >>> 0) | 0) | 0; 20016 $12_1 = $12_1 - 8 | 0; 20017 $19_1 = $19_1 - 2 | 0; 20018 if ($19_1) { 20019 continue 20020 } 20021 break; 20022 }; 20023 if ($1_1 & 4) { 20024 break block120 20025 } 20026 $0_1 = $12_1 + 8 | 0; 20027 } 20028 $0_1 = $0_1 - 4 | 0; 20029 $2_1 = $0_1; 20030 $1_1 = 0; 20031 $4_1 = $13_1; 20032 $3_1 = $10_1; 20033 $5_1 = 32; 20034 $7_1 = 0; 20035 if (($5_1 & 63) >>> 0 >= 32) { 20036 $6_1 = $3_1 << $7_1; 20037 $4_1 = 0; 20038 } else { 20039 $6_1 = (1 << $7_1) - 1 & $3_1 >>> 32 - $7_1 | $4_1 << $7_1; 20040 $4_1 = $3_1 << $7_1; 20041 } 20042 $0_1 = __wasm_i64_udiv($4_1 | HEAP32[$0_1 >> 2], $1_1 | $6_1, 1e9, 0); 20043 HEAP32[$2_1 >> 2] = $0_1; 20044 } 20045 $8_1 = $8_1 - 9 | 0; 20046 if ($8_1 >>> 0 > 9) { 20047 continue 20048 } 20049 break; 20050 }; 20051 } 20052 $0_1 = HEAP32[($8_1 << 2) + 1067100 >> 2] << 1; 20053 if (!$0_1) { 20054 break block124 20055 } 20056 block125 : { 20057 block128 : { 20058 block127 : { 20059 block126 : { 20060 $12_1 = HEAP32[$16_1 + 828 >> 2]; 20061 if ($12_1 >>> 0 <= 40) { 20062 $1_1 = 0; 20063 if (!$12_1) { 20064 break block125 20065 } 20066 $18_1 = $0_1; 20067 $15_1 = 0; 20068 $0_1 = $12_1 << 2; 20069 $1_1 = $0_1 - 4 | 0; 20070 if ($1_1) { 20071 break block126 20072 } 20073 $10_1 = 0; 20074 $13_1 = 0; 20075 $0_1 = $0_1 + ($16_1 + 668 | 0) | 0; 20076 break block127; 20077 } 20078 break block123; 20079 } 20080 $19_1 = ($1_1 >>> 2 | 0) + 1 & 2147483646; 20081 $12_1 = ($0_1 + $16_1 | 0) + 660 | 0; 20082 $10_1 = 0; 20083 $13_1 = 0; 20084 while (1) { 20085 $2_1 = 0; 20086 $4_1 = $13_1; 20087 $6_1 = $10_1; 20088 $5_1 = 32; 20089 $7_1 = 0; 20090 $0_1 = $12_1 + 4 | 0; 20091 if (($5_1 & 63) >>> 0 >= 32) { 20092 $3_1 = $6_1 << $7_1; 20093 $4_1 = 0; 20094 } else { 20095 $3_1 = (1 << $7_1) - 1 & $6_1 >>> 32 - $7_1 | $4_1 << $7_1; 20096 $4_1 = $6_1 << $7_1; 20097 } 20098 $10_1 = $4_1 | HEAP32[$0_1 >> 2]; 20099 $13_1 = $3_1 | $2_1; 20100 $25_1 = __wasm_i64_udiv($10_1, $13_1, $18_1, $15_1); 20101 HEAP32[$0_1 >> 2] = $25_1; 20102 $0_1 = HEAP32[$12_1 >> 2]; 20103 $3_1 = $10_1; 20104 $5_1 = __wasm_i64_mul($18_1, $15_1, $25_1, i64toi32_i32$HIGH_BITS); 20105 $4_1 = $3_1 - $5_1 | 0; 20106 $2_1 = $13_1 - (i64toi32_i32$HIGH_BITS + ($3_1 >>> 0 < $5_1 >>> 0) | 0) | 0; 20107 $5_1 = 32; 20108 $6_1 = 0; 20109 if (($5_1 & 63) >>> 0 >= 32) { 20110 $3_1 = $4_1 << $6_1; 20111 $2_1 = 0; 20112 } else { 20113 $3_1 = (1 << $6_1) - 1 & $4_1 >>> 32 - $6_1 | $2_1 << $6_1; 20114 $2_1 = $4_1 << $6_1; 20115 } 20116 $10_1 = $2_1 | $0_1; 20117 $13_1 = $3_1 | $7_1; 20118 $25_1 = __wasm_i64_udiv($10_1, $13_1, $18_1, $15_1); 20119 HEAP32[$12_1 >> 2] = $25_1; 20120 $3_1 = $10_1; 20121 $5_1 = __wasm_i64_mul($18_1, $15_1, $25_1, i64toi32_i32$HIGH_BITS); 20122 $10_1 = $3_1 - $5_1 | 0; 20123 $13_1 = $13_1 - (i64toi32_i32$HIGH_BITS + ($3_1 >>> 0 < $5_1 >>> 0) | 0) | 0; 20124 $12_1 = $12_1 - 8 | 0; 20125 $19_1 = $19_1 - 2 | 0; 20126 if ($19_1) { 20127 continue 20128 } 20129 break; 20130 }; 20131 if ($1_1 & 4) { 20132 break block128 20133 } 20134 $0_1 = $12_1 + 8 | 0; 20135 } 20136 $0_1 = $0_1 - 4 | 0; 20137 $6_1 = $0_1; 20138 $0_1 = HEAP32[$0_1 >> 2]; 20139 $1_1 = 0; 20140 $3_1 = $13_1; 20141 $4_1 = $10_1; 20142 $5_1 = 32; 20143 $2_1 = 0; 20144 if (($5_1 & 63) >>> 0 >= 32) { 20145 $7_1 = $4_1 << $2_1; 20146 $2_1 = 0; 20147 } else { 20148 $7_1 = (1 << $2_1) - 1 & $4_1 >>> 32 - $2_1 | $3_1 << $2_1; 20149 $2_1 = $4_1 << $2_1; 20150 } 20151 $0_1 = __wasm_i64_udiv($2_1 | $0_1, $1_1 | $7_1, $18_1, $15_1); 20152 HEAP32[$6_1 >> 2] = $0_1; 20153 } 20154 $1_1 = HEAP32[$16_1 + 828 >> 2]; 20155 } 20156 $0_1 = HEAP32[$16_1 + 172 >> 2]; 20157 $9_1 = $0_1 >>> 0 > $1_1 >>> 0 ? $0_1 : $1_1; 20158 if ($9_1 >>> 0 > 40) { 20159 break block91 20160 } 20161 block129 : { 20162 if (!$9_1) { 20163 $9_1 = 0; 20164 break block129; 20165 } 20166 $8_1 = 0; 20167 block130 : { 20168 if (($9_1 | 0) != 1) { 20169 $2_1 = $9_1 & 1; 20170 $24_1 = $9_1 & 62; 20171 $12_1 = $16_1 + 668 | 0; 20172 $19_1 = $16_1 + 12 | 0; 20173 while (1) { 20174 $29_1 = HEAP32[$19_1 >> 2]; 20175 $1_1 = $29_1 + HEAP32[$12_1 >> 2] | 0; 20176 $20_1 = $1_1 + ($8_1 & 1) | 0; 20177 HEAP32[$12_1 >> 2] = $20_1; 20178 $8_1 = $12_1 + 4 | 0; 20179 $4_1 = $8_1; 20180 $27_1 = HEAP32[$19_1 + 4 >> 2]; 20181 $8_1 = $27_1 + HEAP32[$8_1 >> 2] | 0; 20182 $1_1 = $8_1 + ($1_1 >>> 0 < $29_1 >>> 0 | $1_1 >>> 0 > $20_1 >>> 0) | 0; 20183 HEAP32[$4_1 >> 2] = $1_1; 20184 $8_1 = $8_1 >>> 0 < $27_1 >>> 0 | $1_1 >>> 0 < $8_1 >>> 0; 20185 $19_1 = $19_1 + 8 | 0; 20186 $12_1 = $12_1 + 8 | 0; 20187 $30_1 = $30_1 + 2 | 0; 20188 if (($30_1 | 0) != ($24_1 | 0)) { 20189 continue 20190 } 20191 break; 20192 }; 20193 if (!$2_1) { 20194 break block130 20195 } 20196 } 20197 $1_1 = $30_1 << 2; 20198 $21_1 = $1_1 + ($16_1 + 668 | 0) | 0; 20199 $24_1 = HEAP32[$1_1 + ($16_1 + 12 | 0) >> 2]; 20200 $1_1 = $24_1 + HEAP32[$21_1 >> 2] | 0; 20201 $8_1 = $1_1 + $8_1 | 0; 20202 HEAP32[$21_1 >> 2] = $8_1; 20203 $8_1 = $1_1 >>> 0 < $24_1 >>> 0 | $1_1 >>> 0 > $8_1 >>> 0; 20204 } 20205 if (!$8_1) { 20206 break block129 20207 } 20208 if (($9_1 | 0) == 40) { 20209 break block131 20210 } 20211 HEAP32[($16_1 + 668 | 0) + ($9_1 << 2) >> 2] = 1; 20212 $9_1 = $9_1 + 1 | 0; 20213 } 20214 HEAP32[$16_1 + 828 >> 2] = $9_1; 20215 $21_1 = HEAP32[$16_1 + 336 >> 2]; 20216 $12_1 = $9_1 >>> 0 < $21_1 >>> 0 ? $21_1 : $9_1; 20217 if ($12_1 >>> 0 >= 41) { 20218 break block123 20219 } 20220 block133 : { 20221 block132 : { 20222 if (!$12_1) { 20223 break block132 20224 } 20225 $12_1 = $12_1 << 2; 20226 $1_1 = $16_1 + 172 | 0; 20227 $9_1 = $16_1 + 664 | 0; 20228 while (1) { 20229 $8_1 = HEAP32[$9_1 + $12_1 >> 2]; 20230 $24_1 = HEAP32[$1_1 + $12_1 >> 2]; 20231 if (($8_1 | 0) == ($24_1 | 0)) { 20232 $12_1 = $12_1 - 4 | 0; 20233 if ($12_1) { 20234 continue 20235 } 20236 break block132; 20237 } 20238 break; 20239 }; 20240 if ($8_1 >>> 0 >= $24_1 >>> 0) { 20241 break block132 20242 } 20243 if (!$0_1) { 20244 $0_1 = 0; 20245 HEAP32[$16_1 + 172 >> 2] = 0; 20246 break block133; 20247 } 20248 $9_1 = $0_1 << 2; 20249 $8_1 = $9_1 - 4 | 0; 20250 $24_1 = ($8_1 >>> 2 | 0) + 1 | 0; 20251 $1_1 = $24_1 & 3; 20252 block135 : { 20253 block134 : { 20254 if ($8_1 >>> 0 < 12) { 20255 $10_1 = 0; 20256 $13_1 = 0; 20257 $12_1 = $16_1 + 12 | 0; 20258 break block134; 20259 } 20260 $19_1 = $24_1 & 2147483644; 20261 $10_1 = 0; 20262 $13_1 = 0; 20263 $12_1 = $16_1 + 12 | 0; 20264 while (1) { 20265 $5_1 = $10_1; 20266 $2_1 = __wasm_i64_mul(HEAP32[$12_1 >> 2], 0, 10, 0) + $5_1 | 0; 20267 $6_1 = i64toi32_i32$HIGH_BITS + $13_1 | 0; 20268 HEAP32[$12_1 >> 2] = $2_1; 20269 $8_1 = $12_1 + 4 | 0; 20270 $17_1 = $8_1; 20271 $10_1 = __wasm_i64_mul(HEAP32[$8_1 >> 2], 0, 10, 0); 20272 $15_1 = i64toi32_i32$HIGH_BITS; 20273 $7_1 = $2_1 >>> 0 < $5_1 >>> 0 ? $6_1 + 1 | 0 : $6_1; 20274 $3_1 = $2_1; 20275 $5_1 = 32; 20276 $4_1 = 0; 20277 if (($5_1 & 63) >>> 0 >= 32) { 20278 $6_1 = 0; 20279 $5_1 = $7_1 >>> $4_1 | 0; 20280 } else { 20281 $6_1 = $7_1 >>> $4_1 | 0; 20282 $5_1 = ((1 << $4_1) - 1 & $7_1) << 32 - $4_1 | $3_1 >>> $4_1; 20283 } 20284 $2_1 = $6_1 + $15_1 | 0; 20285 $4_1 = $5_1 + $10_1 | 0; 20286 $2_1 = $5_1 >>> 0 > $4_1 >>> 0 ? $2_1 + 1 | 0 : $2_1; 20287 HEAP32[$17_1 >> 2] = $4_1; 20288 $8_1 = $12_1 + 8 | 0; 20289 $17_1 = $8_1; 20290 $10_1 = __wasm_i64_mul(HEAP32[$8_1 >> 2], 0, 10, 0); 20291 $15_1 = i64toi32_i32$HIGH_BITS; 20292 $7_1 = $2_1; 20293 $6_1 = $4_1; 20294 $5_1 = 32; 20295 $3_1 = 0; 20296 if (($5_1 & 63) >>> 0 >= 32) { 20297 $2_1 = 0; 20298 $5_1 = $7_1 >>> $3_1 | 0; 20299 } else { 20300 $2_1 = $7_1 >>> $3_1 | 0; 20301 $5_1 = ((1 << $3_1) - 1 & $7_1) << 32 - $3_1 | $6_1 >>> $3_1; 20302 } 20303 $3_1 = $10_1 + $5_1 | 0; 20304 $4_1 = $2_1 + $15_1 | 0; 20305 HEAP32[$17_1 >> 2] = $3_1; 20306 $8_1 = $12_1 + 12 | 0; 20307 $17_1 = $8_1; 20308 $10_1 = __wasm_i64_mul(HEAP32[$8_1 >> 2], 0, 10, 0); 20309 $15_1 = i64toi32_i32$HIGH_BITS; 20310 $7_1 = $3_1 >>> 0 < $5_1 >>> 0 ? $4_1 + 1 | 0 : $4_1; 20311 $2_1 = $3_1; 20312 $5_1 = 32; 20313 $6_1 = 0; 20314 if (($5_1 & 63) >>> 0 >= 32) { 20315 $4_1 = 0; 20316 $5_1 = $7_1 >>> $6_1 | 0; 20317 } else { 20318 $4_1 = $7_1 >>> $6_1 | 0; 20319 $5_1 = ((1 << $6_1) - 1 & $7_1) << 32 - $6_1 | $2_1 >>> $6_1; 20320 } 20321 $3_1 = $4_1 + $15_1 | 0; 20322 $6_1 = $5_1 + $10_1 | 0; 20323 $3_1 = $6_1 >>> 0 < $5_1 >>> 0 ? $3_1 + 1 | 0 : $3_1; 20324 HEAP32[$17_1 >> 2] = $6_1; 20325 $4_1 = $6_1; 20326 $5_1 = 32; 20327 $2_1 = 0; 20328 if (($5_1 & 63) >>> 0 >= 32) { 20329 $7_1 = 0; 20330 $10_1 = $3_1 >>> $2_1 | 0; 20331 } else { 20332 $7_1 = $3_1 >>> $2_1 | 0; 20333 $10_1 = ((1 << $2_1) - 1 & $3_1) << 32 - $2_1 | $4_1 >>> $2_1; 20334 } 20335 $13_1 = $7_1; 20336 $12_1 = $12_1 + 16 | 0; 20337 $19_1 = $19_1 - 4 | 0; 20338 if ($19_1) { 20339 continue 20340 } 20341 break; 20342 }; 20343 if (!$1_1) { 20344 break block135 20345 } 20346 } 20347 $19_1 = $1_1 << 2; 20348 while (1) { 20349 $5_1 = $10_1; 20350 $2_1 = __wasm_i64_mul(HEAP32[$12_1 >> 2], 0, 10, 0) + $5_1 | 0; 20351 $6_1 = $13_1 + i64toi32_i32$HIGH_BITS | 0; 20352 $6_1 = $2_1 >>> 0 < $5_1 >>> 0 ? $6_1 + 1 | 0 : $6_1; 20353 HEAP32[$12_1 >> 2] = $2_1; 20354 $12_1 = $12_1 + 4 | 0; 20355 $4_1 = $2_1; 20356 $5_1 = 32; 20357 $7_1 = 0; 20358 if (($5_1 & 63) >>> 0 >= 32) { 20359 $3_1 = 0; 20360 $10_1 = $6_1 >>> $7_1 | 0; 20361 } else { 20362 $3_1 = $6_1 >>> $7_1 | 0; 20363 $10_1 = ((1 << $7_1) - 1 & $6_1) << 32 - $7_1 | $4_1 >>> $7_1; 20364 } 20365 $13_1 = $3_1; 20366 $19_1 = $19_1 - 4 | 0; 20367 if ($19_1) { 20368 continue 20369 } 20370 break; 20371 }; 20372 } 20373 if ($10_1 | $13_1) { 20374 if (($0_1 | 0) == 40) { 20375 break block131 20376 } 20377 HEAP32[$9_1 + ($16_1 + 12 | 0) >> 2] = $10_1; 20378 $0_1 = $0_1 + 1 | 0; 20379 } 20380 HEAP32[$16_1 + 172 >> 2] = $0_1; 20381 break block133; 20382 } 20383 $31_1 = $31_1 + 1 | 0; 20384 } 20385 $20_1 = 0; 20386 $8_1 = 1; 20387 $1_1 = $31_1 << 16 >> 16; 20388 $44_1 = ($1_1 | 0) < ($33_1 | 0); 20389 if ($44_1) { 20390 $9_1 = 0; 20391 break block136; 20392 } 20393 $9_1 = 0; 20394 $24_1 = $11_1 >>> 0 > $1_1 - $33_1 >>> 0 ? $31_1 - $33_1 << 16 >> 16 : $11_1; 20395 if (!$24_1) { 20396 break block136 20397 } 20398 $1_1 = $16_1 + 340 | 0; 20399 $0_1 = $16_1 + 176 | 0; 20400 wasm2js_memory_copy($1_1, $0_1, 164); 20401 $37_1 = $139($1_1, 1); 20402 $1_1 = $16_1 + 504 | 0; 20403 wasm2js_memory_copy($1_1, $0_1, 164); 20404 $40_1 = $139($1_1, 2); 20405 $1_1 = $16_1 + 668 | 0; 20406 wasm2js_memory_copy($1_1, $0_1, 164); 20407 $42_1 = $16_1 + 172 | 0; 20408 $43_1 = $16_1 + 336 | 0; 20409 $15_1 = $16_1 + 8 | 0; 20410 $18_1 = $16_1 + 500 | 0; 20411 $25_1 = $16_1 + 664 | 0; 20412 $23_1 = $139($1_1, 3); 20413 $34_1 = HEAP32[$37_1 + 160 >> 2]; 20414 $39_1 = HEAP32[$40_1 + 160 >> 2]; 20415 $41_1 = HEAP32[$23_1 + 160 >> 2]; 20416 $27_1 = 0; 20417 $0_1 = HEAP32[$16_1 + 172 >> 2]; 20418 block137 : { 20419 block152 : { 20420 while (1) { 20421 $29_1 = $27_1; 20422 if ($0_1 >>> 0 >= 41) { 20423 break block42 20424 } 20425 if (!$0_1) { 20426 break block137 20427 } 20428 $27_1 = $27_1 + 1 | 0; 20429 $1_1 = $0_1 << 2; 20430 $12_1 = 0; 20431 while (1) { 20432 if (!HEAP32[$12_1 + ($16_1 + 12 | 0) >> 2]) { 20433 $12_1 = $12_1 + 4 | 0; 20434 if (($1_1 | 0) != ($12_1 | 0)) { 20435 continue 20436 } 20437 break block137; 20438 } 20439 break; 20440 }; 20441 $1_1 = $0_1 >>> 0 < $41_1 >>> 0 ? $41_1 : $0_1; 20442 if ($1_1 >>> 0 >= 41) { 20443 break block138 20444 } 20445 $12_1 = $1_1 << 2; 20446 block140 : { 20447 block139 : { 20448 while (1) { 20449 $9_1 = HEAP32[($12_1 + $16_1 | 0) + 8 >> 2]; 20450 $8_1 = HEAP32[$12_1 + $25_1 >> 2]; 20451 if (($9_1 | 0) == ($8_1 | 0)) { 20452 $12_1 = $12_1 - 4 | 0; 20453 if ($12_1) { 20454 continue 20455 } 20456 break block139; 20457 } 20458 break; 20459 }; 20460 $17_1 = 0; 20461 if ($8_1 >>> 0 > $9_1 >>> 0) { 20462 break block140 20463 } 20464 } 20465 $8_1 = 1; 20466 $30_1 = 0; 20467 block141 : { 20468 if (($1_1 | 0) != 1) { 20469 $13_1 = $1_1 & 1; 20470 $6_1 = $1_1 & 62; 20471 $12_1 = $16_1 + 12 | 0; 20472 $19_1 = $16_1 + 668 | 0; 20473 while (1) { 20474 $2_1 = HEAP32[$12_1 >> 2]; 20475 $0_1 = $2_1 + (HEAP32[$19_1 >> 2] ^ -1) | 0; 20476 $8_1 = $0_1 + ($8_1 & 1) | 0; 20477 HEAP32[$12_1 >> 2] = $8_1; 20478 $9_1 = $12_1 + 4 | 0; 20479 $4_1 = $9_1; 20480 $3_1 = HEAP32[$9_1 >> 2]; 20481 $9_1 = $3_1 + (HEAP32[$19_1 + 4 >> 2] ^ -1) | 0; 20482 $0_1 = $9_1 + ($0_1 >>> 0 < $2_1 >>> 0 | $0_1 >>> 0 > $8_1 >>> 0) | 0; 20483 HEAP32[$4_1 >> 2] = $0_1; 20484 $8_1 = $0_1 >>> 0 < $9_1 >>> 0 | $3_1 >>> 0 > $9_1 >>> 0; 20485 $19_1 = $19_1 + 8 | 0; 20486 $12_1 = $12_1 + 8 | 0; 20487 $30_1 = $30_1 + 2 | 0; 20488 if (($30_1 | 0) != ($6_1 | 0)) { 20489 continue 20490 } 20491 break; 20492 }; 20493 if (!$13_1) { 20494 break block141 20495 } 20496 } 20497 $0_1 = $30_1 << 2; 20498 $9_1 = $0_1 + ($16_1 + 12 | 0) | 0; 20499 $2_1 = $9_1; 20500 $9_1 = HEAP32[$9_1 >> 2]; 20501 $0_1 = $9_1 + (HEAP32[$0_1 + $23_1 >> 2] ^ -1) | 0; 20502 $8_1 = $8_1 + $0_1 | 0; 20503 HEAP32[$2_1 >> 2] = $8_1; 20504 $8_1 = $0_1 >>> 0 < $9_1 >>> 0 | $0_1 >>> 0 > $8_1 >>> 0; 20505 } 20506 if (!$8_1) { 20507 break block142 20508 } 20509 HEAP32[$16_1 + 172 >> 2] = $1_1; 20510 $0_1 = $1_1; 20511 $17_1 = 8; 20512 } 20513 $9_1 = $0_1 >>> 0 < $39_1 >>> 0 ? $39_1 : $0_1; 20514 if ($9_1 >>> 0 >= 41) { 20515 break block91 20516 } 20517 $12_1 = $9_1 << 2; 20518 block144 : { 20519 block143 : { 20520 while (1) { 20521 $1_1 = HEAP32[($12_1 + $16_1 | 0) + 8 >> 2]; 20522 $8_1 = HEAP32[$12_1 + $18_1 >> 2]; 20523 if (($1_1 | 0) == ($8_1 | 0)) { 20524 $12_1 = $12_1 - 4 | 0; 20525 if ($12_1) { 20526 continue 20527 } 20528 break block143; 20529 } 20530 break; 20531 }; 20532 if ($1_1 >>> 0 >= $8_1 >>> 0) { 20533 break block143 20534 } 20535 $9_1 = $0_1; 20536 break block144; 20537 } 20538 $8_1 = 1; 20539 $30_1 = 0; 20540 block145 : { 20541 if (($9_1 | 0) != 1) { 20542 $13_1 = $9_1 & 1; 20543 $2_1 = $9_1 & 62; 20544 $12_1 = $16_1 + 12 | 0; 20545 $19_1 = $16_1 + 504 | 0; 20546 while (1) { 20547 $3_1 = HEAP32[$12_1 >> 2]; 20548 $0_1 = $3_1 + (HEAP32[$19_1 >> 2] ^ -1) | 0; 20549 $8_1 = $0_1 + ($8_1 & 1) | 0; 20550 HEAP32[$12_1 >> 2] = $8_1; 20551 $1_1 = $12_1 + 4 | 0; 20552 $4_1 = $1_1; 20553 $6_1 = HEAP32[$1_1 >> 2]; 20554 $1_1 = $6_1 + (HEAP32[$19_1 + 4 >> 2] ^ -1) | 0; 20555 $0_1 = $1_1 + ($0_1 >>> 0 < $3_1 >>> 0 | $0_1 >>> 0 > $8_1 >>> 0) | 0; 20556 HEAP32[$4_1 >> 2] = $0_1; 20557 $8_1 = $1_1 >>> 0 < $6_1 >>> 0 | $0_1 >>> 0 < $1_1 >>> 0; 20558 $19_1 = $19_1 + 8 | 0; 20559 $12_1 = $12_1 + 8 | 0; 20560 $30_1 = $30_1 + 2 | 0; 20561 if (($30_1 | 0) != ($2_1 | 0)) { 20562 continue 20563 } 20564 break; 20565 }; 20566 if (!$13_1) { 20567 break block145 20568 } 20569 } 20570 $0_1 = $30_1 << 2; 20571 $1_1 = $0_1 + ($16_1 + 12 | 0) | 0; 20572 $2_1 = $1_1; 20573 $1_1 = HEAP32[$1_1 >> 2]; 20574 $0_1 = $1_1 + (HEAP32[$0_1 + $40_1 >> 2] ^ -1) | 0; 20575 $8_1 = $8_1 + $0_1 | 0; 20576 HEAP32[$2_1 >> 2] = $8_1; 20577 $8_1 = $0_1 >>> 0 < $1_1 >>> 0 | $0_1 >>> 0 > $8_1 >>> 0; 20578 } 20579 if (!$8_1) { 20580 break block142 20581 } 20582 HEAP32[$16_1 + 172 >> 2] = $9_1; 20583 $17_1 = $17_1 | 4; 20584 } 20585 $1_1 = $9_1 >>> 0 < $34_1 >>> 0 ? $34_1 : $9_1; 20586 if ($1_1 >>> 0 >= 41) { 20587 break block138 20588 } 20589 block147 : { 20590 block146 : { 20591 if (!$1_1) { 20592 break block146 20593 } 20594 $12_1 = $1_1 << 2; 20595 while (1) { 20596 $0_1 = HEAP32[$12_1 + $15_1 >> 2]; 20597 $8_1 = HEAP32[$12_1 + $43_1 >> 2]; 20598 if (($0_1 | 0) == ($8_1 | 0)) { 20599 $12_1 = $12_1 - 4 | 0; 20600 if ($12_1) { 20601 continue 20602 } 20603 break block146; 20604 } 20605 break; 20606 }; 20607 if ($0_1 >>> 0 >= $8_1 >>> 0) { 20608 break block146 20609 } 20610 $1_1 = $9_1; 20611 break block147; 20612 } 20613 if ($1_1) { 20614 $8_1 = 1; 20615 $30_1 = 0; 20616 block148 : { 20617 if (($1_1 | 0) != 1) { 20618 $13_1 = $1_1 & 1; 20619 $2_1 = $1_1 & 62; 20620 $12_1 = $16_1 + 12 | 0; 20621 $19_1 = $16_1 + 340 | 0; 20622 while (1) { 20623 $3_1 = HEAP32[$12_1 >> 2]; 20624 $0_1 = $3_1 + (HEAP32[$19_1 >> 2] ^ -1) | 0; 20625 $8_1 = $0_1 + ($8_1 & 1) | 0; 20626 HEAP32[$12_1 >> 2] = $8_1; 20627 $9_1 = $12_1 + 4 | 0; 20628 $4_1 = $9_1; 20629 $6_1 = HEAP32[$9_1 >> 2]; 20630 $9_1 = $6_1 + (HEAP32[$19_1 + 4 >> 2] ^ -1) | 0; 20631 $0_1 = $9_1 + ($0_1 >>> 0 < $3_1 >>> 0 | $0_1 >>> 0 > $8_1 >>> 0) | 0; 20632 HEAP32[$4_1 >> 2] = $0_1; 20633 $8_1 = $0_1 >>> 0 < $9_1 >>> 0 | $6_1 >>> 0 > $9_1 >>> 0; 20634 $19_1 = $19_1 + 8 | 0; 20635 $12_1 = $12_1 + 8 | 0; 20636 $30_1 = $30_1 + 2 | 0; 20637 if (($30_1 | 0) != ($2_1 | 0)) { 20638 continue 20639 } 20640 break; 20641 }; 20642 if (!$13_1) { 20643 break block148 20644 } 20645 } 20646 $0_1 = $30_1 << 2; 20647 $9_1 = $0_1 + ($16_1 + 12 | 0) | 0; 20648 $2_1 = $9_1; 20649 $9_1 = HEAP32[$9_1 >> 2]; 20650 $0_1 = $9_1 + (HEAP32[$0_1 + $37_1 >> 2] ^ -1) | 0; 20651 $8_1 = $8_1 + $0_1 | 0; 20652 HEAP32[$2_1 >> 2] = $8_1; 20653 $8_1 = $0_1 >>> 0 < $9_1 >>> 0 | $0_1 >>> 0 > $8_1 >>> 0; 20654 } 20655 if (!$8_1) { 20656 break block142 20657 } 20658 } 20659 HEAP32[$16_1 + 172 >> 2] = $1_1; 20660 $17_1 = $17_1 + 2 | 0; 20661 } 20662 $0_1 = $1_1 >>> 0 < $21_1 >>> 0 ? $21_1 : $1_1; 20663 if ($0_1 >>> 0 >= 41) { 20664 break block42 20665 } 20666 block150 : { 20667 block149 : { 20668 if (!$0_1) { 20669 break block149 20670 } 20671 $12_1 = $0_1 << 2; 20672 while (1) { 20673 $9_1 = HEAP32[$12_1 + $15_1 >> 2]; 20674 $8_1 = HEAP32[$12_1 + $42_1 >> 2]; 20675 if (($9_1 | 0) == ($8_1 | 0)) { 20676 $12_1 = $12_1 - 4 | 0; 20677 if ($12_1) { 20678 continue 20679 } 20680 break block149; 20681 } 20682 break; 20683 }; 20684 if ($8_1 >>> 0 <= $9_1 >>> 0) { 20685 break block149 20686 } 20687 $0_1 = $1_1; 20688 break block150; 20689 } 20690 if ($0_1) { 20691 $8_1 = 1; 20692 $30_1 = 0; 20693 block151 : { 20694 if (($0_1 | 0) != 1) { 20695 $13_1 = $0_1 & 1; 20696 $2_1 = $0_1 & 62; 20697 $12_1 = $16_1 + 12 | 0; 20698 $19_1 = $16_1 + 176 | 0; 20699 while (1) { 20700 $3_1 = HEAP32[$12_1 >> 2]; 20701 $1_1 = $3_1 + (HEAP32[$19_1 >> 2] ^ -1) | 0; 20702 $8_1 = $1_1 + ($8_1 & 1) | 0; 20703 HEAP32[$12_1 >> 2] = $8_1; 20704 $9_1 = $12_1 + 4 | 0; 20705 $4_1 = $9_1; 20706 $6_1 = HEAP32[$9_1 >> 2]; 20707 $9_1 = $6_1 + (HEAP32[$19_1 + 4 >> 2] ^ -1) | 0; 20708 $1_1 = $9_1 + ($1_1 >>> 0 < $3_1 >>> 0 | $1_1 >>> 0 > $8_1 >>> 0) | 0; 20709 HEAP32[$4_1 >> 2] = $1_1; 20710 $8_1 = $1_1 >>> 0 < $9_1 >>> 0 | $6_1 >>> 0 > $9_1 >>> 0; 20711 $19_1 = $19_1 + 8 | 0; 20712 $12_1 = $12_1 + 8 | 0; 20713 $30_1 = $30_1 + 2 | 0; 20714 if (($30_1 | 0) != ($2_1 | 0)) { 20715 continue 20716 } 20717 break; 20718 }; 20719 if (!$13_1) { 20720 break block151 20721 } 20722 } 20723 $1_1 = $30_1 << 2; 20724 $9_1 = $1_1 + ($16_1 + 12 | 0) | 0; 20725 $2_1 = $9_1; 20726 $9_1 = HEAP32[$9_1 >> 2]; 20727 $1_1 = $9_1 + (HEAP32[$1_1 + ($16_1 + 176 | 0) >> 2] ^ -1) | 0; 20728 $8_1 = $8_1 + $1_1 | 0; 20729 HEAP32[$2_1 >> 2] = $8_1; 20730 $8_1 = $1_1 >>> 0 < $9_1 >>> 0 | $1_1 >>> 0 > $8_1 >>> 0; 20731 } 20732 if (!$8_1) { 20733 break block142 20734 } 20735 } 20736 HEAP32[$16_1 + 172 >> 2] = $0_1; 20737 $17_1 = $17_1 + 1 | 0; 20738 } 20739 if (($11_1 | 0) == ($29_1 | 0)) { 20740 break block152 20741 } 20742 HEAP8[$28_1 + $29_1 | 0] = $17_1 + 48; 20743 block153 : { 20744 if (!$0_1) { 20745 $0_1 = 0; 20746 break block153; 20747 } 20748 $9_1 = $0_1 << 2; 20749 $8_1 = $9_1 - 4 | 0; 20750 $29_1 = ($8_1 >>> 2 | 0) + 1 | 0; 20751 $1_1 = $29_1 & 3; 20752 block155 : { 20753 block154 : { 20754 if ($8_1 >>> 0 < 12) { 20755 $10_1 = 0; 20756 $13_1 = 0; 20757 $12_1 = $16_1 + 12 | 0; 20758 break block154; 20759 } 20760 $19_1 = $29_1 & 2147483644; 20761 $10_1 = 0; 20762 $13_1 = 0; 20763 $12_1 = $16_1 + 12 | 0; 20764 while (1) { 20765 $5_1 = $10_1; 20766 $7_1 = __wasm_i64_mul(HEAP32[$12_1 >> 2], 0, 10, 0) + $5_1 | 0; 20767 $2_1 = $13_1 + i64toi32_i32$HIGH_BITS | 0; 20768 HEAP32[$12_1 >> 2] = $7_1; 20769 $8_1 = $12_1 + 4 | 0; 20770 $10_1 = __wasm_i64_mul(HEAP32[$8_1 >> 2], 0, 10, 0); 20771 $17_1 = i64toi32_i32$HIGH_BITS; 20772 $6_1 = $5_1 >>> 0 > $7_1 >>> 0 ? $2_1 + 1 | 0 : $2_1; 20773 $4_1 = $7_1; 20774 $5_1 = 32; 20775 $3_1 = 0; 20776 if (($5_1 & 63) >>> 0 >= 32) { 20777 $2_1 = 0; 20778 $5_1 = $6_1 >>> $3_1 | 0; 20779 } else { 20780 $2_1 = $6_1 >>> $3_1 | 0; 20781 $5_1 = ((1 << $3_1) - 1 & $6_1) << 32 - $3_1 | $4_1 >>> $3_1; 20782 } 20783 $3_1 = $10_1 + $5_1 | 0; 20784 $7_1 = $2_1 + $17_1 | 0; 20785 HEAP32[$8_1 >> 2] = $3_1; 20786 $8_1 = $12_1 + 8 | 0; 20787 $10_1 = __wasm_i64_mul(HEAP32[$8_1 >> 2], 0, 10, 0); 20788 $17_1 = i64toi32_i32$HIGH_BITS; 20789 $6_1 = $3_1 >>> 0 < $5_1 >>> 0 ? $7_1 + 1 | 0 : $7_1; 20790 $2_1 = $3_1; 20791 $5_1 = 32; 20792 $4_1 = 0; 20793 if (($5_1 & 63) >>> 0 >= 32) { 20794 $7_1 = 0; 20795 $5_1 = $6_1 >>> $4_1 | 0; 20796 } else { 20797 $7_1 = $6_1 >>> $4_1 | 0; 20798 $5_1 = ((1 << $4_1) - 1 & $6_1) << 32 - $4_1 | $2_1 >>> $4_1; 20799 } 20800 $3_1 = $7_1 + $17_1 | 0; 20801 $4_1 = $5_1 + $10_1 | 0; 20802 $3_1 = $5_1 >>> 0 > $4_1 >>> 0 ? $3_1 + 1 | 0 : $3_1; 20803 HEAP32[$8_1 >> 2] = $4_1; 20804 $8_1 = $12_1 + 12 | 0; 20805 $10_1 = __wasm_i64_mul(HEAP32[$8_1 >> 2], 0, 10, 0); 20806 $17_1 = i64toi32_i32$HIGH_BITS; 20807 $6_1 = $3_1; 20808 $7_1 = $4_1; 20809 $5_1 = 32; 20810 $2_1 = 0; 20811 if (($5_1 & 63) >>> 0 >= 32) { 20812 $3_1 = 0; 20813 $5_1 = $6_1 >>> $2_1 | 0; 20814 } else { 20815 $3_1 = $6_1 >>> $2_1 | 0; 20816 $5_1 = ((1 << $2_1) - 1 & $6_1) << 32 - $2_1 | $7_1 >>> $2_1; 20817 } 20818 $2_1 = $10_1 + $5_1 | 0; 20819 $4_1 = $3_1 + $17_1 | 0; 20820 $4_1 = $2_1 >>> 0 < $5_1 >>> 0 ? $4_1 + 1 | 0 : $4_1; 20821 HEAP32[$8_1 >> 2] = $2_1; 20822 $3_1 = $2_1; 20823 $5_1 = 32; 20824 $7_1 = 0; 20825 if (($5_1 & 63) >>> 0 >= 32) { 20826 $6_1 = 0; 20827 $10_1 = $4_1 >>> $7_1 | 0; 20828 } else { 20829 $6_1 = $4_1 >>> $7_1 | 0; 20830 $10_1 = ((1 << $7_1) - 1 & $4_1) << 32 - $7_1 | $3_1 >>> $7_1; 20831 } 20832 $13_1 = $6_1; 20833 $12_1 = $12_1 + 16 | 0; 20834 $19_1 = $19_1 - 4 | 0; 20835 if ($19_1) { 20836 continue 20837 } 20838 break; 20839 }; 20840 if (!$1_1) { 20841 break block155 20842 } 20843 } 20844 $19_1 = $1_1 << 2; 20845 while (1) { 20846 $5_1 = $10_1; 20847 $7_1 = __wasm_i64_mul(HEAP32[$12_1 >> 2], 0, 10, 0) + $5_1 | 0; 20848 $2_1 = i64toi32_i32$HIGH_BITS + $13_1 | 0; 20849 $2_1 = $5_1 >>> 0 > $7_1 >>> 0 ? $2_1 + 1 | 0 : $2_1; 20850 HEAP32[$12_1 >> 2] = $7_1; 20851 $12_1 = $12_1 + 4 | 0; 20852 $3_1 = $7_1; 20853 $5_1 = 32; 20854 $6_1 = 0; 20855 if (($5_1 & 63) >>> 0 >= 32) { 20856 $4_1 = 0; 20857 $10_1 = $2_1 >>> $6_1 | 0; 20858 } else { 20859 $4_1 = $2_1 >>> $6_1 | 0; 20860 $10_1 = ((1 << $6_1) - 1 & $2_1) << 32 - $6_1 | $3_1 >>> $6_1; 20861 } 20862 $13_1 = $4_1; 20863 $19_1 = $19_1 - 4 | 0; 20864 if ($19_1) { 20865 continue 20866 } 20867 break; 20868 }; 20869 } 20870 if (!($10_1 | $13_1)) { 20871 break block153 20872 } 20873 if (($0_1 | 0) == 40) { 20874 break block131 20875 } 20876 HEAP32[$9_1 + ($16_1 + 12 | 0) >> 2] = $10_1; 20877 $0_1 = $0_1 + 1 | 0; 20878 } 20879 HEAP32[$16_1 + 172 >> 2] = $0_1; 20880 if (($24_1 | 0) != ($27_1 | 0)) { 20881 continue 20882 } 20883 break; 20884 }; 20885 $8_1 = 0; 20886 $9_1 = $24_1; 20887 break block136; 20888 } 20889 $137($11_1, $11_1, 1066892); 20890 wasm2js_trap(); 20891 } 20892 if ($11_1 >>> 0 < $24_1 >>> 0) { 20893 break block156 20894 } 20895 block157 : { 20896 if (($24_1 | 0) == ($29_1 | 0)) { 20897 break block157 20898 } 20899 $0_1 = $24_1 - $29_1 | 0; 20900 if (!$0_1) { 20901 break block157 20902 } 20903 wasm2js_memory_fill($28_1 + $29_1 | 0, 48, $0_1); 20904 } 20905 HEAP16[$26_1 + 8 >> 1] = $31_1; 20906 HEAP32[$26_1 + 4 >> 2] = $24_1; 20907 break block158; 20908 } 20909 $129(1066240, 28, 1066796); 20910 wasm2js_trap(); 20911 } 20912 $129(1066432, 29, 1066812); 20913 wasm2js_trap(); 20914 } 20915 $129(1066480, 28, 1066828); 20916 wasm2js_trap(); 20917 } 20918 $129(1066724, 54, 1066940); 20919 wasm2js_trap(); 20920 } 20921 $129(1066652, 55, 1066924); 20922 wasm2js_trap(); 20923 } 20924 $129(1062792, 27, 1062848); 20925 wasm2js_trap(); 20926 } 20927 $135($29_1, $24_1, $11_1, 1066908); 20928 wasm2js_trap(); 20929 } 20930 block170 : { 20931 block159 : { 20932 if (!$21_1) { 20933 break block159 20934 } 20935 $24_1 = $21_1 << 2; 20936 $29_1 = $24_1 - 4 | 0; 20937 $20_1 = ($29_1 >>> 2 | 0) + 1 | 0; 20938 $1_1 = $20_1 & 3; 20939 block161 : { 20940 block160 : { 20941 if ($29_1 >>> 0 < 12) { 20942 $10_1 = 0; 20943 $13_1 = 0; 20944 $12_1 = $16_1 + 176 | 0; 20945 break block160; 20946 } 20947 $19_1 = $20_1 & 2147483644; 20948 $10_1 = 0; 20949 $13_1 = 0; 20950 $12_1 = $16_1 + 176 | 0; 20951 while (1) { 20952 $5_1 = $10_1; 20953 $6_1 = __wasm_i64_mul(HEAP32[$12_1 >> 2], 0, 5, 0) + $5_1 | 0; 20954 $7_1 = i64toi32_i32$HIGH_BITS + $13_1 | 0; 20955 HEAP32[$12_1 >> 2] = $6_1; 20956 $29_1 = $12_1 + 4 | 0; 20957 $17_1 = $29_1; 20958 $10_1 = __wasm_i64_mul(HEAP32[$17_1 >> 2], 0, 5, 0); 20959 $15_1 = i64toi32_i32$HIGH_BITS; 20960 $2_1 = $6_1 >>> 0 < $5_1 >>> 0 ? $7_1 + 1 | 0 : $7_1; 20961 $3_1 = $6_1; 20962 $5_1 = 32; 20963 $4_1 = 0; 20964 if (($5_1 & 63) >>> 0 >= 32) { 20965 $7_1 = 0; 20966 $5_1 = $2_1 >>> $4_1 | 0; 20967 } else { 20968 $7_1 = $2_1 >>> $4_1 | 0; 20969 $5_1 = ((1 << $4_1) - 1 & $2_1) << 32 - $4_1 | $3_1 >>> $4_1; 20970 } 20971 $6_1 = $7_1 + $15_1 | 0; 20972 $4_1 = $5_1 + $10_1 | 0; 20973 $6_1 = $5_1 >>> 0 > $4_1 >>> 0 ? $6_1 + 1 | 0 : $6_1; 20974 HEAP32[$17_1 >> 2] = $4_1; 20975 $29_1 = $12_1 + 8 | 0; 20976 $17_1 = $29_1; 20977 $10_1 = __wasm_i64_mul(HEAP32[$17_1 >> 2], 0, 5, 0); 20978 $15_1 = i64toi32_i32$HIGH_BITS; 20979 $2_1 = $6_1; 20980 $7_1 = $4_1; 20981 $5_1 = 32; 20982 $3_1 = 0; 20983 if (($5_1 & 63) >>> 0 >= 32) { 20984 $6_1 = 0; 20985 $5_1 = $2_1 >>> $3_1 | 0; 20986 } else { 20987 $6_1 = $2_1 >>> $3_1 | 0; 20988 $5_1 = ((1 << $3_1) - 1 & $2_1) << 32 - $3_1 | $7_1 >>> $3_1; 20989 } 20990 $3_1 = $10_1 + $5_1 | 0; 20991 $4_1 = $6_1 + $15_1 | 0; 20992 HEAP32[$17_1 >> 2] = $3_1; 20993 $29_1 = $12_1 + 12 | 0; 20994 $17_1 = $29_1; 20995 $10_1 = __wasm_i64_mul(HEAP32[$17_1 >> 2], 0, 5, 0); 20996 $15_1 = i64toi32_i32$HIGH_BITS; 20997 $2_1 = $3_1 >>> 0 < $5_1 >>> 0 ? $4_1 + 1 | 0 : $4_1; 20998 $6_1 = $3_1; 20999 $5_1 = 32; 21000 $7_1 = 0; 21001 if (($5_1 & 63) >>> 0 >= 32) { 21002 $4_1 = 0; 21003 $5_1 = $2_1 >>> $7_1 | 0; 21004 } else { 21005 $4_1 = $2_1 >>> $7_1 | 0; 21006 $5_1 = ((1 << $7_1) - 1 & $2_1) << 32 - $7_1 | $6_1 >>> $7_1; 21007 } 21008 $3_1 = $4_1 + $15_1 | 0; 21009 $7_1 = $5_1 + $10_1 | 0; 21010 $3_1 = $7_1 >>> 0 < $5_1 >>> 0 ? $3_1 + 1 | 0 : $3_1; 21011 HEAP32[$17_1 >> 2] = $7_1; 21012 $4_1 = $7_1; 21013 $5_1 = 32; 21014 $6_1 = 0; 21015 if (($5_1 & 63) >>> 0 >= 32) { 21016 $2_1 = 0; 21017 $10_1 = $3_1 >>> $6_1 | 0; 21018 } else { 21019 $2_1 = $3_1 >>> $6_1 | 0; 21020 $10_1 = ((1 << $6_1) - 1 & $3_1) << 32 - $6_1 | $4_1 >>> $6_1; 21021 } 21022 $13_1 = $2_1; 21023 $12_1 = $12_1 + 16 | 0; 21024 $19_1 = $19_1 - 4 | 0; 21025 if ($19_1) { 21026 continue 21027 } 21028 break; 21029 }; 21030 if (!$1_1) { 21031 break block161 21032 } 21033 } 21034 $19_1 = $1_1 << 2; 21035 while (1) { 21036 $5_1 = $10_1; 21037 $6_1 = __wasm_i64_mul(HEAP32[$12_1 >> 2], 0, 5, 0) + $5_1 | 0; 21038 $7_1 = $13_1 + i64toi32_i32$HIGH_BITS | 0; 21039 $7_1 = $6_1 >>> 0 < $5_1 >>> 0 ? $7_1 + 1 | 0 : $7_1; 21040 HEAP32[$12_1 >> 2] = $6_1; 21041 $12_1 = $12_1 + 4 | 0; 21042 $4_1 = $6_1; 21043 $5_1 = 32; 21044 $2_1 = 0; 21045 if (($5_1 & 63) >>> 0 >= 32) { 21046 $3_1 = 0; 21047 $10_1 = $7_1 >>> $2_1 | 0; 21048 } else { 21049 $3_1 = $7_1 >>> $2_1 | 0; 21050 $10_1 = ((1 << $2_1) - 1 & $7_1) << 32 - $2_1 | $4_1 >>> $2_1; 21051 } 21052 $13_1 = $3_1; 21053 $19_1 = $19_1 - 4 | 0; 21054 if ($19_1) { 21055 continue 21056 } 21057 break; 21058 }; 21059 } 21060 if (!($10_1 | $13_1)) { 21061 $20_1 = $21_1; 21062 break block159; 21063 } 21064 if (($21_1 | 0) == 40) { 21065 break block131 21066 } 21067 HEAP32[$24_1 + ($16_1 + 176 | 0) >> 2] = $10_1; 21068 $20_1 = $21_1 + 1 | 0; 21069 } 21070 HEAP32[$16_1 + 336 >> 2] = $20_1; 21071 $12_1 = $0_1 >>> 0 < $20_1 >>> 0 ? $20_1 : $0_1; 21072 if ($12_1 >>> 0 >= 41) { 21073 break block123 21074 } 21075 block165 : { 21076 block164 : { 21077 block167 : { 21078 block166 : { 21079 block163 : { 21080 block162 : { 21081 if (!$12_1) { 21082 break block162 21083 } 21084 $12_1 = $12_1 << 2; 21085 $21_1 = $16_1 + 172 | 0; 21086 $24_1 = $16_1 + 8 | 0; 21087 while (1) { 21088 $0_1 = HEAP32[$12_1 + $24_1 >> 2]; 21089 $1_1 = HEAP32[$12_1 + $21_1 >> 2]; 21090 if (($0_1 | 0) == ($1_1 | 0)) { 21091 $12_1 = $12_1 - 4 | 0; 21092 if ($12_1) { 21093 continue 21094 } 21095 break block162; 21096 } 21097 break; 21098 }; 21099 switch (($0_1 >>> 0 > $1_1 >>> 0) - ($0_1 >>> 0 < $1_1 >>> 0) & 255) { 21100 case 0: 21101 break block162; 21102 case 1: 21103 break block163; 21104 default: 21105 break block164; 21106 }; 21107 } 21108 $0_1 = 0; 21109 if ($8_1) { 21110 break block165 21111 } 21112 $0_1 = $9_1 - 1 | 0; 21113 if ($11_1 >>> 0 <= $0_1 >>> 0) { 21114 break block166 21115 } 21116 if (!(HEAP8[$0_1 + $28_1 | 0] & 1)) { 21117 break block164 21118 } 21119 } 21120 if ($9_1 >>> 0 > $11_1 >>> 0) { 21121 break block167 21122 } 21123 $0_1 = $9_1 + $28_1 | 0; 21124 block168 : { 21125 if (!$9_1) { 21126 break block168 21127 } 21128 $12_1 = 0; 21129 while (1) { 21130 $1_1 = $0_1 + $12_1 | 0; 21131 if (HEAPU8[$1_1 - 1 | 0] == 57) { 21132 $12_1 = $12_1 - 1 | 0; 21133 if ($12_1 + $9_1 | 0) { 21134 continue 21135 } 21136 break block168; 21137 } 21138 break; 21139 }; 21140 $0_1 = $1_1 - 1 | 0; 21141 HEAP8[$0_1 | 0] = HEAPU8[$0_1 | 0] + 1; 21142 $0_1 = 0 - $12_1 | 0; 21143 if (!$0_1) { 21144 break block164 21145 } 21146 wasm2js_memory_fill($1_1, 48, $0_1); 21147 break block164; 21148 } 21149 $12_1 = 49; 21150 block169 : { 21151 if ($8_1) { 21152 break block169 21153 } 21154 HEAP8[$28_1 | 0] = 49; 21155 $12_1 = 48; 21156 $1_1 = $9_1 - 1 | 0; 21157 if (!$1_1) { 21158 break block169 21159 } 21160 wasm2js_memory_fill($28_1 + 1 | 0, 48, $1_1); 21161 } 21162 $31_1 = $31_1 + 1 | 0; 21163 if ($9_1 >>> 0 >= $11_1 >>> 0 | $44_1) { 21164 break block164 21165 } 21166 HEAP8[$0_1 | 0] = $12_1; 21167 $9_1 = $9_1 + 1 | 0; 21168 break block164; 21169 } 21170 $137($0_1, $11_1, 1066844); 21171 wasm2js_trap(); 21172 } 21173 $135(0, $9_1, $11_1, 1066860); 21174 wasm2js_trap(); 21175 } 21176 if ($9_1 >>> 0 > $11_1 >>> 0) { 21177 break block170 21178 } 21179 $0_1 = $9_1; 21180 } 21181 HEAP16[$26_1 + 8 >> 1] = $31_1; 21182 HEAP32[$26_1 + 4 >> 2] = $0_1; 21183 break block158; 21184 } 21185 $135(0, $9_1, $11_1, 1066876); 21186 wasm2js_trap(); 21187 } 21188 HEAP32[$26_1 >> 2] = $28_1; 21189 global$0 = $16_1 + 832 | 0; 21190 break block171; 21191 } 21192 $135(0, $12_1, 40, 1062848); 21193 wasm2js_trap(); 21194 } 21195 $137(40, 40, 1062848); 21196 wasm2js_trap(); 21197 } 21198 $135(0, $1_1, 40, 1062848); 21199 wasm2js_trap(); 21200 } 21201 $129(1062819, 26, 1062848); 21202 wasm2js_trap(); 21203 } 21204 } 21205 $0_1 = $35_1 ? $45_1 : $38_1; 21206 $1_1 = $35_1 | $36_1; 21207 $9_1 = HEAP16[$22_1 + 1096 >> 1]; 21208 if (($9_1 | 0) > ($33_1 | 0)) { 21209 $130($22_1 + 8 | 0, HEAP32[$22_1 + 1088 >> 2], HEAP32[$22_1 + 1092 >> 2], $9_1, $14_1, $22_1 + 1040 | 0); 21210 $9_1 = HEAP32[$22_1 + 12 >> 2]; 21211 $8_1 = HEAP32[$22_1 + 8 >> 2]; 21212 break block100; 21213 } 21214 $9_1 = 2; 21215 HEAP16[$22_1 + 1040 >> 1] = 2; 21216 if (!$14_1) { 21217 $9_1 = 1; 21218 HEAP32[$22_1 + 1048 >> 2] = 1; 21219 HEAP32[$22_1 + 1044 >> 2] = 1062719; 21220 $8_1 = $22_1 + 1040 | 0; 21221 break block100; 21222 } 21223 HEAP32[$22_1 + 1056 >> 2] = $14_1; 21224 HEAP16[$22_1 + 1052 >> 1] = 0; 21225 HEAP32[$22_1 + 1048 >> 2] = 2; 21226 HEAP32[$22_1 + 1044 >> 2] = 1062720; 21227 $8_1 = $22_1 + 1040 | 0; 21228 } 21229 HEAP32[$22_1 + 1100 >> 2] = $9_1; 21230 HEAP32[$22_1 + 1096 >> 2] = $8_1; 21231 HEAP32[$22_1 + 1092 >> 2] = $1_1; 21232 HEAP32[$22_1 + 1088 >> 2] = $0_1; 21233 $0_1 = $131($32_1, $22_1 + 1088 | 0); 21234 global$0 = $22_1 + 1136 | 0; 21235 return $0_1 | 0; 21236 } 21237 $135(0, $0_1, 40, 1062848); 21238 wasm2js_trap(); 21239 } 21240 $135(0, $9_1, 40, 1062848); 21241 wasm2js_trap(); 21242 } 21243 21244 function $164($0_1, $1_1) { 21245 $0_1 = $0_1 | 0; 21246 $1_1 = $1_1 | 0; 21247 if (!HEAPU8[$0_1 | 0]) { 21248 return $144($1_1, 1067364, 5) | 0 21249 } 21250 return $144($1_1, 1067369, 4) | 0; 21251 } 21252 21253 function $165($0_1, $1_1) { 21254 $0_1 = $0_1 | 0; 21255 $1_1 = $1_1 | 0; 21256 var $2_1 = 0, $3_1 = 0, $4_1 = 0, $5_1 = 0, $6_1 = 0; 21257 $2_1 = global$0 - 16 | 0; 21258 global$0 = $2_1; 21259 $0_1 = HEAP32[$0_1 >> 2]; 21260 block : { 21261 if (!(HEAPU8[$1_1 + 11 | 0] & 24)) { 21262 $0_1 = FUNCTION_TABLE[HEAP32[HEAP32[$1_1 + 4 >> 2] + 16 >> 2]](HEAP32[$1_1 >> 2], $0_1) | 0; 21263 break block; 21264 } 21265 HEAP32[$2_1 + 12 >> 2] = 0; 21266 $5_1 = $1_1; 21267 $6_1 = $2_1 + 12 | 0; 21268 block1 : { 21269 if ($0_1 >>> 0 >= 128) { 21270 $3_1 = $0_1 & 63 | -128; 21271 $1_1 = $0_1 >>> 6 | 0; 21272 if ($0_1 >>> 0 < 2048) { 21273 HEAP8[$2_1 + 13 | 0] = $3_1; 21274 HEAP8[$2_1 + 12 | 0] = $1_1 | 192; 21275 $0_1 = 2; 21276 break block1; 21277 } 21278 $4_1 = $0_1 >>> 12 | 0; 21279 $1_1 = $1_1 & 63 | -128; 21280 if ($0_1 >>> 0 <= 65535) { 21281 HEAP8[$2_1 + 14 | 0] = $3_1; 21282 HEAP8[$2_1 + 13 | 0] = $1_1; 21283 HEAP8[$2_1 + 12 | 0] = $4_1 | 224; 21284 $0_1 = 3; 21285 break block1; 21286 } 21287 HEAP8[$2_1 + 15 | 0] = $3_1; 21288 HEAP8[$2_1 + 14 | 0] = $1_1; 21289 HEAP8[$2_1 + 13 | 0] = $4_1 & 63 | -128; 21290 HEAP8[$2_1 + 12 | 0] = $0_1 >>> 18 | -16; 21291 $0_1 = 4; 21292 break block1; 21293 } 21294 HEAP8[$2_1 + 12 | 0] = $0_1; 21295 $0_1 = 1; 21296 } 21297 $0_1 = $144($5_1, $6_1, $0_1); 21298 } 21299 global$0 = $2_1 + 16 | 0; 21300 return $0_1 | 0; 21301 } 21302 21303 function $166($0_1, $1_1) { 21304 $0_1 = $0_1 | 0; 21305 $1_1 = $1_1 | 0; 21306 return 0; 21307 } 21308 21309 function $167($0_1) { 21310 $0_1 = $0_1 | 0; 21311 wasm2js_trap(); 21312 } 21313 21314 function $168($0_1, $1_1, $2_1) { 21315 var $3_1 = 0, $4_1 = 0, $5_1 = 0; 21316 block : { 21317 if (!$2_1) { 21318 break block 21319 } 21320 while (1) { 21321 $3_1 = HEAPU8[$0_1 | 0]; 21322 $4_1 = HEAPU8[$1_1 | 0]; 21323 if (($3_1 | 0) == ($4_1 | 0)) { 21324 $0_1 = $0_1 + 1 | 0; 21325 $1_1 = $1_1 + 1 | 0; 21326 $2_1 = $2_1 - 1 | 0; 21327 if ($2_1) { 21328 continue 21329 } 21330 break block; 21331 } 21332 break; 21333 }; 21334 $5_1 = $3_1 - $4_1 | 0; 21335 } 21336 return $5_1; 21337 } 21338 21339 function $169($0_1, $1_1, $2_1, $3_1, $4_1) { 21340 var $5_1 = 0, $6_1 = 0, $7_1 = 0, $8_1 = 0, $9_1 = 0, $10_1 = 0, $11_1 = 0, $12_1 = 0, $13_1 = 0, $14_1 = 0, $15_1 = 0, $16_1 = 0; 21341 $11_1 = $3_1; 21342 $12_1 = __wasm_i64_mul($3_1, 0, $1_1, 0); 21343 $13_1 = i64toi32_i32$HIGH_BITS; 21344 $7_1 = $4_1; 21345 $6_1 = $3_1; 21346 $10_1 = 32; 21347 if (($10_1 & 63) >>> 0 >= 32) { 21348 $3_1 = $7_1 >>> $5_1 | 0 21349 } else { 21350 $8_1 = $7_1 >>> $5_1 | 0; 21351 $3_1 = ((1 << $5_1) - 1 & $7_1) << 32 - $5_1 | $6_1 >>> $5_1; 21352 } 21353 $4_1 = $8_1; 21354 $16_1 = __wasm_i64_mul($1_1, $14_1, $3_1, $8_1); 21355 $14_1 = i64toi32_i32$HIGH_BITS; 21356 $8_1 = $2_1; 21357 $7_1 = $1_1; 21358 $1_1 = $11_1; 21359 if (($10_1 & 63) >>> 0 >= 32) { 21360 $6_1 = 0; 21361 $15_1 = $8_1 >>> $5_1 | 0; 21362 } else { 21363 $6_1 = $8_1 >>> $5_1 | 0; 21364 $15_1 = ((1 << $5_1) - 1 & $8_1) << 32 - $5_1 | $7_1 >>> $5_1; 21365 } 21366 $11_1 = $6_1; 21367 $10_1 = __wasm_i64_mul($1_1, $9_1, $15_1, $6_1); 21368 $9_1 = i64toi32_i32$HIGH_BITS + $14_1 | 0; 21369 $5_1 = $10_1 + $16_1 | 0; 21370 $9_1 = $5_1 >>> 0 < $10_1 >>> 0 ? $9_1 + 1 | 0 : $9_1; 21371 $1_1 = $5_1; 21372 $2_1 = $9_1; 21373 $6_1 = $5_1; 21374 $10_1 = 32; 21375 $7_1 = 0; 21376 if (($10_1 & 63) >>> 0 >= 32) { 21377 $8_1 = $5_1 << $7_1; 21378 $10_1 = 0; 21379 } else { 21380 $8_1 = (1 << $7_1) - 1 & $6_1 >>> 32 - $7_1 | $9_1 << $7_1; 21381 $10_1 = $6_1 << $7_1; 21382 } 21383 $5_1 = $8_1 + $13_1 | 0; 21384 $7_1 = $10_1 + $12_1 | 0; 21385 $5_1 = $10_1 >>> 0 > $7_1 >>> 0 ? $5_1 + 1 | 0 : $5_1; 21386 $9_1 = $0_1; 21387 HEAP32[$9_1 >> 2] = $7_1; 21388 HEAP32[$9_1 + 4 >> 2] = $5_1; 21389 $9_1 = $13_1; 21390 $12_1 = ($9_1 | 0) == ($5_1 | 0) & $7_1 >>> 0 < $12_1 >>> 0 | $5_1 >>> 0 < $9_1 >>> 0; 21391 $13_1 = 0; 21392 $4_1 = __wasm_i64_mul($3_1, $4_1, $15_1, $11_1); 21393 $7_1 = i64toi32_i32$HIGH_BITS; 21394 $10_1 = 0; 21395 $8_1 = $2_1; 21396 $5_1 = $14_1; 21397 $9_1 = ($8_1 | 0) == ($5_1 | 0) & $1_1 >>> 0 < $16_1 >>> 0 | $5_1 >>> 0 > $8_1 >>> 0; 21398 $5_1 = 32; 21399 $6_1 = 0; 21400 if (($5_1 & 63) >>> 0 >= 32) { 21401 $8_1 = $9_1 << $6_1; 21402 $11_1 = 0; 21403 } else { 21404 $8_1 = (1 << $6_1) - 1 & $9_1 >>> 32 - $6_1 | $10_1 << $6_1; 21405 $11_1 = $9_1 << $6_1; 21406 } 21407 $3_1 = $8_1; 21408 $8_1 = $2_1; 21409 $10_1 = $1_1; 21410 if (($5_1 & 63) >>> 0 >= 32) { 21411 $9_1 = 0; 21412 $5_1 = $8_1 >>> $6_1 | 0; 21413 } else { 21414 $9_1 = $8_1 >>> $6_1 | 0; 21415 $5_1 = ((1 << $6_1) - 1 & $8_1) << 32 - $6_1 | $10_1 >>> $6_1; 21416 } 21417 $7_1 = $7_1 + ($3_1 | $9_1) | 0; 21418 $5_1 = $5_1 | $11_1; 21419 $6_1 = $4_1 + $5_1 | 0; 21420 $7_1 = $6_1 >>> 0 < $5_1 >>> 0 ? $7_1 + 1 | 0 : $7_1; 21421 $5_1 = $6_1; 21422 $6_1 = $7_1 + $13_1 | 0; 21423 $8_1 = $5_1 + $12_1 | 0; 21424 $6_1 = $5_1 >>> 0 > $8_1 >>> 0 ? $6_1 + 1 | 0 : $6_1; 21425 $10_1 = $0_1; 21426 HEAP32[$10_1 + 8 >> 2] = $8_1; 21427 HEAP32[$10_1 + 12 >> 2] = $6_1; 21428 } 21429 21430 function __wasm_ctz_i32($0_1) { 21431 if ($0_1) { 21432 return 31 - Math_clz32($0_1 ^ $0_1 - 1) | 0 21433 } 21434 return 32; 21435 } 21436 21437 function __wasm_i64_mul($0_1, $1_1, $2_1, $3_1) { 21438 var $4_1 = 0, $5_1 = 0; 21439 $4_1 = $2_1 >>> 16 | 0; 21440 $5_1 = $0_1 >>> 16 | 0; 21441 $1_1 = (Math_imul($4_1, $5_1) + Math_imul($1_1, $2_1) | 0) + Math_imul($0_1, $3_1) | 0; 21442 $2_1 = $2_1 & 65535; 21443 $0_1 = $0_1 & 65535; 21444 $3_1 = Math_imul($2_1, $0_1); 21445 $2_1 = ($3_1 >>> 16 | 0) + Math_imul($2_1, $5_1) | 0; 21446 $1_1 = $1_1 + ($2_1 >>> 16 | 0) | 0; 21447 $2_1 = Math_imul($0_1, $4_1) + ($2_1 & 65535) | 0; 21448 i64toi32_i32$HIGH_BITS = $1_1 + ($2_1 >>> 16 | 0) | 0; 21449 return $3_1 & 65535 | $2_1 << 16; 21450 } 21451 21452 function __wasm_i64_udiv($0_1, $1_1, $2_1, $3_1) { 21453 var $4_1 = 0, $5_1 = 0, $6_1 = 0, $7_1 = 0, $8_1 = 0, $9_1 = 0, $10_1 = 0, $11_1 = 0, $12_1 = 0, $13_1 = 0, $14_1 = 0, $15_1 = 0, $16_1 = 0; 21454 $12_1 = $2_1; 21455 $11_1 = $3_1; 21456 $7_1 = $0_1; 21457 __inlined_func$_ZN17compiler_builtins3int4udiv10divmod_u6417h6026910b5ed08e40E$3 : { 21458 label$1 : { 21459 label$2 : { 21460 label$3 : { 21461 label$4 : { 21462 label$5 : { 21463 label$6 : { 21464 label$7 : { 21465 label$8 : { 21466 label$9 : { 21467 label$11 : { 21468 $4_1 = $1_1; 21469 if ($4_1) { 21470 $2_1 = $3_1; 21471 $3_1 = $12_1; 21472 if (!$3_1) { 21473 break label$11 21474 } 21475 if (!$2_1) { 21476 break label$9 21477 } 21478 $4_1 = Math_clz32($2_1) - Math_clz32($4_1) | 0; 21479 if ($4_1 >>> 0 <= 31) { 21480 break label$8 21481 } 21482 break label$2; 21483 } 21484 $0_1 = $11_1; 21485 if (($0_1 | 0) == 1 | $0_1 >>> 0 > 1) { 21486 break label$2 21487 } 21488 $4_1 = ($7_1 >>> 0) / ($2_1 >>> 0) | 0; 21489 i64toi32_i32$HIGH_BITS = 0; 21490 $6_1 = $4_1; 21491 break __inlined_func$_ZN17compiler_builtins3int4udiv10divmod_u6417h6026910b5ed08e40E$3; 21492 } 21493 $3_1 = $11_1; 21494 if (!$7_1) { 21495 break label$7 21496 } 21497 if (!$3_1) { 21498 break label$6 21499 } 21500 if ($3_1 & $3_1 - 1) { 21501 break label$6 21502 } 21503 $6_1 = $4_1 >>> __wasm_ctz_i32($3_1) | 0; 21504 i64toi32_i32$HIGH_BITS = 0; 21505 break __inlined_func$_ZN17compiler_builtins3int4udiv10divmod_u6417h6026910b5ed08e40E$3; 21506 } 21507 if (!($3_1 & $3_1 - 1)) { 21508 break label$5 21509 } 21510 $4_1 = (Math_clz32($3_1) + 33 | 0) - Math_clz32($4_1) | 0; 21511 $3_1 = 0 - $4_1 | 0; 21512 break label$3; 21513 } 21514 $3_1 = 63 - $4_1 | 0; 21515 $4_1 = $4_1 + 1 | 0; 21516 break label$3; 21517 } 21518 i64toi32_i32$HIGH_BITS = 0; 21519 $6_1 = ($4_1 >>> 0) / ($3_1 >>> 0) | 0; 21520 break __inlined_func$_ZN17compiler_builtins3int4udiv10divmod_u6417h6026910b5ed08e40E$3; 21521 } 21522 $4_1 = Math_clz32($3_1) - Math_clz32($4_1) | 0; 21523 if ($4_1 >>> 0 < 31) { 21524 break label$4 21525 } 21526 break label$2; 21527 } 21528 if (($3_1 | 0) == 1) { 21529 break label$1 21530 } 21531 $0_1 = $1_1; 21532 $6_1 = $7_1; 21533 $8_1 = __wasm_ctz_i32($3_1); 21534 $5_1 = $8_1 & 31; 21535 if (($8_1 & 63) >>> 0 >= 32) { 21536 $2_1 = 0; 21537 $6_1 = $0_1 >>> $5_1 | 0; 21538 } else { 21539 $2_1 = $0_1 >>> $5_1 | 0; 21540 $6_1 = ((1 << $5_1) - 1 & $0_1) << 32 - $5_1 | $6_1 >>> $5_1; 21541 } 21542 i64toi32_i32$HIGH_BITS = $2_1; 21543 break __inlined_func$_ZN17compiler_builtins3int4udiv10divmod_u6417h6026910b5ed08e40E$3; 21544 } 21545 $3_1 = 63 - $4_1 | 0; 21546 $4_1 = $4_1 + 1 | 0; 21547 } 21548 $6_1 = $1_1; 21549 $8_1 = $4_1 & 63; 21550 $5_1 = $8_1 & 31; 21551 if (($8_1 & 63) >>> 0 >= 32) { 21552 $2_1 = 0; 21553 $9_1 = $6_1 >>> $5_1 | 0; 21554 } else { 21555 $2_1 = $6_1 >>> $5_1 | 0; 21556 $9_1 = ((1 << $5_1) - 1 & $6_1) << 32 - $5_1 | $0_1 >>> $5_1; 21557 } 21558 $13_1 = $2_1; 21559 $2_1 = $1_1; 21560 $6_1 = $7_1; 21561 $8_1 = $3_1 & 63; 21562 $5_1 = $8_1 & 31; 21563 if (($8_1 & 63) >>> 0 >= 32) { 21564 $0_1 = $6_1 << $5_1; 21565 $7_1 = 0; 21566 } else { 21567 $0_1 = (1 << $5_1) - 1 & $6_1 >>> 32 - $5_1 | $2_1 << $5_1; 21568 $7_1 = $6_1 << $5_1; 21569 } 21570 $1_1 = $0_1; 21571 if ($4_1) { 21572 $5_1 = $12_1 - 1 | 0; 21573 $14_1 = $5_1; 21574 $3_1 = $11_1 - 1 | 0; 21575 $15_1 = ($5_1 | 0) != -1 ? $3_1 + 1 | 0 : $3_1; 21576 while (1) { 21577 $0_1 = $9_1; 21578 $2_1 = $13_1 << 1 | $0_1 >>> 31; 21579 $9_1 = $0_1 << 1 | $1_1 >>> 31; 21580 $6_1 = $9_1; 21581 $5_1 = $15_1 - (($6_1 >>> 0 > $14_1 >>> 0) + $2_1 | 0) | 0; 21582 $0_1 = $5_1 >> 31; 21583 $10_1 = $5_1 >> 31; 21584 $8_1 = $10_1 & $12_1; 21585 $9_1 = $6_1 - $8_1 | 0; 21586 $13_1 = $2_1 - (($0_1 & $11_1) + ($6_1 >>> 0 < $8_1 >>> 0) | 0) | 0; 21587 $3_1 = $7_1; 21588 $0_1 = $1_1 << 1 | $3_1 >>> 31; 21589 $7_1 = $16_1 | $3_1 << 1; 21590 $1_1 = $0_1; 21591 $10_1 = $10_1 & 1; 21592 $16_1 = $10_1; 21593 $4_1 = $4_1 - 1 | 0; 21594 if ($4_1) { 21595 continue 21596 } 21597 break; 21598 }; 21599 } 21600 $3_1 = $7_1; 21601 i64toi32_i32$HIGH_BITS = $1_1 << 1 | $3_1 >>> 31; 21602 $6_1 = $10_1 | $3_1 << 1; 21603 break __inlined_func$_ZN17compiler_builtins3int4udiv10divmod_u6417h6026910b5ed08e40E$3; 21604 } 21605 $7_1 = 0; 21606 $1_1 = 0; 21607 } 21608 i64toi32_i32$HIGH_BITS = $1_1; 21609 $6_1 = $7_1; 21610 } 21611 return $6_1; 21612 } 21613 21614 function __wasm_rotl_i32($0_1) { 21615 var $1_1 = 0; 21616 $1_1 = $0_1 & 31; 21617 $0_1 = 0 - $0_1 & 31; 21618 return (-1 >>> $1_1 & -2) << $1_1 | (-1 << $0_1 & -2) >>> $0_1; 21619 } 21620 21621 bufferView = HEAPU8; 21622 initActiveSegments(imports); 21623 var FUNCTION_TABLE = [null, $118, $90, $68, $147, $69, $88, $26, $28, $80, $27, $3, $74, $76, $67, $75, $46, $79, $78, $81, $77, $164, $132, $161, $85, $165, $117, $163, $89, $87, $86, $91, $96, $92, $111, $110, $115, $88, $109, $107, $108, $93, $106, $113, $112, $114, $105, $104, $92, $127, $126, $128, $125, $68, $153, $118, $149, $150, $158, $162, $160, $166, $167, $167]; 21624 function __wasm_memory_size() { 21625 return buffer.byteLength >> 16; 21626 } 21627 21628 function __wasm_memory_grow(pagesToAdd) { 21629 pagesToAdd = pagesToAdd | 0; 21630 var oldPages = __wasm_memory_size() | 0; 21631 var newPages = oldPages + pagesToAdd | 0; 21632 if ((oldPages < newPages) && (newPages < 65536)) { 21633 var newBuffer = new ArrayBuffer(newPages << 16); 21634 var newHEAP8 = new Int8Array(newBuffer); 21635 newHEAP8.set(HEAP8); 21636 HEAP8 = new Int8Array(newBuffer); 21637 HEAP16 = new Int16Array(newBuffer); 21638 HEAP32 = new Int32Array(newBuffer); 21639 HEAPU8 = new Uint8Array(newBuffer); 21640 HEAPU16 = new Uint16Array(newBuffer); 21641 HEAPU32 = new Uint32Array(newBuffer); 21642 HEAPF32 = new Float32Array(newBuffer); 21643 HEAPF64 = new Float64Array(newBuffer); 21644 buffer = newBuffer; 21645 bufferView = HEAPU8; 21646 } 21647 return oldPages; 21648 } 21649 21650 return { 21651 "memory": Object.create(Object.prototype, { 21652 "grow": { 21653 "value": __wasm_memory_grow 21654 }, 21655 "buffer": { 21656 "get": function () { 21657 return buffer; 21658 } 21659 21660 } 21661 }), 21662 "alloc": $29, 21663 "dealloc": $30, 21664 "handle": $31, 21665 "out_len": $32 21666 }; 21667} 21668 21669var retasmFunc = asmFunc({ 21670}); 21671export var memory = retasmFunc.memory; 21672export var alloc = retasmFunc.alloc; 21673export var dealloc = retasmFunc.dealloc; 21674export var handle = retasmFunc.handle; 21675export var out_len = retasmFunc.out_len;