← Back to branch summary

~ubuntu-branches/ubuntu/vivid/emscripten/vivid

« back to all changes in this revision

Viewing changes to tools/eliminator/eliminator-test.js

  • Committer: Package Import Robot
  • Author(s): Sylvestre Ledru
  • Date: 2013-05-02 13:11:51 UTC
  • Revision ID: package-import@ubuntu.com-20130502131151-q8dvteqr1ef2x7xz
Tags: upstream-1.4.1~20130504~adb56cb
Import upstream version 1.4.1~20130504~adb56cb

Show diffs side-by-side

added added

removed removed

Lines of Context:
tools/eliminator/eliminator-test.js
 
1
function a($directory) {
 
2
  var $1 = _strlen($directory);
 
3
  var $p_0 = $directory + $1 | 0;
 
4
  chak($p_0);
 
5
  var $210 = HEAP32[100]; // heaps alias each other! so this cannot be eliminated
 
6
  HEAP32[1e3] = HEAP32[5];
 
7
  HEAP32[90] = $210;
 
8
  chak();
 
9
  var $210a = HEAP32[100]; // function calls can also modify memory
 
10
  something();
 
11
  HEAP32[90] = $210a;
 
12
  chak();
 
13
  var $a = $hack; // no mem use (just a global), so ok to eliminate
 
14
  HEAP32[1e3] = HEAP32[5];
 
15
  HEAP32[90] = $a;
 
16
  chak();
 
17
  var $bb = HEAP32[11]; // ok to eliminate
 
18
  var $b = ($bb+7)|0; // ok to eliminate by itself, but not with inlined $bb which is mem-using!
 
19
  HEAP32[1e3] = HEAP32[5];
 
20
  HEAP32[90] = $b;
 
21
  chak();
 
22
  var $bb2 = HEAP32[11];
 
23
  HEAP32[111] = 321;
 
24
  var $b2 = ($bb2+7)|0;
 
25
  HEAP32[1e3] = HEAP32[5];
 
26
  HEAP32[90] = $b2;
 
27
  chak();
 
28
  var $d = HEAP32[100]; // alias on next line, but that is where we are consumed - so ok.
 
29
  HEAP32[1e3] = $d;
 
30
  chak();
 
31
  var $e = func();
 
32
  HEAP32[1e3] = $e;
 
33
  chak();
 
34
  var $e2 = func();
 
35
  tor($e2);
 
36
  chak();
 
37
  var $e3 = HEAP[9];
 
38
  tor($e3);
 
39
  barrier(); // same stuff, but with a var on top and assigns as the first and only def
 
40
  var $$210, $$210a, $$a, $$bb, $$b, $$bb2, $$b2, $$d, $$e, $$e2, $$e3;
 
41
  $$210 = HEAP32[100]; // heaps alias each other! so this cannot be eliminated
 
42
  HEAP32[1e3] = HEAP32[5];
 
43
  HEAP32[90] = $$210;
 
44
  chak();
 
45
  $$210a = HEAP32[100]; // function calls can also modify memory
 
46
  something();
 
47
  HEAP32[90] = $$210a;
 
48
  chak();
 
49
  $$a = $$hack; // no mem use, so ok to eliminate
 
50
  HEAP32[1e3] = HEAP32[5];
 
51
  HEAP32[90] = $$a;
 
52
  chak();
 
53
  $$bb = HEAP32[11]; // ok to eliminate
 
54
  $$b = ($$bb+7)|0; // ok to eliminate by itself, but not with inlined $$bb which is mem-using!
 
55
  HEAP32[1e3] = HEAP32[5];
 
56
  HEAP32[90] = $$b;
 
57
  chak();
 
58
  $$bb2 = HEAP32[11];
 
59
  HEAP32[111] = 321;
 
60
  $$b2 = ($$bb2+7)|0;
 
61
  HEAP32[1e3] = HEAP32[5];
 
62
  HEAP32[90] = $$b2;
 
63
  chak();
 
64
  $$d = HEAP32[100]; // alias on next line, but that is where we are consumed - so ok.
 
65
  HEAP32[1e3] = $$d;
 
66
  chak();
 
67
  $$e = func();
 
68
  HEAP32[1e3] = $$e;
 
69
  chak();
 
70
  $$e2 = func();
 
71
  tor($$e2);
 
72
  chak();
 
73
  $$e3 = HEAP[9];
 
74
  tor($$e3);
 
75
  barrier();
 
76
  var $65, $image, $51$s2, $71;
 
77
  var $66 = HEAP32[$65 >> 2];
 
78
  var $71 = $66 - _int_ceildiv(HEAP32[$image >> 2], HEAP32[$51$s2]) | 0;
 
79
  HEAP32[$65 >> 2] = _int_ceildivpow2($71, HEAP32[$51$s2 + 10]);
 
80
  barr();
 
81
  var ONCE = sheep();
 
82
  while (ONCE) {
 
83
    work();
 
84
  }
 
85
  var ONCEb = 75;
 
86
  while (ONCEb) {
 
87
    work();
 
88
  }
 
89
  var $26 = __ZL3minIiET_S0_S0_12(4096, 4096 - $16 | 0); // cannot eliminate this because the call might modify FUNCTION_TABLE
 
90
  var $27 = FUNCTION_TABLE[$22]($18, $this + ($16 + 27) | 0, $26);
 
91
  print($27);
 
92
  chak();
 
93
  var zzz = 10;
 
94
  do {
 
95
    print(zzz);
 
96
  } while (0);
 
97
  var zzz1 = 10;
 
98
  do {
 
99
    print(zzz1);
 
100
  } while (1); // cannot eliminate a do-while that is not one-time
 
101
}
 
102
function b() {
 
103
  var $148 = _sqlite3Strlen30($147);
 
104
  var $150 = HEAP32[$pExpr + 16 >> 2];
 
105
  if (($150 | 0) == 0) {
 
106
    var $156 = 0;
 
107
  } else {
 
108
    var $156 = HEAP32[$150 >> 2];
 
109
  }
 
110
  var $156;
 
111
  HEAP32[$139 + ($136 << 4) + 4 >> 2] = _sqlite3FindFunction($145, $147, $148, $156, $135, 0);
 
112
  farr();
 
113
  var $a = f1();
 
114
  var $b = f2() + $a; // this could be reordered to facilitate optimization
 
115
  f3($b);
 
116
  farr();
 
117
  var finality = cheez();
 
118
  return finality;
 
119
}
 
120
function c() {
 
121
  var x = MEM[100], y = callMe(5), z = glob; // do not eliminate vars with multiple variables, if there is a call!
 
122
  var w = x*2;
 
123
  zoom(z);
 
124
  hail(w);
 
125
  sunk(y);
 
126
  barrier();
 
127
  var x2 = MEM[100], y2 = $callMe2, z2 = glob; // no call, so ok
 
128
  var w2 = x2*2;
 
129
  zoom(z2);
 
130
  hail(w2);
 
131
  sunk(y2);
 
132
  var fly = you(fools);
 
133
  var one, two = three(); // more than one var here, so cannot eliminate |two=|, oh well
 
134
  var noneed;
 
135
  noneed = fools(you);
 
136
  var noneed2;
 
137
  noneed2 += fools(you2);
 
138
  return;
 
139
}
 
140
function f() {
 
141
  var unused;
 
142
  var x = GLOB[1];
 
143
  var y = x + 1;
 
144
  var z = y / 2;
 
145
  HEAP[123] = z;
 
146
}
 
147
function g(a1, a2) {
 
148
  var a = 1;
 
149
  var b = a * 2;
 
150
  var c = b - 1;
 
151
  var qqq = "qwe";
 
152
  a = c;
 
153
  foo(c);
 
154
  var ww = 1, www, zzz = 2;
 
155
  foo(zzz);
 
156
  for (var i = 0; i < 5; i++) {
 
157
    var q = {
 
158
      a: 1
 
159
    } + [ 2, 3 ];
 
160
  }
 
161
  for (var iterator in SOME_GLOBAL) {
 
162
    quux(iterator);
 
163
  }
 
164
  var $0 = HEAP[5];
 
165
  MAYBE_HEAP[myglobal] = 123;
 
166
  var $1 = $0 < 0;
 
167
  if ($1) {
 
168
    __label__ = 1;
 
169
  } else {
 
170
    __label__ = 2;
 
171
  }
 
172
  var sadijn = new asd;
 
173
  sadijn2 = "qwe%sert";
 
174
  this.Module || (this.Module = {});
 
175
  var obj = {
 
176
    'quoted': 1,
 
177
    "doublequoted": 2,
 
178
    unquoted: 3,
 
179
    4: 5
 
180
  };
 
181
}
 
182
function h() {
 
183
  var out;
 
184
  bar(hello);
 
185
  var hello = 5;
 
186
  if (0) {
 
187
    var sb1 = 21;
 
188
  }
 
189
  out = sb1;
 
190
  if (0) {
 
191
    var sb2 = 23;
 
192
  } else {
 
193
    out = sb2;
 
194
  }
 
195
  if (0) {
 
196
    out = sb3;
 
197
  } else {
 
198
    var sb3 = 23;
 
199
  }
 
200
  for (var it = 0; it < 5; it++) {
 
201
    x = y ? x + 1 : 7;
 
202
    var x = -5;
 
203
  }
 
204
  var oneUse = glob; // for now, cannot eliminate into body or else of if
 
205
  if (1) {
 
206
    otherGlob = oneUse;
 
207
    breakMe();
 
208
  }
 
209
  var oneUse2 = glob2;
 
210
  while (1) {
 
211
    otherGlob2 = oneUse2;
 
212
    breakMe();
 
213
  }
 
214
  return out;
 
215
}
 
216
function strtok_part(b, j, f) {
 
217
  var a;
 
218
  for (;;) {
 
219
    h = a == 13 ? h : 0;
 
220
    a = HEAP[d + h];
 
221
    if (a == g != 0) break;
 
222
    var h = h + 1;
 
223
    if (a != 0) a = 13;
 
224
  }
 
225
}
 
226
function py() {
 
227
  var $4 = HEAP[__PyThreadState_Current];
 
228
  var $5 = $4 + 12;
 
229
  var $7 = HEAP[$5] + 1;
 
230
  var $8 = $7 + 12;
 
231
  HEAP[$8] = 99;
 
232
}
 
233
var anon = function(x) {
 
234
  var $4 = HEAP[__PyThreadState_Current];
 
235
  var $5 = $4 + 12;
 
236
  var $7 = HEAP[$5] + 1;
 
237
  var $8 = $4 + 12;
 
238
  HEAP[$8] = $7;
 
239
}
 
240
function r($0) {
 
241
  HEAP[$0 + 5 + 2] = 99+5+2+1;
 
242
}
 
243
function t() {
 
244
  var $cmp2=($10) < ($11);
 
245
  if ($cmp2) { __label__ = 3; }
 
246
  var $cmp3=($12) < ($13);
 
247
  if (!($cmp3)) { __label__ = 4; }
 
248
}
 
249
function f2() {
 
250
  var $arrayidx64_phi_trans_insert = $vla + ($storemerge312 << 2) | 0;
 
251
  var $_pre = HEAPU32[$arrayidx64_phi_trans_insert >> 2];
 
252
  var $phitmp = $storemerge312 + 1 | 0;
 
253
  var $storemerge312 = $phitmp;
 
254
  var $8 = $_pre;
 
255
  c($8);
 
256
}
 
257
function f3($s, $tree, $k) {
 
258
  // HEAP vars alias each other, and the loop can confuse us
 
259
  var $0 = HEAPU32[($s + 2908 + ($k << 2) | 0) >> 2];
 
260
  while (1) {
 
261
    HEAP32[($s + 2908 + ($storemerge_in << 2) | 0) >> 2] = $9;
 
262
  }
 
263
  HEAP32[($s + 2908 + ($storemerge_in << 2) | 0) >> 2] = $0;
 
264
}
 
265
function llvm3_1() {
 
266
  while (check()) {
 
267
    var $inc = $aj_0 + 1;
 
268
    if ($curri_01 % $zj_0 == 0) {
 
269
      break;
 
270
    }
 
271
    var $j_0 = $inc;
 
272
    run($j_0 / 2);
 
273
  }
 
274
}
 
275
function _inflate($strm, $flush) {
 
276
  var __stackBase__ = STACKTOP;
 
277
  STACKTOP += 4;
 
278
  var __label__;
 
279
  var $hbuf = __stackBase__;
 
280
  var $cmp = ($strm | 0) == 0;
 
281
  $_$2 : do {
 
282
    if ($cmp) {
 
283
      var $retval_0 = -2;
 
284
    } else {
 
285
      var $state1 = $strm + 28 | 0;
 
286
      var $0 = HEAPU32[$state1 >> 2];
 
287
      var $cmp2 = ($0 | 0) == 0;
 
288
      if ($cmp2) {
 
289
        var $retval_0 = -2;
 
290
        break;
 
291
      }
 
292
      var $next_out = $strm + 12 | 0;
 
293
      var $1 = HEAP32[$next_out >> 2];
 
294
      var $cmp4 = ($1 | 0) == 0;
 
295
      if ($cmp4) {
 
296
        var $retval_0 = -2;
 
297
        break;
 
298
      }
 
299
      var $next_in = $strm | 0;
 
300
      var $2 = HEAP32[$next_in >> 2];
 
301
      var $cmp6 = ($2 | 0) == 0;
 
302
      if ($cmp6) {
 
303
        var $avail_in = $strm + 4 | 0;
 
304
        var $3 = HEAP32[$avail_in >> 2];
 
305
        var $cmp7 = ($3 | 0) == 0;
 
306
        if (!$cmp7) {
 
307
          var $retval_0 = -2;
 
308
          break;
 
309
        }
 
310
      }
 
311
      var $4 = $0;
 
312
      var $mode = $0 | 0;
 
313
      var $5 = HEAP32[$mode >> 2];
 
314
      var $cmp9 = ($5 | 0) == 11;
 
315
      if ($cmp9) {
 
316
        HEAP32[$mode >> 2] = 12;
 
317
        var $_pre = HEAP32[$next_out >> 2];
 
318
        var $_pre882 = HEAP32[$next_in >> 2];
 
319
        var $8 = $_pre;
 
320
        var $7 = $_pre882;
 
321
        var $6 = 12;
 
322
      } else {
 
323
        var $8 = $1;
 
324
        var $7 = $2;
 
325
        var $6 = $5;
 
326
      }
 
327
      var $6;
 
328
      var $7;
 
329
      var $8;
 
330
      var $avail_out = $strm + 16 | 0;
 
331
      var $9 = HEAP32[$avail_out >> 2];
 
332
      var $avail_in15 = $strm + 4 | 0;
 
333
      var $10 = HEAPU32[$avail_in15 >> 2];
 
334
      var $11 = $0 + 56 | 0;
 
335
      var $12 = HEAP32[$11 >> 2];
 
336
      var $13 = $0 + 60 | 0;
 
337
      var $14 = HEAP32[$13 >> 2];
 
338
      var $15 = $0 + 8 | 0;
 
339
      var $16 = $0 + 24 | 0;
 
340
      var $arrayidx = $hbuf | 0;
 
341
      var $arrayidx40 = $hbuf + 1 | 0;
 
342
      var $17 = $0 + 16 | 0;
 
343
      var $head = $0 + 32 | 0;
 
344
      var $18 = $head;
 
345
      var $msg = $strm + 24 | 0;
 
346
      var $19 = $0 + 36 | 0;
 
347
      var $20 = $0 + 20 | 0;
 
348
      var $adler = $strm + 48 | 0;
 
349
      var $21 = $0 + 64 | 0;
 
350
      var $22 = $0 + 12 | 0;
 
351
      var $flush_off = $flush - 5 | 0;
 
352
      var $23 = $flush_off >>> 0 < 2;
 
353
      var $24 = $0 + 4 | 0;
 
354
      var $cmp660 = ($flush | 0) == 6;
 
355
      var $25 = $0 + 7108 | 0;
 
356
      var $26 = $0 + 84 | 0;
 
357
      var $lencode1215 = $0 + 76 | 0;
 
358
      var $27 = $lencode1215;
 
359
      var $28 = $0 + 72 | 0;
 
360
      var $29 = $0 + 7112 | 0;
 
361
      var $30 = $0 + 68 | 0;
 
362
      var $31 = $0 + 44 | 0;
 
363
      var $32 = $0 + 7104 | 0;
 
364
      var $33 = $0 + 48 | 0;
 
365
      var $window = $0 + 52 | 0;
 
366
      var $34 = $window;
 
367
      var $35 = $0 + 40 | 0;
 
368
      var $total_out = $strm + 20 | 0;
 
369
      var $36 = $0 + 28 | 0;
 
370
      var $arrayidx199 = $hbuf + 2 | 0;
 
371
      var $arrayidx202 = $hbuf + 3 | 0;
 
372
      var $37 = $0 + 96 | 0;
 
373
      var $38 = $0 + 100 | 0;
 
374
      var $39 = $0 + 92 | 0;
 
375
      var $40 = $0 + 104 | 0;
 
376
      var $lens = $0 + 112 | 0;
 
377
      var $41 = $lens;
 
378
      var $codes = $0 + 1328 | 0;
 
379
      var $next861 = $0 + 108 | 0;
 
380
      var $42 = $next861;
 
381
      var $43 = $next861 | 0;
 
382
      var $arraydecay860_c = $codes;
 
383
      var $44 = $0 + 76 | 0;
 
384
      var $arraydecay864 = $lens;
 
385
      var $work = $0 + 752 | 0;
 
386
      var $arraydecay867 = $work;
 
387
      var $arrayidx1128 = $0 + 624 | 0;
 
388
      var $45 = $arrayidx1128;
 
389
      var $46 = $0 + 80 | 0;
 
390
      var $47 = $0 + 88 | 0;
 
391
      var $distcode1395 = $0 + 80 | 0;
 
392
      var $48 = $distcode1395;
 
393
      var $ret_0 = 0;
 
394
      var $next_0 = $7;
 
395
      var $put_0 = $8;
 
396
      var $have_0 = $10;
 
397
      var $left_0 = $9;
 
398
      var $hold_0 = $12;
 
399
      var $bits_0 = $14;
 
400
      var $out_0 = $9;
 
401
      var $49 = $6;
 
402
      $_$12 : while (1) {
 
403
        var $49;
 
404
        var $out_0;
 
405
        var $bits_0;
 
406
        var $hold_0;
 
407
        var $left_0;
 
408
        var $have_0;
 
409
        var $put_0;
 
410
        var $next_0;
 
411
        var $ret_0;
 
412
        $_$14 : do {
 
413
          if (($49 | 0) == 0) {
 
414
            var $50 = HEAPU32[$15 >> 2];
 
415
            var $cmp19 = ($50 | 0) == 0;
 
416
            if ($cmp19) {
 
417
              HEAP32[$mode >> 2] = 12;
 
418
              var $ret_0_be = $ret_0;
 
419
              var $next_0_be = $next_0;
 
420
              var $put_0_be = $put_0;
 
421
              var $have_0_be = $have_0;
 
422
              var $left_0_be = $left_0;
 
423
              var $hold_0_be = $hold_0;
 
424
              var $bits_0_be = $bits_0;
 
425
              var $out_0_be = $out_0;
 
426
              __label__ = 268;
 
427
              break;
 
428
            }
 
429
            var $next_1 = $next_0;
 
430
            var $have_1 = $have_0;
 
431
            var $hold_1 = $hold_0;
 
432
            var $bits_1 = $bits_0;
 
433
            while (1) {
 
434
              var $bits_1;
 
435
              var $hold_1;
 
436
              var $have_1;
 
437
              var $next_1;
 
438
              var $cmp24 = $bits_1 >>> 0 < 16;
 
439
              if (!$cmp24) {
 
440
                break;
 
441
              }
 
442
              var $cmp26 = ($have_1 | 0) == 0;
 
443
              if ($cmp26) {
 
444
                var $ret_8 = $ret_0;
 
445
                var $next_58 = $next_1;
 
446
                var $have_58 = 0;
 
447
                var $hold_54 = $hold_1;
 
448
                var $bits_54 = $bits_1;
 
449
                var $out_4 = $out_0;
 
450
                break $_$12;
 
451
              }
 
452
              // XXX first chunk with a difference (no impact)
 
453
              var $dec = $have_1 - 1 | 0;
 
454
              var $incdec_ptr = $next_1 + 1 | 0;
 
455
              var $51 = HEAPU8[$next_1];
 
456
              var $conv = $51 & 255;
 
457
              var $shl = $conv << $bits_1;
 
458
              var $add = $shl + $hold_1 | 0;
 
459
              var $add29 = $bits_1 + 8 | 0;
 
460
              var $next_1 = $incdec_ptr;
 
461
              var $have_1 = $dec;
 
462
              var $hold_1 = $add;
 
463
              var $bits_1 = $add29;
 
464
            }
 
465
            var $and = $50 & 2;
 
466
            var $tobool = ($and | 0) != 0;
 
467
            var $cmp34 = ($hold_1 | 0) == 35615;
 
468
            var $or_cond = $tobool & $cmp34;
 
469
            if ($or_cond) {
 
470
              var $call = _crc32(0, 0, 0);
 
471
              HEAP32[$16 >> 2] = $call;
 
472
              HEAP8[$arrayidx] = 31;
 
473
              HEAP8[$arrayidx40] = -117;
 
474
              var $52 = HEAP32[$16 >> 2];
 
475
              var $call42 = _crc32($52, $arrayidx, 2);
 
476
              HEAP32[$16 >> 2] = $call42;
 
477
              HEAP32[$mode >> 2] = 1;
 
478
              var $ret_0_be = $ret_0;
 
479
              var $next_0_be = $next_1;
 
480
              var $put_0_be = $put_0;
 
481
              var $have_0_be = $have_1;
 
482
              var $left_0_be = $left_0;
 
483
              var $hold_0_be = 0;
 
484
              var $bits_0_be = 0;
 
485
              var $out_0_be = $out_0;
 
486
              __label__ = 268;
 
487
              break;
 
488
            }
 
489
            HEAP32[$17 >> 2] = 0;
 
490
            var $53 = HEAP32[$18 >> 2];
 
491
            var $cmp49 = ($53 | 0) == 0;
 
492
            if ($cmp49) {
 
493
              var $54 = $50;
 
494
            } else {
 
495
              var $done = $53 + 48 | 0;
 
496
              HEAP32[$done >> 2] = -1;
 
497
              var $_pre884 = HEAP32[$15 >> 2];
 
498
              var $54 = $_pre884;
 
499
            }
 
500
            var $54;
 
501
            var $and55 = $54 & 1;
 
502
            var $tobool56 = ($and55 | 0) == 0;
 
503
            do {
 
504
              if (!$tobool56) {
 
505
                var $and58 = $hold_1 << 8;
 
506
                var $shl59 = $and58 & 65280;
 
507
                var $shr60 = $hold_1 >>> 8;
 
508
                var $add61 = $shl59 + $shr60 | 0;
 
509
                var $rem = ($add61 >>> 0) % 31;
 
510
                var $tobool62 = ($rem | 0) == 0;
 
511
                if (!$tobool62) {
 
512
                  break;
 
513
                }
 
514
                var $and66 = $hold_1 & 15;
 
515
                var $cmp67 = ($and66 | 0) == 8;
 
516
                if ($cmp67) {
 
517
                  var $shr74 = $hold_1 >>> 4;
 
518
                  var $sub = $bits_1 - 4 | 0;
 
519
                  var $and76 = $shr74 & 15;
 
520
                  var $add77 = $and76 + 8 | 0;
 
521
                  var $55 = HEAPU32[$19 >> 2];
 
522
                  var $cmp78 = ($55 | 0) == 0;
 
523
                  do {
 
524
                    if (!$cmp78) {
 
525
                      var $cmp83 = $add77 >>> 0 > $55 >>> 0;
 
526
                      if (!$cmp83) {
 
527
                        break;
 
528
                      }
 
529
                      HEAP32[$msg >> 2] = STRING_TABLE.__str3100 | 0;
 
530
                      HEAP32[$mode >> 2] = 29;
 
531
                      var $ret_0_be = $ret_0;
 
532
                      var $next_0_be = $next_1;
 
533
                      var $put_0_be = $put_0;
 
534
                      var $have_0_be = $have_1;
 
535
                      var $left_0_be = $left_0;
 
536
                      var $hold_0_be = $shr74;
 
537
                      var $bits_0_be = $sub;
 
538
                      var $out_0_be = $out_0;
 
539
                      __label__ = 268;
 
540
                      break $_$14;
 
541
                    }
 
542
                    HEAP32[$19 >> 2] = $add77;
 
543
                  } while (0);
 
544
                  var $shl90 = 1 << $add77;
 
545
                  HEAP32[$20 >> 2] = $shl90;
 
546
                  var $call91 = _adler32(0, 0, 0);
 
547
                  HEAP32[$16 >> 2] = $call91;
 
548
                  HEAP32[$adler >> 2] = $call91;
 
549
                  var $and93 = $hold_1 >>> 12;
 
550
                  var $56 = $and93 & 2;
 
551
                  var $57 = $56 ^ 11;
 
552
                  HEAP32[$mode >> 2] = $57;
 
553
                  var $ret_0_be = $ret_0;
 
554
                  var $next_0_be = $next_1;
 
555
                  var $put_0_be = $put_0;
 
556
                  var $have_0_be = $have_1;
 
557
                  var $left_0_be = $left_0;
 
558
                  var $hold_0_be = 0;
 
559
                  var $bits_0_be = 0;
 
560
                  var $out_0_be = $out_0;
 
561
                  __label__ = 268;
 
562
                  break $_$14;
 
563
                }
 
564
                HEAP32[$msg >> 2] = STRING_TABLE.__str299 | 0;
 
565
                HEAP32[$mode >> 2] = 29;
 
566
                var $ret_0_be = $ret_0;
 
567
                var $next_0_be = $next_1;
 
568
                var $put_0_be = $put_0;
 
569
                var $have_0_be = $have_1;
 
570
                var $left_0_be = $left_0;
 
571
                var $hold_0_be = $hold_1;
 
572
                var $bits_0_be = $bits_1;
 
573
                var $out_0_be = $out_0;
 
574
                __label__ = 268;
 
575
                break $_$14;
 
576
              }
 
577
            } while (0);
 
578
            HEAP32[$msg >> 2] = STRING_TABLE.__str198 | 0;
 
579
            HEAP32[$mode >> 2] = 29;
 
580
            var $ret_0_be = $ret_0;
 
581
            var $next_0_be = $next_1;
 
582
            var $put_0_be = $put_0;
 
583
            var $have_0_be = $have_1;
 
584
            var $left_0_be = $left_0;
 
585
            var $hold_0_be = $hold_1;
 
586
            var $bits_0_be = $bits_1;
 
587
            var $out_0_be = $out_0;
 
588
            __label__ = 268;
 
589
            break;
 
590
          } else if (($49 | 0) == 1) {
 
591
            var $next_2 = $next_0;
 
592
            var $have_2 = $have_0;
 
593
            var $hold_2 = $hold_0;
 
594
            var $bits_2 = $bits_0;
 
595
            while (1) {
 
596
              var $bits_2;
 
597
              var $hold_2;
 
598
              var $have_2;
 
599
              var $next_2;
 
600
              var $cmp101 = $bits_2 >>> 0 < 16;
 
601
              if (!$cmp101) {
 
602
                break;
 
603
              }
 
604
              var $cmp105 = ($have_2 | 0) == 0;
 
605
              if ($cmp105) {
 
606
                var $ret_8 = $ret_0;
 
607
                var $next_58 = $next_2;
 
608
                var $have_58 = 0;
 
609
                var $hold_54 = $hold_2;
 
610
                var $bits_54 = $bits_2;
 
611
                var $out_4 = $out_0;
 
612
                break $_$12;
 
613
              }
 
614
              var $dec109 = $have_2 - 1 | 0;
 
615
              var $incdec_ptr110 = $next_2 + 1 | 0;
 
616
              var $58 = HEAPU8[$next_2];
 
617
              var $conv111 = $58 & 255;
 
618
              var $shl112 = $conv111 << $bits_2;
 
619
              var $add113 = $shl112 + $hold_2 | 0;
 
620
              var $add114 = $bits_2 + 8 | 0;
 
621
              var $next_2 = $incdec_ptr110;
 
622
              var $have_2 = $dec109;
 
623
              var $hold_2 = $add113;
 
624
              var $bits_2 = $add114;
 
625
            }
 
626
            HEAP32[$17 >> 2] = $hold_2;
 
627
            var $and120 = $hold_2 & 255;
 
628
            var $cmp121 = ($and120 | 0) == 8;
 
629
            if (!$cmp121) {
 
630
              HEAP32[$msg >> 2] = STRING_TABLE.__str299 | 0;
 
631
              HEAP32[$mode >> 2] = 29;
 
632
              var $ret_0_be = $ret_0;
 
633
              var $next_0_be = $next_2;
 
634
              var $put_0_be = $put_0;
 
635
              var $have_0_be = $have_2;
 
636
              var $left_0_be = $left_0;
 
637
              var $hold_0_be = $hold_2;
 
638
              var $bits_0_be = $bits_2;
 
639
              var $out_0_be = $out_0;
 
640
              __label__ = 268;
 
641
              break;
 
642
            }
 
643
            var $and128 = $hold_2 & 57344;
 
644
            var $tobool129 = ($and128 | 0) == 0;
 
645
            if ($tobool129) {
 
646
              var $59 = HEAPU32[$18 >> 2];
 
647
              var $cmp135 = ($59 | 0) == 0;
 
648
              if ($cmp135) {
 
649
                var $60 = $hold_2;
 
650
              } else {
 
651
                var $shr138 = $hold_2 >>> 8;
 
652
                var $and139 = $shr138 & 1;
 
653
                var $text = $59 | 0;
 
654
                HEAP32[$text >> 2] = $and139;
 
655
                var $_pre887 = HEAP32[$17 >> 2];
 
656
                var $60 = $_pre887;
 
657
              }
 
658
              var $60;
 
659
              var $and143 = $60 & 512;
 
660
              var $tobool144 = ($and143 | 0) == 0;
 
661
              if (!$tobool144) {
 
662
                var $conv147 = $hold_2 & 255;
 
663
                HEAP8[$arrayidx] = $conv147;
 
664
                var $shr149 = $hold_2 >>> 8;
 
665
                var $conv150 = $shr149 & 255;
 
666
                HEAP8[$arrayidx40] = $conv150;
 
667
                var $61 = HEAP32[$16 >> 2];
 
668
                var $call154 = _crc32($61, $arrayidx, 2);
 
669
                HEAP32[$16 >> 2] = $call154;
 
670
              }
 
671
              HEAP32[$mode >> 2] = 2;
 
672
              var $next_3 = $next_2;
 
673
              var $have_3 = $have_2;
 
674
              var $hold_3 = 0;
 
675
              var $bits_3 = 0;
 
676
              __label__ = 44;
 
677
              break;
 
678
            }
 
679
            HEAP32[$msg >> 2] = STRING_TABLE.__str4101 | 0;
 
680
            HEAP32[$mode >> 2] = 29;
 
681
            var $ret_0_be = $ret_0;
 
682
            var $next_0_be = $next_2;
 
683
            var $put_0_be = $put_0;
 
684
            var $have_0_be = $have_2;
 
685
            var $left_0_be = $left_0;
 
686
            var $hold_0_be = $hold_2;
 
687
            var $bits_0_be = $bits_2;
 
688
            var $out_0_be = $out_0;
 
689
            __label__ = 268;
 
690
            break;
 
691
          } else if (($49 | 0) == 2) {
 
692
            var $next_3 = $next_0;
 
693
            var $have_3 = $have_0;
 
694
            var $hold_3 = $hold_0;
 
695
            var $bits_3 = $bits_0;
 
696
            __label__ = 44;
 
697
          } else if (($49 | 0) == 3) {
 
698
            var $next_4 = $next_0;
 
699
            var $have_4 = $have_0;
 
700
            var $hold_4 = $hold_0;
 
701
            var $bits_4 = $bits_0;
 
702
            __label__ = 52;
 
703
          } else if (($49 | 0) == 4) {
 
704
            var $next_5 = $next_0;
 
705
            var $have_5 = $have_0;
 
706
            var $hold_5 = $hold_0;
 
707
            var $bits_5 = $bits_0;
 
708
            __label__ = 60;
 
709
          } else if (($49 | 0) == 5) {
 
710
            var $next_8 = $next_0;
 
711
            var $have_8 = $have_0;
 
712
            var $hold_8 = $hold_0;
 
713
            var $bits_8 = $bits_0;
 
714
            __label__ = 71;
 
715
          } else if (($49 | 0) == 6) {
 
716
            var $_pre888 = HEAP32[$17 >> 2];
 
717
            var $next_11 = $next_0;
 
718
            var $have_11 = $have_0;
 
719
            var $hold_9 = $hold_0;
 
720
            var $bits_9 = $bits_0;
 
721
            var $89 = $_pre888;
 
722
            __label__ = 81;
 
723
            break;
 
724
          } else if (($49 | 0) == 7) {
 
725
            var $next_13 = $next_0;
 
726
            var $have_13 = $have_0;
 
727
            var $hold_10 = $hold_0;
 
728
            var $bits_10 = $bits_0;
 
729
            __label__ = 94;
 
730
          } else if (($49 | 0) == 8) {
 
731
            var $next_15 = $next_0;
 
732
            var $have_15 = $have_0;
 
733
            var $hold_11 = $hold_0;
 
734
            var $bits_11 = $bits_0;
 
735
            __label__ = 107;
 
736
          } else if (($49 | 0) == 9) {
 
737
            var $next_18 = $next_0;
 
738
            var $have_18 = $have_0;
 
739
            var $hold_14 = $hold_0;
 
740
            var $bits_14 = $bits_0;
 
741
            while (1) {
 
742
              var $bits_14;
 
743
              var $hold_14;
 
744
              var $have_18;
 
745
              var $next_18;
 
746
              var $cmp552 = $bits_14 >>> 0 < 32;
 
747
              if (!$cmp552) {
 
748
                break;
 
749
              }
 
750
              var $cmp556 = ($have_18 | 0) == 0;
 
751
              if ($cmp556) {
 
752
                var $ret_8 = $ret_0;
 
753
                var $next_58 = $next_18;
 
754
                var $have_58 = 0;
 
755
                var $hold_54 = $hold_14;
 
756
                var $bits_54 = $bits_14;
 
757
                var $out_4 = $out_0;
 
758
                break $_$12;
 
759
              }
 
760
              var $dec560 = $have_18 - 1 | 0;
 
761
              var $incdec_ptr561 = $next_18 + 1 | 0;
 
762
              var $114 = HEAPU8[$next_18];
 
763
              var $conv562 = $114 & 255;
 
764
              var $shl563 = $conv562 << $bits_14;
 
765
              var $add564 = $shl563 + $hold_14 | 0;
 
766
              var $add565 = $bits_14 + 8 | 0;
 
767
              var $next_18 = $incdec_ptr561;
 
768
              var $have_18 = $dec560;
 
769
              var $hold_14 = $add564;
 
770
              var $bits_14 = $add565;
 
771
            }
 
772
            var $add581 = _llvm_bswap_i32($hold_14);
 
773
            HEAP32[$16 >> 2] = $add581;
 
774
            HEAP32[$adler >> 2] = $add581;
 
775
            HEAP32[$mode >> 2] = 10;
 
776
            var $next_19 = $next_18;
 
777
            var $have_19 = $have_18;
 
778
            var $hold_15 = 0;
 
779
            var $bits_15 = 0;
 
780
            __label__ = 120;
 
781
            break;
 
782
          } else if (($49 | 0) == 10) {
 
783
            var $next_19 = $next_0;
 
784
            var $have_19 = $have_0;
 
785
            var $hold_15 = $hold_0;
 
786
            var $bits_15 = $bits_0;
 
787
            __label__ = 120;
 
788
          } else if (($49 | 0) == 11) {
 
789
            var $next_20 = $next_0;
 
790
            var $have_20 = $have_0;
 
791
            var $hold_16 = $hold_0;
 
792
            var $bits_16 = $bits_0;
 
793
            __label__ = 123;
 
794
          } else if (($49 | 0) == 12) {
 
795
            var $next_21 = $next_0;
 
796
            var $have_21 = $have_0;
 
797
            var $hold_17 = $hold_0;
 
798
            var $bits_17 = $bits_0;
 
799
            __label__ = 124;
 
800
          } else if (($49 | 0) == 13) {
 
801
            var $and681 = $bits_0 & 7;
 
802
            var $shr682 = $hold_0 >>> ($and681 >>> 0);
 
803
            var $sub684 = $bits_0 - $and681 | 0;
 
804
            var $next_23 = $next_0;
 
805
            var $have_23 = $have_0;
 
806
            var $hold_19 = $shr682;
 
807
            var $bits_19 = $sub684;
 
808
            while (1) {
 
809
              var $bits_19;
 
810
              var $hold_19;
 
811
              var $have_23;
 
812
              var $next_23;
 
813
              var $cmp689 = $bits_19 >>> 0 < 32;
 
814
              if (!$cmp689) {
 
815
                break;
 
816
              }
 
817
              var $cmp693 = ($have_23 | 0) == 0;
 
818
              if ($cmp693) {
 
819
                var $ret_8 = $ret_0;
 
820
                var $next_58 = $next_23;
 
821
                var $have_58 = 0;
 
822
                var $hold_54 = $hold_19;
 
823
                var $bits_54 = $bits_19;
 
824
                var $out_4 = $out_0;
 
825
                break $_$12;
 
826
              }
 
827
              var $dec697 = $have_23 - 1 | 0;
 
828
              var $incdec_ptr698 = $next_23 + 1 | 0;
 
829
              var $118 = HEAPU8[$next_23];
 
830
              var $conv699 = $118 & 255;
 
831
              var $shl700 = $conv699 << $bits_19;
 
832
              var $add701 = $shl700 + $hold_19 | 0;
 
833
              var $add702 = $bits_19 + 8 | 0;
 
834
              var $next_23 = $incdec_ptr698;
 
835
              var $have_23 = $dec697;
 
836
              var $hold_19 = $add701;
 
837
              var $bits_19 = $add702;
 
838
            }
 
839
            var $and708 = $hold_19 & 65535;
 
840
            var $shr709 = $hold_19 >>> 16;
 
841
            var $xor = $shr709 ^ 65535;
 
842
            var $cmp710 = ($and708 | 0) == ($xor | 0);
 
843
            if (!$cmp710) {
 
844
              HEAP32[$msg >> 2] = STRING_TABLE.__str7104 | 0;
 
845
              HEAP32[$mode >> 2] = 29;
 
846
              var $ret_0_be = $ret_0;
 
847
              var $next_0_be = $next_23;
 
848
              var $put_0_be = $put_0;
 
849
              var $have_0_be = $have_23;
 
850
              var $left_0_be = $left_0;
 
851
              var $hold_0_be = $hold_19;
 
852
              var $bits_0_be = $bits_19;
 
853
              var $out_0_be = $out_0;
 
854
              __label__ = 268;
 
855
              break;
 
856
            }
 
857
            HEAP32[$21 >> 2] = $and708;
 
858
            HEAP32[$mode >> 2] = 14;
 
859
            if ($cmp660) {
 
860
              var $ret_8 = $ret_0;
 
861
              var $next_58 = $next_23;
 
862
              var $have_58 = $have_23;
 
863
              var $hold_54 = 0;
 
864
              var $bits_54 = 0;
 
865
              var $out_4 = $out_0;
 
866
              break $_$12;
 
867
            }
 
868
            var $next_24 = $next_23;
 
869
            var $have_24 = $have_23;
 
870
            var $hold_20 = 0;
 
871
            var $bits_20 = 0;
 
872
            __label__ = 143;
 
873
            break;
 
874
          } else if (($49 | 0) == 14) {
 
875
            var $next_24 = $next_0;
 
876
            var $have_24 = $have_0;
 
877
            var $hold_20 = $hold_0;
 
878
            var $bits_20 = $bits_0;
 
879
            __label__ = 143;
 
880
          } else if (($49 | 0) == 15) {
 
881
            var $next_25 = $next_0;
 
882
            var $have_25 = $have_0;
 
883
            var $hold_21 = $hold_0;
 
884
            var $bits_21 = $bits_0;
 
885
            __label__ = 144;
 
886
          } else if (($49 | 0) == 16) {
 
887
            var $next_26 = $next_0;
 
888
            var $have_26 = $have_0;
 
889
            var $hold_22 = $hold_0;
 
890
            var $bits_22 = $bits_0;
 
891
            while (1) {
 
892
              var $bits_22;
 
893
              var $hold_22;
 
894
              var $have_26;
 
895
              var $next_26;
 
896
              var $cmp755 = $bits_22 >>> 0 < 14;
 
897
              if (!$cmp755) {
 
898
                break;
 
899
              }
 
900
              var $cmp759 = ($have_26 | 0) == 0;
 
901
              if ($cmp759) {
 
902
                var $ret_8 = $ret_0;
 
903
                var $next_58 = $next_26;
 
904
                var $have_58 = 0;
 
905
                var $hold_54 = $hold_22;
 
906
                var $bits_54 = $bits_22;
 
907
                var $out_4 = $out_0;
 
908
                break $_$12;
 
909
              }
 
910
              var $dec763 = $have_26 - 1 | 0;
 
911
              var $incdec_ptr764 = $next_26 + 1 | 0;
 
912
              var $121 = HEAPU8[$next_26];
 
913
              var $conv765 = $121 & 255;
 
914
              var $shl766 = $conv765 << $bits_22;
 
915
              var $add767 = $shl766 + $hold_22 | 0;
 
916
              var $add768 = $bits_22 + 8 | 0;
 
917
              var $next_26 = $incdec_ptr764;
 
918
              var $have_26 = $dec763;
 
919
              var $hold_22 = $add767;
 
920
              var $bits_22 = $add768;
 
921
            }
 
922
            var $and774 = $hold_22 & 31;
 
923
            var $add775 = $and774 + 257 | 0;
 
924
            HEAP32[$37 >> 2] = $add775;
 
925
            var $shr777 = $hold_22 >>> 5;
 
926
            var $and781 = $shr777 & 31;
 
927
            var $add782 = $and781 + 1 | 0;
 
928
            HEAP32[$38 >> 2] = $add782;
 
929
            var $shr784 = $hold_22 >>> 10;
 
930
            var $and788 = $shr784 & 15;
 
931
            var $add789 = $and788 + 4 | 0;
 
932
            HEAP32[$39 >> 2] = $add789;
 
933
            var $shr791 = $hold_22 >>> 14;
 
934
            var $sub792 = $bits_22 - 14 | 0;
 
935
            var $cmp796 = $add775 >>> 0 > 286;
 
936
            var $cmp800 = $add782 >>> 0 > 30;
 
937
            var $or_cond894 = $cmp796 | $cmp800;
 
938
            if ($or_cond894) {
 
939
              HEAP32[$msg >> 2] = STRING_TABLE.__str8105 | 0;
 
940
              HEAP32[$mode >> 2] = 29;
 
941
              var $ret_0_be = $ret_0;
 
942
              var $next_0_be = $next_26;
 
943
              var $put_0_be = $put_0;
 
944
              var $have_0_be = $have_26;
 
945
              var $left_0_be = $left_0;
 
946
              var $hold_0_be = $shr791;
 
947
              var $bits_0_be = $sub792;
 
948
              var $out_0_be = $out_0;
 
949
              __label__ = 268;
 
950
              break;
 
951
            }
 
952
            HEAP32[$40 >> 2] = 0;
 
953
            HEAP32[$mode >> 2] = 17;
 
954
            var $next_27 = $next_26;
 
955
            var $have_27 = $have_26;
 
956
            var $hold_23 = $shr791;
 
957
            var $bits_23 = $sub792;
 
958
            __label__ = 154;
 
959
            break;
 
960
          } else if (($49 | 0) == 17) {
 
961
            var $next_27 = $next_0;
 
962
            var $have_27 = $have_0;
 
963
            var $hold_23 = $hold_0;
 
964
            var $bits_23 = $bits_0;
 
965
            __label__ = 154;
 
966
          } else if (($49 | 0) == 18) {
 
967
            var $ret_1_ph = $ret_0;
 
968
            var $next_29_ph = $next_0;
 
969
            var $have_29_ph = $have_0;
 
970
            var $hold_25_ph = $hold_0;
 
971
            var $bits_25_ph = $bits_0;
 
972
            __label__ = 164;
 
973
          } else if (($49 | 0) == 19) {
 
974
            var $ret_2 = $ret_0;
 
975
            var $next_37 = $next_0;
 
976
            var $have_37 = $have_0;
 
977
            var $hold_33 = $hold_0;
 
978
            var $bits_33 = $bits_0;
 
979
            __label__ = 205;
 
980
          } else if (($49 | 0) == 20) {
 
981
            var $ret_3 = $ret_0;
 
982
            var $next_38 = $next_0;
 
983
            var $have_38 = $have_0;
 
984
            var $hold_34 = $hold_0;
 
985
            var $bits_34 = $bits_0;
 
986
            __label__ = 206;
 
987
          } else if (($49 | 0) == 21) {
 
988
            var $_pre889 = HEAP32[$28 >> 2];
 
989
            var $ret_4 = $ret_0;
 
990
            var $next_42 = $next_0;
 
991
            var $have_42 = $have_0;
 
992
            var $hold_38 = $hold_0;
 
993
            var $bits_38 = $bits_0;
 
994
            var $156 = $_pre889;
 
995
            __label__ = 227;
 
996
            break;
 
997
          } else if (($49 | 0) == 22) {
 
998
            var $ret_5_ph = $ret_0;
 
999
            var $next_45_ph = $next_0;
 
1000
            var $have_45_ph = $have_0;
 
1001
            var $hold_41_ph = $hold_0;
 
1002
            var $bits_41_ph = $bits_0;
 
1003
            __label__ = 234;
 
1004
          } else if (($49 | 0) == 23) {
 
1005
            var $_pre891 = HEAP32[$28 >> 2];
 
1006
            var $ret_6 = $ret_0;
 
1007
            var $next_48 = $next_0;
 
1008
            var $have_48 = $have_0;
 
1009
            var $hold_44 = $hold_0;
 
1010
            var $bits_44 = $bits_0;
 
1011
            var $167 = $_pre891;
 
1012
            __label__ = 248;
 
1013
            break;
 
1014
          } else if (($49 | 0) == 24) {
 
1015
            var $ret_7 = $ret_0;
 
1016
            var $next_51 = $next_0;
 
1017
            var $have_51 = $have_0;
 
1018
            var $hold_47 = $hold_0;
 
1019
            var $bits_47 = $bits_0;
 
1020
            __label__ = 254;
 
1021
          } else if (($49 | 0) == 25) {
 
1022
            var $cmp1615 = ($left_0 | 0) == 0;
 
1023
            if ($cmp1615) {
 
1024
              var $ret_8 = $ret_0;
 
1025
              var $next_58 = $next_0;
 
1026
              var $have_58 = $have_0;
 
1027
              var $hold_54 = $hold_0;
 
1028
              var $bits_54 = $bits_0;
 
1029
              var $out_4 = $out_0;
 
1030
              break $_$12;
 
1031
            }
 
1032
            var $186 = HEAP32[$21 >> 2];
 
1033
            var $conv1620 = $186 & 255;
 
1034
            var $incdec_ptr1621 = $put_0 + 1 | 0;
 
1035
            HEAP8[$put_0] = $conv1620;
 
1036
            var $dec1622 = $left_0 - 1 | 0;
 
1037
            HEAP32[$mode >> 2] = 20;
 
1038
            var $ret_0_be = $ret_0;
 
1039
            var $next_0_be = $next_0;
 
1040
            var $put_0_be = $incdec_ptr1621;
 
1041
            var $have_0_be = $have_0;
 
1042
            var $left_0_be = $dec1622;
 
1043
            var $hold_0_be = $hold_0;
 
1044
            var $bits_0_be = $bits_0;
 
1045
            var $out_0_be = $out_0;
 
1046
            __label__ = 268;
 
1047
            break;
 
1048
          } else if (($49 | 0) == 26) {
 
1049
            var $187 = HEAP32[$15 >> 2];
 
1050
            var $tobool1626 = ($187 | 0) == 0;
 
1051
            do {
 
1052
              if (!$tobool1626) {
 
1053
                var $next_52 = $next_0;
 
1054
                var $have_52 = $have_0;
 
1055
                var $hold_48 = $hold_0;
 
1056
                var $bits_48 = $bits_0;
 
1057
                while (1) {
 
1058
                  var $bits_48;
 
1059
                  var $hold_48;
 
1060
                  var $have_52;
 
1061
                  var $next_52;
 
1062
                  var $cmp1630 = $bits_48 >>> 0 < 32;
 
1063
                  if (!$cmp1630) {
 
1064
                    break;
 
1065
                  }
 
1066
                  var $cmp1634 = ($have_52 | 0) == 0;
 
1067
                  if ($cmp1634) {
 
1068
                    var $ret_8 = $ret_0;
 
1069
                    var $next_58 = $next_52;
 
1070
                    var $have_58 = 0;
 
1071
                    var $hold_54 = $hold_48;
 
1072
                    var $bits_54 = $bits_48;
 
1073
                    var $out_4 = $out_0;
 
1074
                    break $_$12;
 
1075
                  }
 
1076
                  var $dec1638 = $have_52 - 1 | 0;
 
1077
                  var $incdec_ptr1639 = $next_52 + 1 | 0;
 
1078
                  var $188 = HEAPU8[$next_52];
 
1079
                  var $conv1640 = $188 & 255;
 
1080
                  var $shl1641 = $conv1640 << $bits_48;
 
1081
                  var $add1642 = $shl1641 + $hold_48 | 0;
 
1082
                  var $add1643 = $bits_48 + 8 | 0;
 
1083
                  var $next_52 = $incdec_ptr1639;
 
1084
                  var $have_52 = $dec1638;
 
1085
                  var $hold_48 = $add1642;
 
1086
                  var $bits_48 = $add1643;
 
1087
                }
 
1088
                var $sub1649 = $out_0 - $left_0 | 0;
 
1089
                var $189 = HEAP32[$total_out >> 2];
 
1090
                var $add1650 = $189 + $sub1649 | 0;
 
1091
                HEAP32[$total_out >> 2] = $add1650;
 
1092
                var $190 = HEAP32[$36 >> 2];
 
1093
                var $add1651 = $190 + $sub1649 | 0;
 
1094
                HEAP32[$36 >> 2] = $add1651;
 
1095
                var $tobool1652 = ($out_0 | 0) == ($left_0 | 0);
 
1096
                if (!$tobool1652) {
 
1097
                  var $191 = HEAP32[$17 >> 2];
 
1098
                  var $tobool1655 = ($191 | 0) == 0;
 
1099
                  var $192 = HEAP32[$16 >> 2];
 
1100
                  var $idx_neg1658 = -$sub1649 | 0;
 
1101
                  var $add_ptr1659 = $put_0 + $idx_neg1658 | 0;
 
1102
                  if ($tobool1655) {
 
1103
                    var $call1665 = _adler32($192, $add_ptr1659, $sub1649);
 
1104
                    var $cond1667 = $call1665;
 
1105
                  } else {
 
1106
                    var $call1660 = _crc32($192, $add_ptr1659, $sub1649);
 
1107
                    var $cond1667 = $call1660;
 
1108
                  }
 
1109
                  var $cond1667;
 
1110
                  HEAP32[$16 >> 2] = $cond1667;
 
1111
                  HEAP32[$adler >> 2] = $cond1667;
 
1112
                }
 
1113
                var $193 = HEAP32[$17 >> 2];
 
1114
                var $tobool1672 = ($193 | 0) == 0;
 
1115
                if ($tobool1672) {
 
1116
                  var $add1685 = _llvm_bswap_i32($hold_48);
 
1117
                  var $cond1687 = $add1685;
 
1118
                } else {
 
1119
                  var $cond1687 = $hold_48;
 
1120
                }
 
1121
                var $cond1687;
 
1122
                var $194 = HEAP32[$16 >> 2];
 
1123
                var $cmp1689 = ($cond1687 | 0) == ($194 | 0);
 
1124
                if ($cmp1689) {
 
1125
                  var $next_53 = $next_52;
 
1126
                  var $have_53 = $have_52;
 
1127
                  var $hold_49 = 0;
 
1128
                  var $bits_49 = 0;
 
1129
                  var $out_1 = $left_0;
 
1130
                  break;
 
1131
                }
 
1132
                HEAP32[$msg >> 2] = STRING_TABLE.__str17114 | 0;
 
1133
                HEAP32[$mode >> 2] = 29;
 
1134
                var $ret_0_be = $ret_0;
 
1135
                var $next_0_be = $next_52;
 
1136
                var $put_0_be = $put_0;
 
1137
                var $have_0_be = $have_52;
 
1138
                var $left_0_be = $left_0;
 
1139
                var $hold_0_be = $hold_48;
 
1140
                var $bits_0_be = $bits_48;
 
1141
                var $out_0_be = $left_0;
 
1142
                __label__ = 268;
 
1143
                break $_$14;
 
1144
              }
 
1145
              var $next_53 = $next_0;
 
1146
              var $have_53 = $have_0;
 
1147
              var $hold_49 = $hold_0;
 
1148
              var $bits_49 = $bits_0;
 
1149
              var $out_1 = $out_0;
 
1150
            } while (0);
 
1151
            var $out_1;
 
1152
            var $bits_49;
 
1153
            var $hold_49;
 
1154
            var $have_53;
 
1155
            var $next_53;
 
1156
            HEAP32[$mode >> 2] = 27;
 
1157
            var $next_54 = $next_53;
 
1158
            var $have_54 = $have_53;
 
1159
            var $hold_50 = $hold_49;
 
1160
            var $bits_50 = $bits_49;
 
1161
            var $out_2 = $out_1;
 
1162
            __label__ = 286;
 
1163
            break;
 
1164
          } else if (($49 | 0) == 27) {
 
1165
            var $next_54 = $next_0;
 
1166
            var $have_54 = $have_0;
 
1167
            var $hold_50 = $hold_0;
 
1168
            var $bits_50 = $bits_0;
 
1169
            var $out_2 = $out_0;
 
1170
            __label__ = 286;
 
1171
          } else if (($49 | 0) == 28) {
 
1172
            var $ret_8 = 1;
 
1173
            var $next_58 = $next_0;
 
1174
            var $have_58 = $have_0;
 
1175
            var $hold_54 = $hold_0;
 
1176
            var $bits_54 = $bits_0;
 
1177
            var $out_4 = $out_0;
 
1178
            break $_$12;
 
1179
          } else if (($49 | 0) == 29) {
 
1180
            var $ret_8 = -3;
 
1181
            var $next_58 = $next_0;
 
1182
            var $have_58 = $have_0;
 
1183
            var $hold_54 = $hold_0;
 
1184
            var $bits_54 = $bits_0;
 
1185
            var $out_4 = $out_0;
 
1186
            break $_$12;
 
1187
          } else if (($49 | 0) == 30) {
 
1188
            var $retval_0 = -4;
 
1189
            break $_$2;
 
1190
          } else {
 
1191
            var $retval_0 = -2;
 
1192
            break $_$2;
 
1193
          }
 
1194
        } while (0);
 
1195
        $_$106 : do {
 
1196
          if (__label__ == 44) {
 
1197
            while (1) {
 
1198
              var $bits_3;
 
1199
              var $hold_3;
 
1200
              var $have_3;
 
1201
              var $next_3;
 
1202
              var $cmp164 = $bits_3 >>> 0 < 32;
 
1203
              if (!$cmp164) {
 
1204
                break;
 
1205
              }
 
1206
              var $cmp168 = ($have_3 | 0) == 0;
 
1207
              if ($cmp168) {
 
1208
                var $ret_8 = $ret_0;
 
1209
                var $next_58 = $next_3;
 
1210
                var $have_58 = 0;
 
1211
                var $hold_54 = $hold_3;
 
1212
                var $bits_54 = $bits_3;
 
1213
                var $out_4 = $out_0;
 
1214
                break $_$12;
 
1215
              }
 
1216
              var $dec172 = $have_3 - 1 | 0;
 
1217
              var $incdec_ptr173 = $next_3 + 1 | 0;
 
1218
              var $62 = HEAPU8[$next_3];
 
1219
              var $conv174 = $62 & 255;
 
1220
              var $shl175 = $conv174 << $bits_3;
 
1221
              var $add176 = $shl175 + $hold_3 | 0;
 
1222
              var $add177 = $bits_3 + 8 | 0;
 
1223
              var $next_3 = $incdec_ptr173;
 
1224
              var $have_3 = $dec172;
 
1225
              var $hold_3 = $add176;
 
1226
              var $bits_3 = $add177;
 
1227
            }
 
1228
            var $63 = HEAP32[$18 >> 2];
 
1229
            var $cmp182 = ($63 | 0) == 0;
 
1230
            if (!$cmp182) {
 
1231
              var $time = $63 + 4 | 0;
 
1232
              HEAP32[$time >> 2] = $hold_3;
 
1233
            }
 
1234
            var $64 = HEAP32[$17 >> 2];
 
1235
            var $and188 = $64 & 512;
 
1236
            var $tobool189 = ($and188 | 0) == 0;
 
1237
            if (!$tobool189) {
 
1238
              var $conv192 = $hold_3 & 255;
 
1239
              HEAP8[$arrayidx] = $conv192;
 
1240
              var $shr194 = $hold_3 >>> 8;
 
1241
              var $conv195 = $shr194 & 255;
 
1242
              HEAP8[$arrayidx40] = $conv195;
 
1243
              var $shr197 = $hold_3 >>> 16;
 
1244
              var $conv198 = $shr197 & 255;
 
1245
              HEAP8[$arrayidx199] = $conv198;
 
1246
              var $shr200 = $hold_3 >>> 24;
 
1247
              var $conv201 = $shr200 & 255;
 
1248
              HEAP8[$arrayidx202] = $conv201;
 
1249
              var $65 = HEAP32[$16 >> 2];
 
1250
              var $call205 = _crc32($65, $arrayidx, 4);
 
1251
              HEAP32[$16 >> 2] = $call205;
 
1252
            }
 
1253
            HEAP32[$mode >> 2] = 3;
 
1254
            var $next_4 = $next_3;
 
1255
            var $have_4 = $have_3;
 
1256
            var $hold_4 = 0;
 
1257
            var $bits_4 = 0;
 
1258
            __label__ = 52;
 
1259
            break;
 
1260
          } else if (__label__ == 120) {
 
1261
            var $bits_15;
 
1262
            var $hold_15;
 
1263
            var $have_19;
 
1264
            var $next_19;
 
1265
            var $115 = HEAP32[$22 >> 2];
 
1266
            var $cmp589 = ($115 | 0) == 0;
 
1267
            if ($cmp589) {
 
1268
              HEAP32[$next_out >> 2] = $put_0;
 
1269
              HEAP32[$avail_out >> 2] = $left_0;
 
1270
              HEAP32[$next_in >> 2] = $next_19;
 
1271
              HEAP32[$avail_in15 >> 2] = $have_19;
 
1272
              HEAP32[$11 >> 2] = $hold_15;
 
1273
              HEAP32[$13 >> 2] = $bits_15;
 
1274
              var $retval_0 = 2;
 
1275
              break $_$2;
 
1276
            }
 
1277
            var $call602 = _adler32(0, 0, 0);
 
1278
            HEAP32[$16 >> 2] = $call602;
 
1279
            HEAP32[$adler >> 2] = $call602;
 
1280
            HEAP32[$mode >> 2] = 11;
 
1281
            var $next_20 = $next_19;
 
1282
            var $have_20 = $have_19;
 
1283
            var $hold_16 = $hold_15;
 
1284
            var $bits_16 = $bits_15;
 
1285
            __label__ = 123;
 
1286
            break;
 
1287
          } else if (__label__ == 143) {
 
1288
            var $bits_20;
 
1289
            var $hold_20;
 
1290
            var $have_24;
 
1291
            var $next_24;
 
1292
            HEAP32[$mode >> 2] = 15;
 
1293
            var $next_25 = $next_24;
 
1294
            var $have_25 = $have_24;
 
1295
            var $hold_21 = $hold_20;
 
1296
            var $bits_21 = $bits_20;
 
1297
            __label__ = 144;
 
1298
            break;
 
1299
          } else if (__label__ == 154) {
 
1300
            while (1) {
 
1301
              var $bits_23;
 
1302
              var $hold_23;
 
1303
              var $have_27;
 
1304
              var $next_27;
 
1305
              var $122 = HEAPU32[$40 >> 2];
 
1306
              var $123 = HEAPU32[$39 >> 2];
 
1307
              var $cmp812 = $122 >>> 0 < $123 >>> 0;
 
1308
              if (!$cmp812) {
 
1309
                break;
 
1310
              }
 
1311
              var $next_28 = $next_27;
 
1312
              var $have_28 = $have_27;
 
1313
              var $hold_24 = $hold_23;
 
1314
              var $bits_24 = $bits_23;
 
1315
              while (1) {
 
1316
                var $bits_24;
 
1317
                var $hold_24;
 
1318
                var $have_28;
 
1319
                var $next_28;
 
1320
                var $cmp817 = $bits_24 >>> 0 < 3;
 
1321
                if (!$cmp817) {
 
1322
                  break;
 
1323
                }
 
1324
                var $cmp821 = ($have_28 | 0) == 0;
 
1325
                if ($cmp821) {
 
1326
                  var $ret_8 = $ret_0;
 
1327
                  var $next_58 = $next_28;
 
1328
                  var $have_58 = 0;
 
1329
                  var $hold_54 = $hold_24;
 
1330
                  var $bits_54 = $bits_24;
 
1331
                  var $out_4 = $out_0;
 
1332
                  break $_$12;
 
1333
                }
 
1334
                var $dec825 = $have_28 - 1 | 0;
 
1335
                var $incdec_ptr826 = $next_28 + 1 | 0;
 
1336
                var $124 = HEAPU8[$next_28];
 
1337
                var $conv827 = $124 & 255;
 
1338
                var $shl828 = $conv827 << $bits_24;
 
1339
                var $add829 = $shl828 + $hold_24 | 0;
 
1340
                var $add830 = $bits_24 + 8 | 0;
 
1341
                var $next_28 = $incdec_ptr826;
 
1342
                var $have_28 = $dec825;
 
1343
                var $hold_24 = $add829;
 
1344
                var $bits_24 = $add830;
 
1345
              }
 
1346
              var $hold_24_tr = $hold_24 & 65535;
 
1347
              var $conv837 = $hold_24_tr & 7;
 
1348
              var $inc839 = $122 + 1 | 0;
 
1349
              HEAP32[$40 >> 2] = $inc839;
 
1350
              var $arrayidx840 = _inflate_order + ($122 << 1) | 0;
 
1351
              var $125 = HEAPU16[$arrayidx840 >> 1];
 
1352
              var $idxprom = $125 & 65535;
 
1353
              var $arrayidx841 = $41 + ($idxprom << 1) | 0;
 
1354
              HEAP16[$arrayidx841 >> 1] = $conv837;
 
1355
              var $shr843 = $hold_24 >>> 3;
 
1356
              var $sub844 = $bits_24 - 3 | 0;
 
1357
              var $next_27 = $next_28;
 
1358
              var $have_27 = $have_28;
 
1359
              var $hold_23 = $shr843;
 
1360
              var $bits_23 = $sub844;
 
1361
            }
 
1362
            var $cmp850111 = $122 >>> 0 < 19;
 
1363
            $_$131 : do {
 
1364
              if ($cmp850111) {
 
1365
                var $126 = $122;
 
1366
                while (1) {
 
1367
                  var $126;
 
1368
                  var $inc854 = $126 + 1 | 0;
 
1369
                  HEAP32[$40 >> 2] = $inc854;
 
1370
                  var $arrayidx855 = _inflate_order + ($126 << 1) | 0;
 
1371
                  var $127 = HEAPU16[$arrayidx855 >> 1];
 
1372
                  var $idxprom856 = $127 & 65535;
 
1373
                  var $arrayidx858 = $41 + ($idxprom856 << 1) | 0;
 
1374
                  HEAP16[$arrayidx858 >> 1] = 0;
 
1375
                  var $_pr = HEAPU32[$40 >> 2];
 
1376
                  var $cmp850 = $_pr >>> 0 < 19;
 
1377
                  if (!$cmp850) {
 
1378
                    break $_$131;
 
1379
                  }
 
1380
                  var $126 = $_pr;
 
1381
                }
 
1382
              }
 
1383
            } while (0);
 
1384
            HEAP32[$43 >> 2] = $arraydecay860_c;
 
1385
            HEAP32[$44 >> 2] = $arraydecay860_c;
 
1386
            HEAP32[$26 >> 2] = 7;
 
1387
            var $call868 = _inflate_table(0, $arraydecay864, 19, $42, $26, $arraydecay867);
 
1388
            var $tobool869 = ($call868 | 0) == 0;
 
1389
            if ($tobool869) {
 
1390
              HEAP32[$40 >> 2] = 0;
 
1391
              HEAP32[$mode >> 2] = 18;
 
1392
              var $ret_1_ph = 0;
 
1393
              var $next_29_ph = $next_27;
 
1394
              var $have_29_ph = $have_27;
 
1395
              var $hold_25_ph = $hold_23;
 
1396
              var $bits_25_ph = $bits_23;
 
1397
              __label__ = 164;
 
1398
              break;
 
1399
            }
 
1400
            HEAP32[$msg >> 2] = STRING_TABLE.__str9106 | 0;
 
1401
            HEAP32[$mode >> 2] = 29;
 
1402
            var $ret_0_be = $call868;
 
1403
            var $next_0_be = $next_27;
 
1404
            var $put_0_be = $put_0;
 
1405
            var $have_0_be = $have_27;
 
1406
            var $left_0_be = $left_0;
 
1407
            var $hold_0_be = $hold_23;
 
1408
            var $bits_0_be = $bits_23;
 
1409
            var $out_0_be = $out_0;
 
1410
            __label__ = 268;
 
1411
            break;
 
1412
          } else if (__label__ == 286) {
 
1413
            var $out_2;
 
1414
            var $bits_50;
 
1415
            var $hold_50;
 
1416
            var $have_54;
 
1417
            var $next_54;
 
1418
            var $195 = HEAP32[$15 >> 2];
 
1419
            var $tobool1702 = ($195 | 0) == 0;
 
1420
            do {
 
1421
              if (!$tobool1702) {
 
1422
                var $196 = HEAP32[$17 >> 2];
 
1423
                var $tobool1705 = ($196 | 0) == 0;
 
1424
                if ($tobool1705) {
 
1425
                  var $next_56 = $next_54;
 
1426
                  var $have_56 = $have_54;
 
1427
                  var $hold_52 = $hold_50;
 
1428
                  var $bits_52 = $bits_50;
 
1429
                  break;
 
1430
                }
 
1431
                var $next_55 = $next_54;
 
1432
                var $have_55 = $have_54;
 
1433
                var $hold_51 = $hold_50;
 
1434
                var $bits_51 = $bits_50;
 
1435
                while (1) {
 
1436
                  var $bits_51;
 
1437
                  var $hold_51;
 
1438
                  var $have_55;
 
1439
                  var $next_55;
 
1440
                  var $cmp1709 = $bits_51 >>> 0 < 32;
 
1441
                  if (!$cmp1709) {
 
1442
                    break;
 
1443
                  }
 
1444
                  var $cmp1713 = ($have_55 | 0) == 0;
 
1445
                  if ($cmp1713) {
 
1446
                    var $ret_8 = $ret_0;
 
1447
                    var $next_58 = $next_55;
 
1448
                    var $have_58 = 0;
 
1449
                    var $hold_54 = $hold_51;
 
1450
                    var $bits_54 = $bits_51;
 
1451
                    var $out_4 = $out_2;
 
1452
                    break $_$12;
 
1453
                  }
 
1454
                  var $dec1717 = $have_55 - 1 | 0;
 
1455
                  var $incdec_ptr1718 = $next_55 + 1 | 0;
 
1456
                  var $197 = HEAPU8[$next_55];
 
1457
                  var $conv1719 = $197 & 255;
 
1458
                  var $shl1720 = $conv1719 << $bits_51;
 
1459
                  var $add1721 = $shl1720 + $hold_51 | 0;
 
1460
                  var $add1722 = $bits_51 + 8 | 0;
 
1461
                  var $next_55 = $incdec_ptr1718;
 
1462
                  var $have_55 = $dec1717;
 
1463
                  var $hold_51 = $add1721;
 
1464
                  var $bits_51 = $add1722;
 
1465
                }
 
1466
                var $198 = HEAP32[$36 >> 2];
 
1467
                var $cmp1729 = ($hold_51 | 0) == ($198 | 0);
 
1468
                if ($cmp1729) {
 
1469
                  var $next_56 = $next_55;
 
1470
                  var $have_56 = $have_55;
 
1471
                  var $hold_52 = 0;
 
1472
                  var $bits_52 = 0;
 
1473
                  break;
 
1474
                }
 
1475
                HEAP32[$msg >> 2] = STRING_TABLE.__str18115 | 0;
 
1476
                HEAP32[$mode >> 2] = 29;
 
1477
                var $ret_0_be = $ret_0;
 
1478
                var $next_0_be = $next_55;
 
1479
                var $put_0_be = $put_0;
 
1480
                var $have_0_be = $have_55;
 
1481
                var $left_0_be = $left_0;
 
1482
                var $hold_0_be = $hold_51;
 
1483
                var $bits_0_be = $bits_51;
 
1484
                var $out_0_be = $out_2;
 
1485
                __label__ = 268;
 
1486
                break $_$106;
 
1487
              }
 
1488
              var $next_56 = $next_54;
 
1489
              var $have_56 = $have_54;
 
1490
              var $hold_52 = $hold_50;
 
1491
              var $bits_52 = $bits_50;
 
1492
            } while (0);
 
1493
            var $bits_52;
 
1494
            var $hold_52;
 
1495
            var $have_56;
 
1496
            var $next_56;
 
1497
            HEAP32[$mode >> 2] = 28;
 
1498
            var $ret_8 = 1;
 
1499
            var $next_58 = $next_56;
 
1500
            var $have_58 = $have_56;
 
1501
            var $hold_54 = $hold_52;
 
1502
            var $bits_54 = $bits_52;
 
1503
            var $out_4 = $out_2;
 
1504
            break $_$12;
 
1505
          }
 
1506
        } while (0);
 
1507
        $_$148 : do {
 
1508
          if (__label__ == 52) {
 
1509
            while (1) {
 
1510
              var $bits_4;
 
1511
              var $hold_4;
 
1512
              var $have_4;
 
1513
              var $next_4;
 
1514
              var $cmp215 = $bits_4 >>> 0 < 16;
 
1515
              if (!$cmp215) {
 
1516
                break;
 
1517
              }
 
1518
              var $cmp219 = ($have_4 | 0) == 0;
 
1519
              if ($cmp219) {
 
1520
                var $ret_8 = $ret_0;
 
1521
                var $next_58 = $next_4;
 
1522
                var $have_58 = 0;
 
1523
                var $hold_54 = $hold_4;
 
1524
                var $bits_54 = $bits_4;
 
1525
                var $out_4 = $out_0;
 
1526
                break $_$12;
 
1527
              }
 
1528
              var $dec223 = $have_4 - 1 | 0;
 
1529
              var $incdec_ptr224 = $next_4 + 1 | 0;
 
1530
              var $66 = HEAPU8[$next_4];
 
1531
              var $conv225 = $66 & 255;
 
1532
              var $shl226 = $conv225 << $bits_4;
 
1533
              var $add227 = $shl226 + $hold_4 | 0;
 
1534
              var $add228 = $bits_4 + 8 | 0;
 
1535
              var $next_4 = $incdec_ptr224;
 
1536
              var $have_4 = $dec223;
 
1537
              var $hold_4 = $add227;
 
1538
              var $bits_4 = $add228;
 
1539
            }
 
1540
            var $67 = HEAP32[$18 >> 2];
 
1541
            var $cmp233 = ($67 | 0) == 0;
 
1542
            if (!$cmp233) {
 
1543
              var $and236 = $hold_4 & 255;
 
1544
              var $xflags = $67 + 8 | 0;
 
1545
              HEAP32[$xflags >> 2] = $and236;
 
1546
              var $shr238 = $hold_4 >>> 8;
 
1547
              var $68 = HEAP32[$18 >> 2];
 
1548
              var $os = $68 + 12 | 0;
 
1549
              HEAP32[$os >> 2] = $shr238;
 
1550
            }
 
1551
            var $69 = HEAP32[$17 >> 2];
 
1552
            var $and242 = $69 & 512;
 
1553
            var $tobool243 = ($and242 | 0) == 0;
 
1554
            if (!$tobool243) {
 
1555
              var $conv246 = $hold_4 & 255;
 
1556
              HEAP8[$arrayidx] = $conv246;
 
1557
              var $shr248 = $hold_4 >>> 8;
 
1558
              var $conv249 = $shr248 & 255;
 
1559
              HEAP8[$arrayidx40] = $conv249;
 
1560
              var $70 = HEAP32[$16 >> 2];
 
1561
              var $call253 = _crc32($70, $arrayidx, 2);
 
1562
              HEAP32[$16 >> 2] = $call253;
 
1563
            }
 
1564
            HEAP32[$mode >> 2] = 4;
 
1565
            var $next_5 = $next_4;
 
1566
            var $have_5 = $have_4;
 
1567
            var $hold_5 = 0;
 
1568
            var $bits_5 = 0;
 
1569
            __label__ = 60;
 
1570
            break;
 
1571
          } else if (__label__ == 123) {
 
1572
            var $bits_16;
 
1573
            var $hold_16;
 
1574
            var $have_20;
 
1575
            var $next_20;
 
1576
            if ($23) {
 
1577
              var $ret_8 = $ret_0;
 
1578
              var $next_58 = $next_20;
 
1579
              var $have_58 = $have_20;
 
1580
              var $hold_54 = $hold_16;
 
1581
              var $bits_54 = $bits_16;
 
1582
              var $out_4 = $out_0;
 
1583
              break $_$12;
 
1584
            }
 
1585
            var $next_21 = $next_20;
 
1586
            var $have_21 = $have_20;
 
1587
            var $hold_17 = $hold_16;
 
1588
            var $bits_17 = $bits_16;
 
1589
            __label__ = 124;
 
1590
            break;
 
1591
          } else if (__label__ == 144) {
 
1592
            var $bits_21;
 
1593
            var $hold_21;
 
1594
            var $have_25;
 
1595
            var $next_25;
 
1596
            var $119 = HEAPU32[$21 >> 2];
 
1597
            var $tobool730 = ($119 | 0) == 0;
 
1598
            if ($tobool730) {
 
1599
              HEAP32[$mode >> 2] = 11;
 
1600
              var $ret_0_be = $ret_0;
 
1601
              var $next_0_be = $next_25;
 
1602
              var $put_0_be = $put_0;
 
1603
              var $have_0_be = $have_25;
 
1604
              var $left_0_be = $left_0;
 
1605
              var $hold_0_be = $hold_21;
 
1606
              var $bits_0_be = $bits_21;
 
1607
              var $out_0_be = $out_0;
 
1608
              __label__ = 268;
 
1609
              break;
 
1610
            }
 
1611
            var $cmp732 = $119 >>> 0 > $have_25 >>> 0;
 
1612
            var $copy_3 = $cmp732 ? $have_25 : $119;
 
1613
            var $cmp736 = $copy_3 >>> 0 > $left_0 >>> 0;
 
1614
            var $copy_4 = $cmp736 ? $left_0 : $copy_3;
 
1615
            var $cmp740 = ($copy_4 | 0) == 0;
 
1616
            if ($cmp740) {
 
1617
              var $ret_8 = $ret_0;
 
1618
              var $next_58 = $next_25;
 
1619
              var $have_58 = $have_25;
 
1620
              var $hold_54 = $hold_21;
 
1621
              var $bits_54 = $bits_21;
 
1622
              var $out_4 = $out_0;
 
1623
              break $_$12;
 
1624
            }
 
1625
            _memcpy($put_0, $next_25, $copy_4, 1);
 
1626
            var $sub744 = $have_25 - $copy_4 | 0;
 
1627
            var $add_ptr745 = $next_25 + $copy_4 | 0;
 
1628
            var $sub746 = $left_0 - $copy_4 | 0;
 
1629
            var $add_ptr747 = $put_0 + $copy_4 | 0;
 
1630
            var $120 = HEAP32[$21 >> 2];
 
1631
            var $sub749 = $120 - $copy_4 | 0;
 
1632
            HEAP32[$21 >> 2] = $sub749;
 
1633
            var $ret_0_be = $ret_0;
 
1634
            var $next_0_be = $add_ptr745;
 
1635
            var $put_0_be = $add_ptr747;
 
1636
            var $have_0_be = $sub744;
 
1637
            var $left_0_be = $sub746;
 
1638
            var $hold_0_be = $hold_21;
 
1639
            var $bits_0_be = $bits_21;
 
1640
            var $out_0_be = $out_0;
 
1641
            __label__ = 268;
 
1642
            break;
 
1643
          } else if (__label__ == 164) {
 
1644
            var $bits_25_ph;
 
1645
            var $hold_25_ph;
 
1646
            var $have_29_ph;
 
1647
            var $next_29_ph;
 
1648
            var $ret_1_ph;
 
1649
            var $next_29 = $next_29_ph;
 
1650
            var $have_29 = $have_29_ph;
 
1651
            var $hold_25 = $hold_25_ph;
 
1652
            var $bits_25 = $bits_25_ph;
 
1653
            $_$167 : while (1) {
 
1654
              var $bits_25;
 
1655
              var $hold_25;
 
1656
              var $have_29;
 
1657
              var $next_29;
 
1658
              var $128 = HEAPU32[$40 >> 2];
 
1659
              var $129 = HEAPU32[$37 >> 2];
 
1660
              var $130 = HEAP32[$38 >> 2];
 
1661
              var $add881 = $130 + $129 | 0;
 
1662
              var $cmp882 = $128 >>> 0 < $add881 >>> 0;
 
1663
              if ($cmp882) {
 
1664
                var $131 = HEAP32[$26 >> 2];
 
1665
                var $shl887 = 1 << $131;
 
1666
                var $sub888 = $shl887 - 1 | 0;
 
1667
                var $132 = HEAPU32[$27 >> 2];
 
1668
                var $next_30 = $next_29;
 
1669
                var $have_30 = $have_29;
 
1670
                var $hold_26 = $hold_25;
 
1671
                var $bits_26 = $bits_25;
 
1672
                while (1) {
 
1673
                  var $bits_26;
 
1674
                  var $hold_26;
 
1675
                  var $have_30;
 
1676
                  var $next_30;
 
1677
                  var $and889 = $sub888 & $hold_26;
 
1678
                  var $arrayidx891_1 = $132 + ($and889 << 2) + 1 | 0;
 
1679
                  var $tmp25 = HEAPU8[$arrayidx891_1];
 
1680
                  var $conv893 = $tmp25 & 255;
 
1681
                  var $cmp894 = $conv893 >>> 0 > $bits_26 >>> 0;
 
1682
                  if (!$cmp894) {
 
1683
                    break;
 
1684
                  }
 
1685
                  var $cmp899 = ($have_30 | 0) == 0;
 
1686
                  if ($cmp899) {
 
1687
                    var $ret_8 = $ret_1_ph;
 
1688
                    var $next_58 = $next_30;
 
1689
                    var $have_58 = 0;
 
1690
                    var $hold_54 = $hold_26;
 
1691
                    var $bits_54 = $bits_26;
 
1692
                    var $out_4 = $out_0;
 
1693
                    break $_$12;
 
1694
                  }
 
1695
                  var $dec903 = $have_30 - 1 | 0;
 
1696
                  var $incdec_ptr904 = $next_30 + 1 | 0;
 
1697
                  var $133 = HEAPU8[$next_30];
 
1698
                  var $conv905 = $133 & 255;
 
1699
                  var $shl906 = $conv905 << $bits_26;
 
1700
                  var $add907 = $shl906 + $hold_26 | 0;
 
1701
                  var $add908 = $bits_26 + 8 | 0;
 
1702
                  var $next_30 = $incdec_ptr904;
 
1703
                  var $have_30 = $dec903;
 
1704
                  var $hold_26 = $add907;
 
1705
                  var $bits_26 = $add908;
 
1706
                }
 
1707
                var $arrayidx891_2 = $132 + ($and889 << 2) + 2 | 0;
 
1708
                var $tmp26 = HEAPU16[$arrayidx891_2 >> 1];
 
1709
                var $cmp912 = ($tmp26 & 65535) < 16;
 
1710
                if ($cmp912) {
 
1711
                  var $next_31 = $next_30;
 
1712
                  var $have_31 = $have_30;
 
1713
                  var $hold_27 = $hold_26;
 
1714
                  var $bits_27 = $bits_26;
 
1715
                  while (1) {
 
1716
                    var $bits_27;
 
1717
                    var $hold_27;
 
1718
                    var $have_31;
 
1719
                    var $next_31;
 
1720
                    var $cmp919 = $bits_27 >>> 0 < $conv893 >>> 0;
 
1721
                    if (!$cmp919) {
 
1722
                      break;
 
1723
                    }
 
1724
                    var $cmp923 = ($have_31 | 0) == 0;
 
1725
                    if ($cmp923) {
 
1726
                      var $ret_8 = $ret_1_ph;
 
1727
                      var $next_58 = $next_31;
 
1728
                      var $have_58 = 0;
 
1729
                      var $hold_54 = $hold_27;
 
1730
                      var $bits_54 = $bits_27;
 
1731
                      var $out_4 = $out_0;
 
1732
                      break $_$12;
 
1733
                    }
 
1734
                    var $dec927 = $have_31 - 1 | 0;
 
1735
                    var $incdec_ptr928 = $next_31 + 1 | 0;
 
1736
                    var $134 = HEAPU8[$next_31];
 
1737
                    var $conv929 = $134 & 255;
 
1738
                    var $shl930 = $conv929 << $bits_27;
 
1739
                    var $add931 = $shl930 + $hold_27 | 0;
 
1740
                    var $add932 = $bits_27 + 8 | 0;
 
1741
                    var $next_31 = $incdec_ptr928;
 
1742
                    var $have_31 = $dec927;
 
1743
                    var $hold_27 = $add931;
 
1744
                    var $bits_27 = $add932;
 
1745
                  }
 
1746
                  var $shr941 = $hold_27 >>> ($conv893 >>> 0);
 
1747
                  var $sub944 = $bits_27 - $conv893 | 0;
 
1748
                  var $inc949 = $128 + 1 | 0;
 
1749
                  HEAP32[$40 >> 2] = $inc949;
 
1750
                  var $arrayidx951 = $41 + ($128 << 1) | 0;
 
1751
                  HEAP16[$arrayidx951 >> 1] = $tmp26;
 
1752
                  var $next_29 = $next_31;
 
1753
                  var $have_29 = $have_31;
 
1754
                  var $hold_25 = $shr941;
 
1755
                  var $bits_25 = $sub944;
 
1756
                } else {
 
1757
                  if ($tmp26 << 16 >> 16 == 16) {
 
1758
                    var $add962 = $conv893 + 2 | 0;
 
1759
                    var $next_32 = $next_30;
 
1760
                    var $have_32 = $have_30;
 
1761
                    var $hold_28 = $hold_26;
 
1762
                    var $bits_28 = $bits_26;
 
1763
                    while (1) {
 
1764
                      var $bits_28;
 
1765
                      var $hold_28;
 
1766
                      var $have_32;
 
1767
                      var $next_32;
 
1768
                      var $cmp963 = $bits_28 >>> 0 < $add962 >>> 0;
 
1769
                      if (!$cmp963) {
 
1770
                        break;
 
1771
                      }
 
1772
                      var $cmp967 = ($have_32 | 0) == 0;
 
1773
                      if ($cmp967) {
 
1774
                        var $ret_8 = $ret_1_ph;
 
1775
                        var $next_58 = $next_32;
 
1776
                        var $have_58 = 0;
 
1777
                        var $hold_54 = $hold_28;
 
1778
                        var $bits_54 = $bits_28;
 
1779
                        var $out_4 = $out_0;
 
1780
                        break $_$12;
 
1781
                      }
 
1782
                      var $dec971 = $have_32 - 1 | 0;
 
1783
                      var $incdec_ptr972 = $next_32 + 1 | 0;
 
1784
                      var $135 = HEAPU8[$next_32];
 
1785
                      var $conv973 = $135 & 255;
 
1786
                      var $shl974 = $conv973 << $bits_28;
 
1787
                      var $add975 = $shl974 + $hold_28 | 0;
 
1788
                      var $add976 = $bits_28 + 8 | 0;
 
1789
                      var $next_32 = $incdec_ptr972;
 
1790
                      var $have_32 = $dec971;
 
1791
                      var $hold_28 = $add975;
 
1792
                      var $bits_28 = $add976;
 
1793
                    }
 
1794
                    var $shr985 = $hold_28 >>> ($conv893 >>> 0);
 
1795
                    var $sub988 = $bits_28 - $conv893 | 0;
 
1796
                    var $cmp992 = ($128 | 0) == 0;
 
1797
                    if ($cmp992) {
 
1798
                      HEAP32[$msg >> 2] = STRING_TABLE.__str10107 | 0;
 
1799
                      HEAP32[$mode >> 2] = 29;
 
1800
                      var $ret_0_be = $ret_1_ph;
 
1801
                      var $next_0_be = $next_32;
 
1802
                      var $put_0_be = $put_0;
 
1803
                      var $have_0_be = $have_32;
 
1804
                      var $left_0_be = $left_0;
 
1805
                      var $hold_0_be = $shr985;
 
1806
                      var $bits_0_be = $sub988;
 
1807
                      var $out_0_be = $out_0;
 
1808
                      __label__ = 268;
 
1809
                      break $_$148;
 
1810
                    }
 
1811
                    var $sub999 = $128 - 1 | 0;
 
1812
                    var $arrayidx1001 = $41 + ($sub999 << 1) | 0;
 
1813
                    var $136 = HEAP16[$arrayidx1001 >> 1];
 
1814
                    var $and1003 = $shr985 & 3;
 
1815
                    var $add1004 = $and1003 + 3 | 0;
 
1816
                    var $shr1006 = $shr985 >>> 2;
 
1817
                    var $sub1007 = $sub988 - 2 | 0;
 
1818
                    var $len_0 = $136;
 
1819
                    var $next_35 = $next_32;
 
1820
                    var $have_35 = $have_32;
 
1821
                    var $hold_31 = $shr1006;
 
1822
                    var $bits_31 = $sub1007;
 
1823
                    var $copy_5 = $add1004;
 
1824
                  } else if ($tmp26 << 16 >> 16 == 17) {
 
1825
                    var $add1020 = $conv893 + 3 | 0;
 
1826
                    var $next_33 = $next_30;
 
1827
                    var $have_33 = $have_30;
 
1828
                    var $hold_29 = $hold_26;
 
1829
                    var $bits_29 = $bits_26;
 
1830
                    while (1) {
 
1831
                      var $bits_29;
 
1832
                      var $hold_29;
 
1833
                      var $have_33;
 
1834
                      var $next_33;
 
1835
                      var $cmp1021 = $bits_29 >>> 0 < $add1020 >>> 0;
 
1836
                      if (!$cmp1021) {
 
1837
                        break;
 
1838
                      }
 
1839
                      var $cmp1025 = ($have_33 | 0) == 0;
 
1840
                      if ($cmp1025) {
 
1841
                        var $ret_8 = $ret_1_ph;
 
1842
                        var $next_58 = $next_33;
 
1843
                        var $have_58 = 0;
 
1844
                        var $hold_54 = $hold_29;
 
1845
                        var $bits_54 = $bits_29;
 
1846
                        var $out_4 = $out_0;
 
1847
                        break $_$12;
 
1848
                      }
 
1849
                      var $dec1029 = $have_33 - 1 | 0;
 
1850
                      var $incdec_ptr1030 = $next_33 + 1 | 0;
 
1851
                      var $137 = HEAPU8[$next_33];
 
1852
                      var $conv1031 = $137 & 255;
 
1853
                      var $shl1032 = $conv1031 << $bits_29;
 
1854
                      var $add1033 = $shl1032 + $hold_29 | 0;
 
1855
                      var $add1034 = $bits_29 + 8 | 0;
 
1856
                      var $next_33 = $incdec_ptr1030;
 
1857
                      var $have_33 = $dec1029;
 
1858
                      var $hold_29 = $add1033;
 
1859
                      var $bits_29 = $add1034;
 
1860
                    }
 
1861
                    var $shr1043 = $hold_29 >>> ($conv893 >>> 0);
 
1862
                    var $and1049 = $shr1043 & 7;
 
1863
                    var $add1050 = $and1049 + 3 | 0;
 
1864
                    var $shr1052 = $shr1043 >>> 3;
 
1865
                    var $sub1046 = -3 - $conv893 | 0;
 
1866
                    var $sub1053 = $sub1046 + $bits_29 | 0;
 
1867
                    var $len_0 = 0;
 
1868
                    var $next_35 = $next_33;
 
1869
                    var $have_35 = $have_33;
 
1870
                    var $hold_31 = $shr1052;
 
1871
                    var $bits_31 = $sub1053;
 
1872
                    var $copy_5 = $add1050;
 
1873
                  } else {
 
1874
                    var $add1061 = $conv893 + 7 | 0;
 
1875
                    var $next_34 = $next_30;
 
1876
                    var $have_34 = $have_30;
 
1877
                    var $hold_30 = $hold_26;
 
1878
                    var $bits_30 = $bits_26;
 
1879
                    while (1) {
 
1880
                      var $bits_30;
 
1881
                      var $hold_30;
 
1882
                      var $have_34;
 
1883
                      var $next_34;
 
1884
                      var $cmp1062 = $bits_30 >>> 0 < $add1061 >>> 0;
 
1885
                      if (!$cmp1062) {
 
1886
                        break;
 
1887
                      }
 
1888
                      var $cmp1066 = ($have_34 | 0) == 0;
 
1889
                      if ($cmp1066) {
 
1890
                        var $ret_8 = $ret_1_ph;
 
1891
                        var $next_58 = $next_34;
 
1892
                        var $have_58 = 0;
 
1893
                        var $hold_54 = $hold_30;
 
1894
                        var $bits_54 = $bits_30;
 
1895
                        var $out_4 = $out_0;
 
1896
                        break $_$12;
 
1897
                      }
 
1898
                      var $dec1070 = $have_34 - 1 | 0;
 
1899
                      var $incdec_ptr1071 = $next_34 + 1 | 0;
 
1900
                      var $138 = HEAPU8[$next_34];
 
1901
                      var $conv1072 = $138 & 255;
 
1902
                      var $shl1073 = $conv1072 << $bits_30;
 
1903
                      var $add1074 = $shl1073 + $hold_30 | 0;
 
1904
                      var $add1075 = $bits_30 + 8 | 0;
 
1905
                      var $next_34 = $incdec_ptr1071;
 
1906
                      var $have_34 = $dec1070;
 
1907
                      var $hold_30 = $add1074;
 
1908
                      var $bits_30 = $add1075;
 
1909
                    }
 
1910
                    var $shr1084 = $hold_30 >>> ($conv893 >>> 0);
 
1911
                    var $and1090 = $shr1084 & 127;
 
1912
                    var $add1091 = $and1090 + 11 | 0;
 
1913
                    var $shr1093 = $shr1084 >>> 7;
 
1914
                    var $sub1087 = -7 - $conv893 | 0;
 
1915
                    var $sub1094 = $sub1087 + $bits_30 | 0;
 
1916
                    var $len_0 = 0;
 
1917
                    var $next_35 = $next_34;
 
1918
                    var $have_35 = $have_34;
 
1919
                    var $hold_31 = $shr1093;
 
1920
                    var $bits_31 = $sub1094;
 
1921
                    var $copy_5 = $add1091;
 
1922
                  }
 
1923
                  var $copy_5;
 
1924
                  var $bits_31;
 
1925
                  var $hold_31;
 
1926
                  var $have_35;
 
1927
                  var $next_35;
 
1928
                  var $len_0;
 
1929
                  var $add1100 = $128 + $copy_5 | 0;
 
1930
                  var $cmp1104 = $add1100 >>> 0 > $add881 >>> 0;
 
1931
                  if ($cmp1104) {
 
1932
                    HEAP32[$msg >> 2] = STRING_TABLE.__str10107 | 0;
 
1933
                    HEAP32[$mode >> 2] = 29;
 
1934
                    var $ret_0_be = $ret_1_ph;
 
1935
                    var $next_0_be = $next_35;
 
1936
                    var $put_0_be = $put_0;
 
1937
                    var $have_0_be = $have_35;
 
1938
                    var $left_0_be = $left_0;
 
1939
                    var $hold_0_be = $hold_31;
 
1940
                    var $bits_0_be = $bits_31;
 
1941
                    var $out_0_be = $out_0;
 
1942
                    __label__ = 268;
 
1943
                    break $_$148;
 
1944
                  }
 
1945
                  var $copy_6127 = $copy_5;
 
1946
                  var $139 = $128;
 
1947
                  while (1) {
 
1948
                    var $139;
 
1949
                    var $copy_6127;
 
1950
                    var $dec1111 = $copy_6127 - 1 | 0;
 
1951
                    var $inc1116 = $139 + 1 | 0;
 
1952
                    HEAP32[$40 >> 2] = $inc1116;
 
1953
                    var $arrayidx1118 = $41 + ($139 << 1) | 0;
 
1954
                    HEAP16[$arrayidx1118 >> 1] = $len_0;
 
1955
                    var $tobool1112 = ($dec1111 | 0) == 0;
 
1956
                    if ($tobool1112) {
 
1957
                      var $next_29 = $next_35;
 
1958
                      var $have_29 = $have_35;
 
1959
                      var $hold_25 = $hold_31;
 
1960
                      var $bits_25 = $bits_31;
 
1961
                      continue $_$167;
 
1962
                    }
 
1963
                    var $_pre892 = HEAP32[$40 >> 2];
 
1964
                    var $copy_6127 = $dec1111;
 
1965
                    var $139 = $_pre892;
 
1966
                  }
 
1967
                }
 
1968
              } else {
 
1969
                var $_pr38 = HEAP32[$mode >> 2];
 
1970
                var $cmp1123 = ($_pr38 | 0) == 29;
 
1971
                if ($cmp1123) {
 
1972
                  var $ret_0_be = $ret_1_ph;
 
1973
                  var $next_0_be = $next_29;
 
1974
                  var $put_0_be = $put_0;
 
1975
                  var $have_0_be = $have_29;
 
1976
                  var $left_0_be = $left_0;
 
1977
                  var $hold_0_be = $hold_25;
 
1978
                  var $bits_0_be = $bits_25;
 
1979
                  var $out_0_be = $out_0;
 
1980
                  __label__ = 268;
 
1981
                  break $_$148;
 
1982
                }
 
1983
                var $140 = HEAP16[$45 >> 1];
 
1984
                var $cmp1130 = $140 << 16 >> 16 == 0;
 
1985
                if ($cmp1130) {
 
1986
                  HEAP32[$msg >> 2] = STRING_TABLE.__str11108 | 0;
 
1987
                  HEAP32[$mode >> 2] = 29;
 
1988
                  var $ret_0_be = $ret_1_ph;
 
1989
                  var $next_0_be = $next_29;
 
1990
                  var $put_0_be = $put_0;
 
1991
                  var $have_0_be = $have_29;
 
1992
                  var $left_0_be = $left_0;
 
1993
                  var $hold_0_be = $hold_25;
 
1994
                  var $bits_0_be = $bits_25;
 
1995
                  var $out_0_be = $out_0;
 
1996
                  __label__ = 268;
 
1997
                  break $_$148;
 
1998
                }
 
1999
                HEAP32[$43 >> 2] = $arraydecay860_c;
 
2000
                HEAP32[$44 >> 2] = $arraydecay860_c;
 
2001
                HEAP32[$26 >> 2] = 9;
 
2002
                var $call1149 = _inflate_table(1, $arraydecay864, $129, $42, $26, $arraydecay867);
 
2003
                var $tobool1150 = ($call1149 | 0) == 0;
 
2004
                if (!$tobool1150) {
 
2005
                  HEAP32[$msg >> 2] = STRING_TABLE.__str12109 | 0;
 
2006
                  HEAP32[$mode >> 2] = 29;
 
2007
                  var $ret_0_be = $call1149;
 
2008
                  var $next_0_be = $next_29;
 
2009
                  var $put_0_be = $put_0;
 
2010
                  var $have_0_be = $have_29;
 
2011
                  var $left_0_be = $left_0;
 
2012
                  var $hold_0_be = $hold_25;
 
2013
                  var $bits_0_be = $bits_25;
 
2014
                  var $out_0_be = $out_0;
 
2015
                  __label__ = 268;
 
2016
                  break $_$148;
 
2017
                }
 
2018
                var $141 = HEAP32[$42 >> 2];
 
2019
                var $_c = $141;
 
2020
                HEAP32[$46 >> 2] = $_c;
 
2021
                HEAP32[$47 >> 2] = 6;
 
2022
                var $142 = HEAP32[$37 >> 2];
 
2023
                var $add_ptr1159 = $arraydecay864 + ($142 << 1) | 0;
 
2024
                var $143 = HEAP32[$38 >> 2];
 
2025
                var $call1165 = _inflate_table(2, $add_ptr1159, $143, $42, $47, $arraydecay867);
 
2026
                var $tobool1166 = ($call1165 | 0) == 0;
 
2027
                if (!$tobool1166) {
 
2028
                  HEAP32[$msg >> 2] = STRING_TABLE.__str13110 | 0;
 
2029
                  HEAP32[$mode >> 2] = 29;
 
2030
                  var $ret_0_be = $call1165;
 
2031
                  var $next_0_be = $next_29;
 
2032
                  var $put_0_be = $put_0;
 
2033
                  var $have_0_be = $have_29;
 
2034
                  var $left_0_be = $left_0;
 
2035
                  var $hold_0_be = $hold_25;
 
2036
                  var $bits_0_be = $bits_25;
 
2037
                  var $out_0_be = $out_0;
 
2038
                  __label__ = 268;
 
2039
                  break $_$148;
 
2040
                }
 
2041
                HEAP32[$mode >> 2] = 19;
 
2042
                if ($cmp660) {
 
2043
                  var $ret_8 = 0;
 
2044
                  var $next_58 = $next_29;
 
2045
                  var $have_58 = $have_29;
 
2046
                  var $hold_54 = $hold_25;
 
2047
                  var $bits_54 = $bits_25;
 
2048
                  var $out_4 = $out_0;
 
2049
                  break $_$12;
 
2050
                }
 
2051
                var $ret_2 = 0;
 
2052
                var $next_37 = $next_29;
 
2053
                var $have_37 = $have_29;
 
2054
                var $hold_33 = $hold_25;
 
2055
                var $bits_33 = $bits_25;
 
2056
                __label__ = 205;
 
2057
                break $_$148;
 
2058
              }
 
2059
            }
 
2060
          }
 
2061
        } while (0);
 
2062
        do {
 
2063
          if (__label__ == 60) {
 
2064
            var $bits_5;
 
2065
            var $hold_5;
 
2066
            var $have_5;
 
2067
            var $next_5;
 
2068
            var $71 = HEAPU32[$17 >> 2];
 
2069
            var $and262 = $71 & 1024;
 
2070
            var $tobool263 = ($and262 | 0) == 0;
 
2071
            do {
 
2072
              if ($tobool263) {
 
2073
                var $76 = HEAP32[$18 >> 2];
 
2074
                var $cmp310 = ($76 | 0) == 0;
 
2075
                if ($cmp310) {
 
2076
                  var $next_7 = $next_5;
 
2077
                  var $have_7 = $have_5;
 
2078
                  var $hold_7 = $hold_5;
 
2079
                  var $bits_7 = $bits_5;
 
2080
                  break;
 
2081
                }
 
2082
                var $extra = $76 + 16 | 0;
 
2083
                HEAP32[$extra >> 2] = 0;
 
2084
                var $next_7 = $next_5;
 
2085
                var $have_7 = $have_5;
 
2086
                var $hold_7 = $hold_5;
 
2087
                var $bits_7 = $bits_5;
 
2088
              } else {
 
2089
                var $next_6 = $next_5;
 
2090
                var $have_6 = $have_5;
 
2091
                var $hold_6 = $hold_5;
 
2092
                var $bits_6 = $bits_5;
 
2093
                while (1) {
 
2094
                  var $bits_6;
 
2095
                  var $hold_6;
 
2096
                  var $have_6;
 
2097
                  var $next_6;
 
2098
                  var $cmp267 = $bits_6 >>> 0 < 16;
 
2099
                  if (!$cmp267) {
 
2100
                    break;
 
2101
                  }
 
2102
                  var $cmp271 = ($have_6 | 0) == 0;
 
2103
                  if ($cmp271) {
 
2104
                    var $ret_8 = $ret_0;
 
2105
                    var $next_58 = $next_6;
 
2106
                    var $have_58 = 0;
 
2107
                    var $hold_54 = $hold_6;
 
2108
                    var $bits_54 = $bits_6;
 
2109
                    var $out_4 = $out_0;
 
2110
                    break $_$12;
 
2111
                  }
 
2112
                  var $dec275 = $have_6 - 1 | 0;
 
2113
                  var $incdec_ptr276 = $next_6 + 1 | 0;
 
2114
                  var $72 = HEAPU8[$next_6];
 
2115
                  var $conv277 = $72 & 255;
 
2116
                  var $shl278 = $conv277 << $bits_6;
 
2117
                  var $add279 = $shl278 + $hold_6 | 0;
 
2118
                  var $add280 = $bits_6 + 8 | 0;
 
2119
                  var $next_6 = $incdec_ptr276;
 
2120
                  var $have_6 = $dec275;
 
2121
                  var $hold_6 = $add279;
 
2122
                  var $bits_6 = $add280;
 
2123
                }
 
2124
                HEAP32[$21 >> 2] = $hold_6;
 
2125
                var $73 = HEAP32[$18 >> 2];
 
2126
                var $cmp285 = ($73 | 0) == 0;
 
2127
                if ($cmp285) {
 
2128
                  var $74 = $71;
 
2129
                } else {
 
2130
                  var $extra_len = $73 + 20 | 0;
 
2131
                  HEAP32[$extra_len >> 2] = $hold_6;
 
2132
                  var $_pre885 = HEAP32[$17 >> 2];
 
2133
                  var $74 = $_pre885;
 
2134
                }
 
2135
                var $74;
 
2136
                var $and291 = $74 & 512;
 
2137
                var $tobool292 = ($and291 | 0) == 0;
 
2138
                if ($tobool292) {
 
2139
                  var $next_7 = $next_6;
 
2140
                  var $have_7 = $have_6;
 
2141
                  var $hold_7 = 0;
 
2142
                  var $bits_7 = 0;
 
2143
                  break;
 
2144
                }
 
2145
                var $conv295 = $hold_6 & 255;
 
2146
                HEAP8[$arrayidx] = $conv295;
 
2147
                var $shr297 = $hold_6 >>> 8;
 
2148
                var $conv298 = $shr297 & 255;
 
2149
                HEAP8[$arrayidx40] = $conv298;
 
2150
                var $75 = HEAP32[$16 >> 2];
 
2151
                var $call302 = _crc32($75, $arrayidx, 2);
 
2152
                HEAP32[$16 >> 2] = $call302;
 
2153
                var $next_7 = $next_6;
 
2154
                var $have_7 = $have_6;
 
2155
                var $hold_7 = 0;
 
2156
                var $bits_7 = 0;
 
2157
              }
 
2158
            } while (0);
 
2159
            var $bits_7;
 
2160
            var $hold_7;
 
2161
            var $have_7;
 
2162
            var $next_7;
 
2163
            HEAP32[$mode >> 2] = 5;
 
2164
            var $next_8 = $next_7;
 
2165
            var $have_8 = $have_7;
 
2166
            var $hold_8 = $hold_7;
 
2167
            var $bits_8 = $bits_7;
 
2168
            __label__ = 71;
 
2169
            break;
 
2170
          } else if (__label__ == 124) {
 
2171
            var $bits_17;
 
2172
            var $hold_17;
 
2173
            var $have_21;
 
2174
            var $next_21;
 
2175
            var $116 = HEAP32[$24 >> 2];
 
2176
            var $tobool616 = ($116 | 0) == 0;
 
2177
            if ($tobool616) {
 
2178
              var $next_22 = $next_21;
 
2179
              var $have_22 = $have_21;
 
2180
              var $hold_18 = $hold_17;
 
2181
              var $bits_18 = $bits_17;
 
2182
              while (1) {
 
2183
                var $bits_18;
 
2184
                var $hold_18;
 
2185
                var $have_22;
 
2186
                var $next_22;
 
2187
                var $cmp629 = $bits_18 >>> 0 < 3;
 
2188
                if (!$cmp629) {
 
2189
                  break;
 
2190
                }
 
2191
                var $cmp633 = ($have_22 | 0) == 0;
 
2192
                if ($cmp633) {
 
2193
                  var $ret_8 = $ret_0;
 
2194
                  var $next_58 = $next_22;
 
2195
                  var $have_58 = 0;
 
2196
                  var $hold_54 = $hold_18;
 
2197
                  var $bits_54 = $bits_18;
 
2198
                  var $out_4 = $out_0;
 
2199
                  break $_$12;
 
2200
                }
 
2201
                var $dec637 = $have_22 - 1 | 0;
 
2202
                var $incdec_ptr638 = $next_22 + 1 | 0;
 
2203
                var $117 = HEAPU8[$next_22];
 
2204
                var $conv639 = $117 & 255;
 
2205
                var $shl640 = $conv639 << $bits_18;
 
2206
                var $add641 = $shl640 + $hold_18 | 0;
 
2207
                var $add642 = $bits_18 + 8 | 0;
 
2208
                var $next_22 = $incdec_ptr638;
 
2209
                var $have_22 = $dec637;
 
2210
                var $hold_18 = $add641;
 
2211
                var $bits_18 = $add642;
 
2212
              }
 
2213
              var $and648 = $hold_18 & 1;
 
2214
              HEAP32[$24 >> 2] = $and648;
 
2215
              var $shr651 = $hold_18 >>> 1;
 
2216
              var $and655 = $shr651 & 3;
 
2217
              do {
 
2218
                if (($and655 | 0) == 0) {
 
2219
                  HEAP32[$mode >> 2] = 13;
 
2220
                } else if (($and655 | 0) == 1) {
 
2221
                  _fixedtables($4);
 
2222
                  HEAP32[$mode >> 2] = 19;
 
2223
                  if (!$cmp660) {
 
2224
                    break;
 
2225
                  }
 
2226
                  var $shr664 = $hold_18 >>> 3;
 
2227
                  var $sub665 = $bits_18 - 3 | 0;
 
2228
                  var $ret_8 = $ret_0;
 
2229
                  var $next_58 = $next_22;
 
2230
                  var $have_58 = $have_22;
 
2231
                  var $hold_54 = $shr664;
 
2232
                  var $bits_54 = $sub665;
 
2233
                  var $out_4 = $out_0;
 
2234
                  break $_$12;
 
2235
                } else if (($and655 | 0) == 2) {
 
2236
                  HEAP32[$mode >> 2] = 16;
 
2237
                } else if (($and655 | 0) == 3) {
 
2238
                  HEAP32[$msg >> 2] = STRING_TABLE.__str6103 | 0;
 
2239
                  HEAP32[$mode >> 2] = 29;
 
2240
                }
 
2241
              } while (0);
 
2242
              var $shr675 = $hold_18 >>> 3;
 
2243
              var $sub676 = $bits_18 - 3 | 0;
 
2244
              var $ret_0_be = $ret_0;
 
2245
              var $next_0_be = $next_22;
 
2246
              var $put_0_be = $put_0;
 
2247
              var $have_0_be = $have_22;
 
2248
              var $left_0_be = $left_0;
 
2249
              var $hold_0_be = $shr675;
 
2250
              var $bits_0_be = $sub676;
 
2251
              var $out_0_be = $out_0;
 
2252
              __label__ = 268;
 
2253
              break;
 
2254
            }
 
2255
            var $and619 = $bits_17 & 7;
 
2256
            var $shr620 = $hold_17 >>> ($and619 >>> 0);
 
2257
            var $sub622 = $bits_17 - $and619 | 0;
 
2258
            HEAP32[$mode >> 2] = 26;
 
2259
            var $ret_0_be = $ret_0;
 
2260
            var $next_0_be = $next_21;
 
2261
            var $put_0_be = $put_0;
 
2262
            var $have_0_be = $have_21;
 
2263
            var $left_0_be = $left_0;
 
2264
            var $hold_0_be = $shr620;
 
2265
            var $bits_0_be = $sub622;
 
2266
            var $out_0_be = $out_0;
 
2267
            __label__ = 268;
 
2268
            break;
 
2269
          } else if (__label__ == 205) {
 
2270
            var $bits_33;
 
2271
            var $hold_33;
 
2272
            var $have_37;
 
2273
            var $next_37;
 
2274
            var $ret_2;
 
2275
            HEAP32[$mode >> 2] = 20;
 
2276
            var $ret_3 = $ret_2;
 
2277
            var $next_38 = $next_37;
 
2278
            var $have_38 = $have_37;
 
2279
            var $hold_34 = $hold_33;
 
2280
            var $bits_34 = $bits_33;
 
2281
            __label__ = 206;
 
2282
            break;
 
2283
          }
 
2284
        } while (0);
 
2285
        do {
 
2286
          if (__label__ == 71) {
 
2287
            var $bits_8;
 
2288
            var $hold_8;
 
2289
            var $have_8;
 
2290
            var $next_8;
 
2291
            var $77 = HEAPU32[$17 >> 2];
 
2292
            var $and319 = $77 & 1024;
 
2293
            var $tobool320 = ($and319 | 0) == 0;
 
2294
            if ($tobool320) {
 
2295
              var $next_10 = $next_8;
 
2296
              var $have_10 = $have_8;
 
2297
              var $88 = $77;
 
2298
            } else {
 
2299
              var $78 = HEAPU32[$21 >> 2];
 
2300
              var $cmp323 = $78 >>> 0 > $have_8 >>> 0;
 
2301
              var $copy_0 = $cmp323 ? $have_8 : $78;
 
2302
              var $tobool327 = ($copy_0 | 0) == 0;
 
2303
              if ($tobool327) {
 
2304
                var $next_9 = $next_8;
 
2305
                var $have_9 = $have_8;
 
2306
                var $87 = $78;
 
2307
                var $86 = $77;
 
2308
              } else {
 
2309
                var $79 = HEAPU32[$18 >> 2];
 
2310
                var $cmp330 = ($79 | 0) == 0;
 
2311
                do {
 
2312
                  if ($cmp330) {
 
2313
                    var $83 = $77;
 
2314
                  } else {
 
2315
                    var $extra334 = $79 + 16 | 0;
 
2316
                    var $80 = HEAP32[$extra334 >> 2];
 
2317
                    var $cmp335 = ($80 | 0) == 0;
 
2318
                    if ($cmp335) {
 
2319
                      var $83 = $77;
 
2320
                      break;
 
2321
                    }
 
2322
                    var $extra_len339 = $79 + 20 | 0;
 
2323
                    var $81 = HEAP32[$extra_len339 >> 2];
 
2324
                    var $sub341 = $81 - $78 | 0;
 
2325
                    var $add_ptr = $80 + $sub341 | 0;
 
2326
                    var $add344 = $sub341 + $copy_0 | 0;
 
2327
                    var $extra_max = $79 + 24 | 0;
 
2328
                    var $82 = HEAPU32[$extra_max >> 2];
 
2329
                    var $cmp346 = $add344 >>> 0 > $82 >>> 0;
 
2330
                    var $sub350 = $82 - $sub341 | 0;
 
2331
                    var $cond351 = $cmp346 ? $sub350 : $copy_0;
 
2332
                    _memcpy($add_ptr, $next_8, $cond351, 1);
 
2333
                    var $_pre886 = HEAP32[$17 >> 2];
 
2334
                    var $83 = $_pre886;
 
2335
                  }
 
2336
                } while (0);
 
2337
                var $83;
 
2338
                var $and354 = $83 & 512;
 
2339
                var $tobool355 = ($and354 | 0) == 0;
 
2340
                if (!$tobool355) {
 
2341
                  var $84 = HEAP32[$16 >> 2];
 
2342
                  var $call358 = _crc32($84, $next_8, $copy_0);
 
2343
                  HEAP32[$16 >> 2] = $call358;
 
2344
                }
 
2345
                var $sub361 = $have_8 - $copy_0 | 0;
 
2346
                var $add_ptr362 = $next_8 + $copy_0 | 0;
 
2347
                var $85 = HEAP32[$21 >> 2];
 
2348
                var $sub364 = $85 - $copy_0 | 0;
 
2349
                HEAP32[$21 >> 2] = $sub364;
 
2350
                var $next_9 = $add_ptr362;
 
2351
                var $have_9 = $sub361;
 
2352
                var $87 = $sub364;
 
2353
                var $86 = $83;
 
2354
              }
 
2355
              var $86;
 
2356
              var $87;
 
2357
              var $have_9;
 
2358
              var $next_9;
 
2359
              var $tobool367 = ($87 | 0) == 0;
 
2360
              if (!$tobool367) {
 
2361
                var $ret_8 = $ret_0;
 
2362
                var $next_58 = $next_9;
 
2363
                var $have_58 = $have_9;
 
2364
                var $hold_54 = $hold_8;
 
2365
                var $bits_54 = $bits_8;
 
2366
                var $out_4 = $out_0;
 
2367
                break $_$12;
 
2368
              }
 
2369
              var $next_10 = $next_9;
 
2370
              var $have_10 = $have_9;
 
2371
              var $88 = $86;
 
2372
            }
 
2373
            var $88;
 
2374
            var $have_10;
 
2375
            var $next_10;
 
2376
            HEAP32[$21 >> 2] = 0;
 
2377
            HEAP32[$mode >> 2] = 6;
 
2378
            var $next_11 = $next_10;
 
2379
            var $have_11 = $have_10;
 
2380
            var $hold_9 = $hold_8;
 
2381
            var $bits_9 = $bits_8;
 
2382
            var $89 = $88;
 
2383
            __label__ = 81;
 
2384
            break;
 
2385
          } else if (__label__ == 206) {
 
2386
            var $bits_34;
 
2387
            var $hold_34;
 
2388
            var $have_38;
 
2389
            var $next_38;
 
2390
            var $ret_3;
 
2391
            var $cmp1179 = $have_38 >>> 0 > 5;
 
2392
            var $cmp1182 = $left_0 >>> 0 > 257;
 
2393
            var $or_cond33 = $cmp1179 & $cmp1182;
 
2394
            if ($or_cond33) {
 
2395
              HEAP32[$next_out >> 2] = $put_0;
 
2396
              HEAP32[$avail_out >> 2] = $left_0;
 
2397
              HEAP32[$next_in >> 2] = $next_38;
 
2398
              HEAP32[$avail_in15 >> 2] = $have_38;
 
2399
              HEAP32[$11 >> 2] = $hold_34;
 
2400
              HEAP32[$13 >> 2] = $bits_34;
 
2401
              _inflate_fast($strm, $out_0);
 
2402
              var $144 = HEAP32[$next_out >> 2];
 
2403
              var $145 = HEAP32[$avail_out >> 2];
 
2404
              var $146 = HEAP32[$next_in >> 2];
 
2405
              var $147 = HEAP32[$avail_in15 >> 2];
 
2406
              var $148 = HEAP32[$11 >> 2];
 
2407
              var $149 = HEAP32[$13 >> 2];
 
2408
              var $150 = HEAP32[$mode >> 2];
 
2409
              var $cmp1204 = ($150 | 0) == 11;
 
2410
              if (!$cmp1204) {
 
2411
                var $ret_0_be = $ret_3;
 
2412
                var $next_0_be = $146;
 
2413
                var $put_0_be = $144;
 
2414
                var $have_0_be = $147;
 
2415
                var $left_0_be = $145;
 
2416
                var $hold_0_be = $148;
 
2417
                var $bits_0_be = $149;
 
2418
                var $out_0_be = $out_0;
 
2419
                __label__ = 268;
 
2420
                break;
 
2421
              }
 
2422
              HEAP32[$25 >> 2] = -1;
 
2423
              var $ret_0_be = $ret_3;
 
2424
              var $next_0_be = $146;
 
2425
              var $put_0_be = $144;
 
2426
              var $have_0_be = $147;
 
2427
              var $left_0_be = $145;
 
2428
              var $hold_0_be = $148;
 
2429
              var $bits_0_be = $149;
 
2430
              var $out_0_be = $out_0;
 
2431
              __label__ = 268;
 
2432
              break;
 
2433
            }
 
2434
            HEAP32[$25 >> 2] = 0;
 
2435
            var $151 = HEAP32[$26 >> 2];
 
2436
            var $shl1212 = 1 << $151;
 
2437
            var $sub1213 = $shl1212 - 1 | 0;
 
2438
            var $152 = HEAPU32[$27 >> 2];
 
2439
            var $next_39 = $next_38;
 
2440
            var $have_39 = $have_38;
 
2441
            var $hold_35 = $hold_34;
 
2442
            var $bits_35 = $bits_34;
 
2443
            while (1) {
 
2444
              var $bits_35;
 
2445
              var $hold_35;
 
2446
              var $have_39;
 
2447
              var $next_39;
 
2448
              var $and1214 = $sub1213 & $hold_35;
 
2449
              var $arrayidx1216_1 = $152 + ($and1214 << 2) + 1 | 0;
 
2450
              var $tmp22 = HEAPU8[$arrayidx1216_1];
 
2451
              var $conv1218 = $tmp22 & 255;
 
2452
              var $cmp1219 = $conv1218 >>> 0 > $bits_35 >>> 0;
 
2453
              if (!$cmp1219) {
 
2454
                break;
 
2455
              }
 
2456
              var $cmp1224 = ($have_39 | 0) == 0;
 
2457
              if ($cmp1224) {
 
2458
                var $ret_8 = $ret_3;
 
2459
                var $next_58 = $next_39;
 
2460
                var $have_58 = 0;
 
2461
                var $hold_54 = $hold_35;
 
2462
                var $bits_54 = $bits_35;
 
2463
                var $out_4 = $out_0;
 
2464
                break $_$12;
 
2465
              }
 
2466
              var $dec1228 = $have_39 - 1 | 0;
 
2467
              var $incdec_ptr1229 = $next_39 + 1 | 0;
 
2468
              var $153 = HEAPU8[$next_39];
 
2469
              var $conv1230 = $153 & 255;
 
2470
              var $shl1231 = $conv1230 << $bits_35;
 
2471
              var $add1232 = $shl1231 + $hold_35 | 0;
 
2472
              var $add1233 = $bits_35 + 8 | 0;
 
2473
              var $next_39 = $incdec_ptr1229;
 
2474
              var $have_39 = $dec1228;
 
2475
              var $hold_35 = $add1232;
 
2476
              var $bits_35 = $add1233;
 
2477
            }
 
2478
            var $arrayidx1216_0 = $152 + ($and1214 << 2) | 0;
 
2479
            var $tmp21 = HEAPU8[$arrayidx1216_0];
 
2480
            var $arrayidx1216_2 = $152 + ($and1214 << 2) + 2 | 0;
 
2481
            var $tmp23 = HEAPU16[$arrayidx1216_2 >> 1];
 
2482
            var $conv1237 = $tmp21 & 255;
 
2483
            var $tobool1238 = $tmp21 << 24 >> 24 == 0;
 
2484
            do {
 
2485
              if ($tobool1238) {
 
2486
                var $next_41 = $next_39;
 
2487
                var $have_41 = $have_39;
 
2488
                var $hold_37 = $hold_35;
 
2489
                var $bits_37 = $bits_35;
 
2490
                var $here_09_0 = 0;
 
2491
                var $here_110_0 = $tmp22;
 
2492
                var $here_211_0 = $tmp23;
 
2493
                var $155 = 0;
 
2494
              } else {
 
2495
                var $and1242 = $conv1237 & 240;
 
2496
                var $cmp1243 = ($and1242 | 0) == 0;
 
2497
                if (!$cmp1243) {
 
2498
                  var $next_41 = $next_39;
 
2499
                  var $have_41 = $have_39;
 
2500
                  var $hold_37 = $hold_35;
 
2501
                  var $bits_37 = $bits_35;
 
2502
                  var $here_09_0 = $tmp21;
 
2503
                  var $here_110_0 = $tmp22;
 
2504
                  var $here_211_0 = $tmp23;
 
2505
                  var $155 = 0;
 
2506
                  break;
 
2507
                }
 
2508
                var $conv1248 = $tmp23 & 65535;
 
2509
                var $add1253 = $conv1218 + $conv1237 | 0;
 
2510
                var $shl1254 = 1 << $add1253;
 
2511
                var $sub1255 = $shl1254 - 1 | 0;
 
2512
                var $next_40 = $next_39;
 
2513
                var $have_40 = $have_39;
 
2514
                var $hold_36 = $hold_35;
 
2515
                var $bits_36 = $bits_35;
 
2516
                while (1) {
 
2517
                  var $bits_36;
 
2518
                  var $hold_36;
 
2519
                  var $have_40;
 
2520
                  var $next_40;
 
2521
                  var $and1256 = $hold_36 & $sub1255;
 
2522
                  var $shr1259 = $and1256 >>> ($conv1218 >>> 0);
 
2523
                  var $add1260 = $shr1259 + $conv1248 | 0;
 
2524
                  var $arrayidx1262_1 = $152 + ($add1260 << 2) + 1 | 0;
 
2525
                  var $tmp19 = HEAPU8[$arrayidx1262_1];
 
2526
                  var $conv1266 = $tmp19 & 255;
 
2527
                  var $add1267 = $conv1266 + $conv1218 | 0;
 
2528
                  var $cmp1268 = $add1267 >>> 0 > $bits_36 >>> 0;
 
2529
                  if (!$cmp1268) {
 
2530
                    break;
 
2531
                  }
 
2532
                  var $cmp1273 = ($have_40 | 0) == 0;
 
2533
                  if ($cmp1273) {
 
2534
                    var $ret_8 = $ret_3;
 
2535
                    var $next_58 = $next_40;
 
2536
                    var $have_58 = 0;
 
2537
                    var $hold_54 = $hold_36;
 
2538
                    var $bits_54 = $bits_36;
 
2539
                    var $out_4 = $out_0;
 
2540
                    break $_$12;
 
2541
                  }
 
2542
                  var $dec1277 = $have_40 - 1 | 0;
 
2543
                  var $incdec_ptr1278 = $next_40 + 1 | 0;
 
2544
                  var $154 = HEAPU8[$next_40];
 
2545
                  var $conv1279 = $154 & 255;
 
2546
                  var $shl1280 = $conv1279 << $bits_36;
 
2547
                  var $add1281 = $shl1280 + $hold_36 | 0;
 
2548
                  var $add1282 = $bits_36 + 8 | 0;
 
2549
                  var $next_40 = $incdec_ptr1278;
 
2550
                  var $have_40 = $dec1277;
 
2551
                  var $hold_36 = $add1281;
 
2552
                  var $bits_36 = $add1282;
 
2553
                }
 
2554
                var $arrayidx1262_2 = $152 + ($add1260 << 2) + 2 | 0;
 
2555
                var $arrayidx1262_0 = $152 + ($add1260 << 2) | 0;
 
2556
                var $tmp20 = HEAP16[$arrayidx1262_2 >> 1];
 
2557
                var $tmp18 = HEAP8[$arrayidx1262_0];
 
2558
                var $shr1289 = $hold_36 >>> ($conv1218 >>> 0);
 
2559
                var $sub1292 = $bits_36 - $conv1218 | 0;
 
2560
                HEAP32[$25 >> 2] = $conv1218;
 
2561
                var $next_41 = $next_40;
 
2562
                var $have_41 = $have_40;
 
2563
                var $hold_37 = $shr1289;
 
2564
                var $bits_37 = $sub1292;
 
2565
                var $here_09_0 = $tmp18;
 
2566
                var $here_110_0 = $tmp19;
 
2567
                var $here_211_0 = $tmp20;
 
2568
                var $155 = $conv1218;
 
2569
              }
 
2570
            } while (0);
 
2571
            var $155;
 
2572
            var $here_211_0;
 
2573
            var $here_110_0;
 
2574
            var $here_09_0;
 
2575
            var $bits_37;
 
2576
            var $hold_37;
 
2577
            var $have_41;
 
2578
            var $next_41;
 
2579
            var $conv1302 = $here_110_0 & 255;
 
2580
            var $shr1303 = $hold_37 >>> ($conv1302 >>> 0);
 
2581
            var $sub1306 = $bits_37 - $conv1302 | 0;
 
2582
            var $add1312 = $155 + $conv1302 | 0;
 
2583
            HEAP32[$25 >> 2] = $add1312;
 
2584
            var $conv1314 = $here_211_0 & 65535;
 
2585
            HEAP32[$21 >> 2] = $conv1314;
 
2586
            var $conv1317 = $here_09_0 & 255;
 
2587
            var $cmp1318 = $here_09_0 << 24 >> 24 == 0;
 
2588
            if ($cmp1318) {
 
2589
              HEAP32[$mode >> 2] = 25;
 
2590
              var $ret_0_be = $ret_3;
 
2591
              var $next_0_be = $next_41;
 
2592
              var $put_0_be = $put_0;
 
2593
              var $have_0_be = $have_41;
 
2594
              var $left_0_be = $left_0;
 
2595
              var $hold_0_be = $shr1303;
 
2596
              var $bits_0_be = $sub1306;
 
2597
              var $out_0_be = $out_0;
 
2598
              __label__ = 268;
 
2599
              break;
 
2600
            }
 
2601
            var $and1325 = $conv1317 & 32;
 
2602
            var $tobool1326 = ($and1325 | 0) == 0;
 
2603
            if (!$tobool1326) {
 
2604
              HEAP32[$25 >> 2] = -1;
 
2605
              HEAP32[$mode >> 2] = 11;
 
2606
              var $ret_0_be = $ret_3;
 
2607
              var $next_0_be = $next_41;
 
2608
              var $put_0_be = $put_0;
 
2609
              var $have_0_be = $have_41;
 
2610
              var $left_0_be = $left_0;
 
2611
              var $hold_0_be = $shr1303;
 
2612
              var $bits_0_be = $sub1306;
 
2613
              var $out_0_be = $out_0;
 
2614
              __label__ = 268;
 
2615
              break;
 
2616
            }
 
2617
            var $and1333 = $conv1317 & 64;
 
2618
            var $tobool1334 = ($and1333 | 0) == 0;
 
2619
            if ($tobool1334) {
 
2620
              var $and1341 = $conv1317 & 15;
 
2621
              HEAP32[$28 >> 2] = $and1341;
 
2622
              HEAP32[$mode >> 2] = 21;
 
2623
              var $ret_4 = $ret_3;
 
2624
              var $next_42 = $next_41;
 
2625
              var $have_42 = $have_41;
 
2626
              var $hold_38 = $shr1303;
 
2627
              var $bits_38 = $sub1306;
 
2628
              var $156 = $and1341;
 
2629
              __label__ = 227;
 
2630
              break;
 
2631
            }
 
2632
            HEAP32[$msg >> 2] = STRING_TABLE.__str2171 | 0;
 
2633
            HEAP32[$mode >> 2] = 29;
 
2634
            var $ret_0_be = $ret_3;
 
2635
            var $next_0_be = $next_41;
 
2636
            var $put_0_be = $put_0;
 
2637
            var $have_0_be = $have_41;
 
2638
            var $left_0_be = $left_0;
 
2639
            var $hold_0_be = $shr1303;
 
2640
            var $bits_0_be = $sub1306;
 
2641
            var $out_0_be = $out_0;
 
2642
            __label__ = 268;
 
2643
            break;
 
2644
          }
 
2645
        } while (0);
 
2646
        do {
 
2647
          if (__label__ == 81) {
 
2648
            var $89;
 
2649
            var $bits_9;
 
2650
            var $hold_9;
 
2651
            var $have_11;
 
2652
            var $next_11;
 
2653
            var $and375 = $89 & 2048;
 
2654
            var $tobool376 = ($and375 | 0) == 0;
 
2655
            do {
 
2656
              if ($tobool376) {
 
2657
                var $98 = HEAP32[$18 >> 2];
 
2658
                var $cmp424 = ($98 | 0) == 0;
 
2659
                if ($cmp424) {
 
2660
                  var $next_12 = $next_11;
 
2661
                  var $have_12 = $have_11;
 
2662
                  break;
 
2663
                }
 
2664
                var $name428 = $98 + 28 | 0;
 
2665
                HEAP32[$name428 >> 2] = 0;
 
2666
                var $next_12 = $next_11;
 
2667
                var $have_12 = $have_11;
 
2668
              } else {
 
2669
                var $cmp378 = ($have_11 | 0) == 0;
 
2670
                if ($cmp378) {
 
2671
                  var $ret_8 = $ret_0;
 
2672
                  var $next_58 = $next_11;
 
2673
                  var $have_58 = 0;
 
2674
                  var $hold_54 = $hold_9;
 
2675
                  var $bits_54 = $bits_9;
 
2676
                  var $out_4 = $out_0;
 
2677
                  break $_$12;
 
2678
                }
 
2679
                var $copy_1 = 0;
 
2680
                while (1) {
 
2681
                  var $copy_1;
 
2682
                  var $inc = $copy_1 + 1 | 0;
 
2683
                  var $arrayidx383 = $next_11 + $copy_1 | 0;
 
2684
                  var $90 = HEAP8[$arrayidx383];
 
2685
                  var $91 = HEAP32[$18 >> 2];
 
2686
                  var $cmp386 = ($91 | 0) == 0;
 
2687
                  do {
 
2688
                    if (!$cmp386) {
 
2689
                      var $name = $91 + 28 | 0;
 
2690
                      var $92 = HEAP32[$name >> 2];
 
2691
                      var $cmp390 = ($92 | 0) == 0;
 
2692
                      if ($cmp390) {
 
2693
                        break;
 
2694
                      }
 
2695
                      var $93 = HEAPU32[$21 >> 2];
 
2696
                      var $name_max = $91 + 32 | 0;
 
2697
                      var $94 = HEAPU32[$name_max >> 2];
 
2698
                      var $cmp395 = $93 >>> 0 < $94 >>> 0;
 
2699
                      if (!$cmp395) {
 
2700
                        break;
 
2701
                      }
 
2702
                      var $inc400 = $93 + 1 | 0;
 
2703
                      HEAP32[$21 >> 2] = $inc400;
 
2704
                      var $95 = HEAP32[$name >> 2];
 
2705
                      var $arrayidx403 = $95 + $93 | 0;
 
2706
                      HEAP8[$arrayidx403] = $90;
 
2707
                    }
 
2708
                  } while (0);
 
2709
                  var $tobool405 = $90 << 24 >> 24 != 0;
 
2710
                  var $cmp406 = $inc >>> 0 < $have_11 >>> 0;
 
2711
                  var $or_cond31 = $tobool405 & $cmp406;
 
2712
                  if (!$or_cond31) {
 
2713
                    break;
 
2714
                  }
 
2715
                  var $copy_1 = $inc;
 
2716
                }
 
2717
                var $96 = HEAP32[$17 >> 2];
 
2718
                var $and410 = $96 & 512;
 
2719
                var $tobool411 = ($and410 | 0) == 0;
 
2720
                if (!$tobool411) {
 
2721
                  var $97 = HEAP32[$16 >> 2];
 
2722
                  var $call414 = _crc32($97, $next_11, $inc);
 
2723
                  HEAP32[$16 >> 2] = $call414;
 
2724
                }
 
2725
                var $sub417 = $have_11 - $inc | 0;
 
2726
                var $add_ptr418 = $next_11 + $inc | 0;
 
2727
                if ($tobool405) {
 
2728
                  var $ret_8 = $ret_0;
 
2729
                  var $next_58 = $add_ptr418;
 
2730
                  var $have_58 = $sub417;
 
2731
                  var $hold_54 = $hold_9;
 
2732
                  var $bits_54 = $bits_9;
 
2733
                  var $out_4 = $out_0;
 
2734
                  break $_$12;
 
2735
                }
 
2736
                var $next_12 = $add_ptr418;
 
2737
                var $have_12 = $sub417;
 
2738
              }
 
2739
            } while (0);
 
2740
            var $have_12;
 
2741
            var $next_12;
 
2742
            HEAP32[$21 >> 2] = 0;
 
2743
            HEAP32[$mode >> 2] = 7;
 
2744
            var $next_13 = $next_12;
 
2745
            var $have_13 = $have_12;
 
2746
            var $hold_10 = $hold_9;
 
2747
            var $bits_10 = $bits_9;
 
2748
            __label__ = 94;
 
2749
            break;
 
2750
          } else if (__label__ == 227) {
 
2751
            var $156;
 
2752
            var $bits_38;
 
2753
            var $hold_38;
 
2754
            var $have_42;
 
2755
            var $next_42;
 
2756
            var $ret_4;
 
2757
            var $tobool1346 = ($156 | 0) == 0;
 
2758
            if ($tobool1346) {
 
2759
              var $_pre890 = HEAP32[$21 >> 2];
 
2760
              var $next_44 = $next_42;
 
2761
              var $have_44 = $have_42;
 
2762
              var $hold_40 = $hold_38;
 
2763
              var $bits_40 = $bits_38;
 
2764
              var $160 = $_pre890;
 
2765
            } else {
 
2766
              var $next_43 = $next_42;
 
2767
              var $have_43 = $have_42;
 
2768
              var $hold_39 = $hold_38;
 
2769
              var $bits_39 = $bits_38;
 
2770
              while (1) {
 
2771
                var $bits_39;
 
2772
                var $hold_39;
 
2773
                var $have_43;
 
2774
                var $next_43;
 
2775
                var $cmp1351 = $bits_39 >>> 0 < $156 >>> 0;
 
2776
                if (!$cmp1351) {
 
2777
                  break;
 
2778
                }
 
2779
                var $cmp1355 = ($have_43 | 0) == 0;
 
2780
                if ($cmp1355) {
 
2781
                  var $ret_8 = $ret_4;
 
2782
                  var $next_58 = $next_43;
 
2783
                  var $have_58 = 0;
 
2784
                  var $hold_54 = $hold_39;
 
2785
                  var $bits_54 = $bits_39;
 
2786
                  var $out_4 = $out_0;
 
2787
                  break $_$12;
 
2788
                }
 
2789
                var $dec1359 = $have_43 - 1 | 0;
 
2790
                var $incdec_ptr1360 = $next_43 + 1 | 0;
 
2791
                var $157 = HEAPU8[$next_43];
 
2792
                var $conv1361 = $157 & 255;
 
2793
                var $shl1362 = $conv1361 << $bits_39;
 
2794
                var $add1363 = $shl1362 + $hold_39 | 0;
 
2795
                var $add1364 = $bits_39 + 8 | 0;
 
2796
                var $next_43 = $incdec_ptr1360;
 
2797
                var $have_43 = $dec1359;
 
2798
                var $hold_39 = $add1363;
 
2799
                var $bits_39 = $add1364;
 
2800
              }
 
2801
              var $shl1371 = 1 << $156;
 
2802
              var $sub1372 = $shl1371 - 1 | 0;
 
2803
              var $and1373 = $sub1372 & $hold_39;
 
2804
              var $158 = HEAP32[$21 >> 2];
 
2805
              var $add1375 = $158 + $and1373 | 0;
 
2806
              HEAP32[$21 >> 2] = $add1375;
 
2807
              var $shr1378 = $hold_39 >>> ($156 >>> 0);
 
2808
              var $sub1380 = $bits_39 - $156 | 0;
 
2809
              var $159 = HEAP32[$25 >> 2];
 
2810
              var $add1385 = $159 + $156 | 0;
 
2811
              HEAP32[$25 >> 2] = $add1385;
 
2812
              var $next_44 = $next_43;
 
2813
              var $have_44 = $have_43;
 
2814
              var $hold_40 = $shr1378;
 
2815
              var $bits_40 = $sub1380;
 
2816
              var $160 = $add1375;
 
2817
            }
 
2818
            var $160;
 
2819
            var $bits_40;
 
2820
            var $hold_40;
 
2821
            var $have_44;
 
2822
            var $next_44;
 
2823
            HEAP32[$29 >> 2] = $160;
 
2824
            HEAP32[$mode >> 2] = 22;
 
2825
            var $ret_5_ph = $ret_4;
 
2826
            var $next_45_ph = $next_44;
 
2827
            var $have_45_ph = $have_44;
 
2828
            var $hold_41_ph = $hold_40;
 
2829
            var $bits_41_ph = $bits_40;
 
2830
            __label__ = 234;
 
2831
            break;
 
2832
          }
 
2833
        } while (0);
 
2834
        do {
 
2835
          if (__label__ == 94) {
 
2836
            var $bits_10;
 
2837
            var $hold_10;
 
2838
            var $have_13;
 
2839
            var $next_13;
 
2840
            var $99 = HEAP32[$17 >> 2];
 
2841
            var $and435 = $99 & 4096;
 
2842
            var $tobool436 = ($and435 | 0) == 0;
 
2843
            do {
 
2844
              if ($tobool436) {
 
2845
                var $108 = HEAP32[$18 >> 2];
 
2846
                var $cmp488 = ($108 | 0) == 0;
 
2847
                if ($cmp488) {
 
2848
                  var $next_14 = $next_13;
 
2849
                  var $have_14 = $have_13;
 
2850
                  break;
 
2851
                }
 
2852
                var $comment492 = $108 + 36 | 0;
 
2853
                HEAP32[$comment492 >> 2] = 0;
 
2854
                var $next_14 = $next_13;
 
2855
                var $have_14 = $have_13;
 
2856
              } else {
 
2857
                var $cmp438 = ($have_13 | 0) == 0;
 
2858
                if ($cmp438) {
 
2859
                  var $ret_8 = $ret_0;
 
2860
                  var $next_58 = $next_13;
 
2861
                  var $have_58 = 0;
 
2862
                  var $hold_54 = $hold_10;
 
2863
                  var $bits_54 = $bits_10;
 
2864
                  var $out_4 = $out_0;
 
2865
                  break $_$12;
 
2866
                }
 
2867
                var $copy_2 = 0;
 
2868
                while (1) {
 
2869
                  var $copy_2;
 
2870
                  var $inc443 = $copy_2 + 1 | 0;
 
2871
                  var $arrayidx444 = $next_13 + $copy_2 | 0;
 
2872
                  var $100 = HEAP8[$arrayidx444];
 
2873
                  var $101 = HEAP32[$18 >> 2];
 
2874
                  var $cmp447 = ($101 | 0) == 0;
 
2875
                  do {
 
2876
                    if (!$cmp447) {
 
2877
                      var $comment = $101 + 36 | 0;
 
2878
                      var $102 = HEAP32[$comment >> 2];
 
2879
                      var $cmp451 = ($102 | 0) == 0;
 
2880
                      if ($cmp451) {
 
2881
                        break;
 
2882
                      }
 
2883
                      var $103 = HEAPU32[$21 >> 2];
 
2884
                      var $comm_max = $101 + 40 | 0;
 
2885
                      var $104 = HEAPU32[$comm_max >> 2];
 
2886
                      var $cmp456 = $103 >>> 0 < $104 >>> 0;
 
2887
                      if (!$cmp456) {
 
2888
                        break;
 
2889
                      }
 
2890
                      var $inc461 = $103 + 1 | 0;
 
2891
                      HEAP32[$21 >> 2] = $inc461;
 
2892
                      var $105 = HEAP32[$comment >> 2];
 
2893
                      var $arrayidx464 = $105 + $103 | 0;
 
2894
                      HEAP8[$arrayidx464] = $100;
 
2895
                    }
 
2896
                  } while (0);
 
2897
                  var $tobool467 = $100 << 24 >> 24 != 0;
 
2898
                  var $cmp469 = $inc443 >>> 0 < $have_13 >>> 0;
 
2899
                  var $or_cond32 = $tobool467 & $cmp469;
 
2900
                  if (!$or_cond32) {
 
2901
                    break;
 
2902
                  }
 
2903
                  var $copy_2 = $inc443;
 
2904
                }
 
2905
                var $106 = HEAP32[$17 >> 2];
 
2906
                var $and474 = $106 & 512;
 
2907
                var $tobool475 = ($and474 | 0) == 0;
 
2908
                if (!$tobool475) {
 
2909
                  var $107 = HEAP32[$16 >> 2];
 
2910
                  var $call478 = _crc32($107, $next_13, $inc443);
 
2911
                  HEAP32[$16 >> 2] = $call478;
 
2912
                }
 
2913
                var $sub481 = $have_13 - $inc443 | 0;
 
2914
                var $add_ptr482 = $next_13 + $inc443 | 0;
 
2915
                if ($tobool467) {
 
2916
                  var $ret_8 = $ret_0;
 
2917
                  var $next_58 = $add_ptr482;
 
2918
                  var $have_58 = $sub481;
 
2919
                  var $hold_54 = $hold_10;
 
2920
                  var $bits_54 = $bits_10;
 
2921
                  var $out_4 = $out_0;
 
2922
                  break $_$12;
 
2923
                }
 
2924
                var $next_14 = $add_ptr482;
 
2925
                var $have_14 = $sub481;
 
2926
              }
 
2927
            } while (0);
 
2928
            var $have_14;
 
2929
            var $next_14;
 
2930
            HEAP32[$mode >> 2] = 8;
 
2931
            var $next_15 = $next_14;
 
2932
            var $have_15 = $have_14;
 
2933
            var $hold_11 = $hold_10;
 
2934
            var $bits_11 = $bits_10;
 
2935
            __label__ = 107;
 
2936
            break;
 
2937
          } else if (__label__ == 234) {
 
2938
            var $bits_41_ph;
 
2939
            var $hold_41_ph;
 
2940
            var $have_45_ph;
 
2941
            var $next_45_ph;
 
2942
            var $ret_5_ph;
 
2943
            var $161 = HEAP32[$47 >> 2];
 
2944
            var $shl1392 = 1 << $161;
 
2945
            var $sub1393 = $shl1392 - 1 | 0;
 
2946
            var $162 = HEAPU32[$48 >> 2];
 
2947
            var $next_45 = $next_45_ph;
 
2948
            var $have_45 = $have_45_ph;
 
2949
            var $hold_41 = $hold_41_ph;
 
2950
            var $bits_41 = $bits_41_ph;
 
2951
            while (1) {
 
2952
              var $bits_41;
 
2953
              var $hold_41;
 
2954
              var $have_45;
 
2955
              var $next_45;
 
2956
              var $and1394 = $sub1393 & $hold_41;
 
2957
              var $arrayidx1396_1 = $162 + ($and1394 << 2) + 1 | 0;
 
2958
              var $tmp16 = HEAPU8[$arrayidx1396_1];
 
2959
              var $conv1398 = $tmp16 & 255;
 
2960
              var $cmp1399 = $conv1398 >>> 0 > $bits_41 >>> 0;
 
2961
              if (!$cmp1399) {
 
2962
                break;
 
2963
              }
 
2964
              var $cmp1404 = ($have_45 | 0) == 0;
 
2965
              if ($cmp1404) {
 
2966
                var $ret_8 = $ret_5_ph;
 
2967
                var $next_58 = $next_45;
 
2968
                var $have_58 = 0;
 
2969
                var $hold_54 = $hold_41;
 
2970
                var $bits_54 = $bits_41;
 
2971
                var $out_4 = $out_0;
 
2972
                break $_$12;
 
2973
              }
 
2974
              var $dec1408 = $have_45 - 1 | 0;
 
2975
              var $incdec_ptr1409 = $next_45 + 1 | 0;
 
2976
              var $163 = HEAPU8[$next_45];
 
2977
              var $conv1410 = $163 & 255;
 
2978
              var $shl1411 = $conv1410 << $bits_41;
 
2979
              var $add1412 = $shl1411 + $hold_41 | 0;
 
2980
              var $add1413 = $bits_41 + 8 | 0;
 
2981
              var $next_45 = $incdec_ptr1409;
 
2982
              var $have_45 = $dec1408;
 
2983
              var $hold_41 = $add1412;
 
2984
              var $bits_41 = $add1413;
 
2985
            }
 
2986
            var $arrayidx1396_0 = $162 + ($and1394 << 2) | 0;
 
2987
            var $tmp15 = HEAPU8[$arrayidx1396_0];
 
2988
            var $arrayidx1396_2 = $162 + ($and1394 << 2) + 2 | 0;
 
2989
            var $tmp17 = HEAPU16[$arrayidx1396_2 >> 1];
 
2990
            var $conv1418 = $tmp15 & 255;
 
2991
            var $and1419 = $conv1418 & 240;
 
2992
            var $cmp1420 = ($and1419 | 0) == 0;
 
2993
            if ($cmp1420) {
 
2994
              var $conv1425 = $tmp17 & 65535;
 
2995
              var $add1430 = $conv1398 + $conv1418 | 0;
 
2996
              var $shl1431 = 1 << $add1430;
 
2997
              var $sub1432 = $shl1431 - 1 | 0;
 
2998
              var $next_46 = $next_45;
 
2999
              var $have_46 = $have_45;
 
3000
              var $hold_42 = $hold_41;
 
3001
              var $bits_42 = $bits_41;
 
3002
              while (1) {
 
3003
                var $bits_42;
 
3004
                var $hold_42;
 
3005
                var $have_46;
 
3006
                var $next_46;
 
3007
                var $and1433 = $hold_42 & $sub1432;
 
3008
                var $shr1436 = $and1433 >>> ($conv1398 >>> 0);
 
3009
                var $add1437 = $shr1436 + $conv1425 | 0;
 
3010
                var $arrayidx1439_1 = $162 + ($add1437 << 2) + 1 | 0;
 
3011
                var $tmp13 = HEAPU8[$arrayidx1439_1];
 
3012
                var $conv1443 = $tmp13 & 255;
 
3013
                var $add1444 = $conv1443 + $conv1398 | 0;
 
3014
                var $cmp1445 = $add1444 >>> 0 > $bits_42 >>> 0;
 
3015
                if (!$cmp1445) {
 
3016
                  break;
 
3017
                }
 
3018
                var $cmp1450 = ($have_46 | 0) == 0;
 
3019
                if ($cmp1450) {
 
3020
                  var $ret_8 = $ret_5_ph;
 
3021
                  var $next_58 = $next_46;
 
3022
                  var $have_58 = 0;
 
3023
                  var $hold_54 = $hold_42;
 
3024
                  var $bits_54 = $bits_42;
 
3025
                  var $out_4 = $out_0;
 
3026
                  break $_$12;
 
3027
                }
 
3028
                var $dec1454 = $have_46 - 1 | 0;
 
3029
                var $incdec_ptr1455 = $next_46 + 1 | 0;
 
3030
                var $164 = HEAPU8[$next_46];
 
3031
                var $conv1456 = $164 & 255;
 
3032
                var $shl1457 = $conv1456 << $bits_42;
 
3033
                var $add1458 = $shl1457 + $hold_42 | 0;
 
3034
                var $add1459 = $bits_42 + 8 | 0;
 
3035
                var $next_46 = $incdec_ptr1455;
 
3036
                var $have_46 = $dec1454;
 
3037
                var $hold_42 = $add1458;
 
3038
                var $bits_42 = $add1459;
 
3039
              }
 
3040
              var $arrayidx1439_2 = $162 + ($add1437 << 2) + 2 | 0;
 
3041
              var $arrayidx1439_0 = $162 + ($add1437 << 2) | 0;
 
3042
              var $tmp14 = HEAP16[$arrayidx1439_2 >> 1];
 
3043
              var $tmp12 = HEAP8[$arrayidx1439_0];
 
3044
              var $shr1466 = $hold_42 >>> ($conv1398 >>> 0);
 
3045
              var $sub1469 = $bits_42 - $conv1398 | 0;
 
3046
              var $165 = HEAP32[$25 >> 2];
 
3047
              var $add1475 = $165 + $conv1398 | 0;
 
3048
              HEAP32[$25 >> 2] = $add1475;
 
3049
              var $next_47 = $next_46;
 
3050
              var $have_47 = $have_46;
 
3051
              var $hold_43 = $shr1466;
 
3052
              var $bits_43 = $sub1469;
 
3053
              var $here_09_1 = $tmp12;
 
3054
              var $here_110_1 = $tmp13;
 
3055
              var $here_211_1 = $tmp14;
 
3056
              var $166 = $add1475;
 
3057
            } else {
 
3058
              var $_pre893 = HEAP32[$25 >> 2];
 
3059
              var $next_47 = $next_45;
 
3060
              var $have_47 = $have_45;
 
3061
              var $hold_43 = $hold_41;
 
3062
              var $bits_43 = $bits_41;
 
3063
              var $here_09_1 = $tmp15;
 
3064
              var $here_110_1 = $tmp16;
 
3065
              var $here_211_1 = $tmp17;
 
3066
              var $166 = $_pre893;
 
3067
            }
 
3068
            var $166;
 
3069
            var $here_211_1;
 
3070
            var $here_110_1;
 
3071
            var $here_09_1;
 
3072
            var $bits_43;
 
3073
            var $hold_43;
 
3074
            var $have_47;
 
3075
            var $next_47;
 
3076
            var $conv1479 = $here_110_1 & 255;
 
3077
            var $shr1480 = $hold_43 >>> ($conv1479 >>> 0);
 
3078
            var $sub1483 = $bits_43 - $conv1479 | 0;
 
3079
            var $add1489 = $166 + $conv1479 | 0;
 
3080
            HEAP32[$25 >> 2] = $add1489;
 
3081
            var $conv1491 = $here_09_1 & 255;
 
3082
            var $and1492 = $conv1491 & 64;
 
3083
            var $tobool1493 = ($and1492 | 0) == 0;
 
3084
            if ($tobool1493) {
 
3085
              var $conv1499 = $here_211_1 & 65535;
 
3086
              HEAP32[$30 >> 2] = $conv1499;
 
3087
              var $and1502 = $conv1491 & 15;
 
3088
              HEAP32[$28 >> 2] = $and1502;
 
3089
              HEAP32[$mode >> 2] = 23;
 
3090
              var $ret_6 = $ret_5_ph;
 
3091
              var $next_48 = $next_47;
 
3092
              var $have_48 = $have_47;
 
3093
              var $hold_44 = $shr1480;
 
3094
              var $bits_44 = $sub1483;
 
3095
              var $167 = $and1502;
 
3096
              __label__ = 248;
 
3097
              break;
 
3098
            }
 
3099
            HEAP32[$msg >> 2] = STRING_TABLE.__str1170 | 0;
 
3100
            HEAP32[$mode >> 2] = 29;
 
3101
            var $ret_0_be = $ret_5_ph;
 
3102
            var $next_0_be = $next_47;
 
3103
            var $put_0_be = $put_0;
 
3104
            var $have_0_be = $have_47;
 
3105
            var $left_0_be = $left_0;
 
3106
            var $hold_0_be = $shr1480;
 
3107
            var $bits_0_be = $sub1483;
 
3108
            var $out_0_be = $out_0;
 
3109
            __label__ = 268;
 
3110
            break;
 
3111
          }
 
3112
        } while (0);
 
3113
        $_$359 : do {
 
3114
          if (__label__ == 107) {
 
3115
            var $bits_11;
 
3116
            var $hold_11;
 
3117
            var $have_15;
 
3118
            var $next_15;
 
3119
            var $109 = HEAPU32[$17 >> 2];
 
3120
            var $and498 = $109 & 512;
 
3121
            var $tobool499 = ($and498 | 0) == 0;
 
3122
            do {
 
3123
              if (!$tobool499) {
 
3124
                var $next_16 = $next_15;
 
3125
                var $have_16 = $have_15;
 
3126
                var $hold_12 = $hold_11;
 
3127
                var $bits_12 = $bits_11;
 
3128
                while (1) {
 
3129
                  var $bits_12;
 
3130
                  var $hold_12;
 
3131
                  var $have_16;
 
3132
                  var $next_16;
 
3133
                  var $cmp503 = $bits_12 >>> 0 < 16;
 
3134
                  if (!$cmp503) {
 
3135
                    break;
 
3136
                  }
 
3137
                  var $cmp507 = ($have_16 | 0) == 0;
 
3138
                  if ($cmp507) {
 
3139
                    var $ret_8 = $ret_0;
 
3140
                    var $next_58 = $next_16;
 
3141
                    var $have_58 = 0;
 
3142
                    var $hold_54 = $hold_12;
 
3143
                    var $bits_54 = $bits_12;
 
3144
                    var $out_4 = $out_0;
 
3145
                    break $_$12;
 
3146
                  }
 
3147
                  var $dec511 = $have_16 - 1 | 0;
 
3148
                  var $incdec_ptr512 = $next_16 + 1 | 0;
 
3149
                  var $110 = HEAPU8[$next_16];
 
3150
                  var $conv513 = $110 & 255;
 
3151
                  var $shl514 = $conv513 << $bits_12;
 
3152
                  var $add515 = $shl514 + $hold_12 | 0;
 
3153
                  var $add516 = $bits_12 + 8 | 0;
 
3154
                  var $next_16 = $incdec_ptr512;
 
3155
                  var $have_16 = $dec511;
 
3156
                  var $hold_12 = $add515;
 
3157
                  var $bits_12 = $add516;
 
3158
                }
 
3159
                var $111 = HEAP32[$16 >> 2];
 
3160
                var $and523 = $111 & 65535;
 
3161
                var $cmp524 = ($hold_12 | 0) == ($and523 | 0);
 
3162
                if ($cmp524) {
 
3163
                  var $next_17 = $next_16;
 
3164
                  var $have_17 = $have_16;
 
3165
                  var $hold_13 = 0;
 
3166
                  var $bits_13 = 0;
 
3167
                  break;
 
3168
                }
 
3169
                HEAP32[$msg >> 2] = STRING_TABLE.__str5102 | 0;
 
3170
                HEAP32[$mode >> 2] = 29;
 
3171
                var $ret_0_be = $ret_0;
 
3172
                var $next_0_be = $next_16;
 
3173
                var $put_0_be = $put_0;
 
3174
                var $have_0_be = $have_16;
 
3175
                var $left_0_be = $left_0;
 
3176
                var $hold_0_be = $hold_12;
 
3177
                var $bits_0_be = $bits_12;
 
3178
                var $out_0_be = $out_0;
 
3179
                __label__ = 268;
 
3180
                break $_$359;
 
3181
              }
 
3182
              var $next_17 = $next_15;
 
3183
              var $have_17 = $have_15;
 
3184
              var $hold_13 = $hold_11;
 
3185
              var $bits_13 = $bits_11;
 
3186
            } while (0);
 
3187
            var $bits_13;
 
3188
            var $hold_13;
 
3189
            var $have_17;
 
3190
            var $next_17;
 
3191
            var $112 = HEAPU32[$18 >> 2];
 
3192
            var $cmp535 = ($112 | 0) == 0;
 
3193
            if (!$cmp535) {
 
3194
              var $shr53930 = $109 >>> 9;
 
3195
              var $and540 = $shr53930 & 1;
 
3196
              var $hcrc = $112 + 44 | 0;
 
3197
              HEAP32[$hcrc >> 2] = $and540;
 
3198
              var $113 = HEAP32[$18 >> 2];
 
3199
              var $done543 = $113 + 48 | 0;
 
3200
              HEAP32[$done543 >> 2] = 1;
 
3201
            }
 
3202
            var $call545 = _crc32(0, 0, 0);
 
3203
            HEAP32[$16 >> 2] = $call545;
 
3204
            HEAP32[$adler >> 2] = $call545;
 
3205
            HEAP32[$mode >> 2] = 11;
 
3206
            var $ret_0_be = $ret_0;
 
3207
            var $next_0_be = $next_17;
 
3208
            var $put_0_be = $put_0;
 
3209
            var $have_0_be = $have_17;
 
3210
            var $left_0_be = $left_0;
 
3211
            var $hold_0_be = $hold_13;
 
3212
            var $bits_0_be = $bits_13;
 
3213
            var $out_0_be = $out_0;
 
3214
            __label__ = 268;
 
3215
            break;
 
3216
          } else if (__label__ == 248) {
 
3217
            var $167;
 
3218
            var $bits_44;
 
3219
            var $hold_44;
 
3220
            var $have_48;
 
3221
            var $next_48;
 
3222
            var $ret_6;
 
3223
            var $tobool1507 = ($167 | 0) == 0;
 
3224
            if ($tobool1507) {
 
3225
              var $next_50 = $next_48;
 
3226
              var $have_50 = $have_48;
 
3227
              var $hold_46 = $hold_44;
 
3228
              var $bits_46 = $bits_44;
 
3229
            } else {
 
3230
              var $next_49 = $next_48;
 
3231
              var $have_49 = $have_48;
 
3232
              var $hold_45 = $hold_44;
 
3233
              var $bits_45 = $bits_44;
 
3234
              while (1) {
 
3235
                var $bits_45;
 
3236
                var $hold_45;
 
3237
                var $have_49;
 
3238
                var $next_49;
 
3239
                var $cmp1512 = $bits_45 >>> 0 < $167 >>> 0;
 
3240
                if (!$cmp1512) {
 
3241
                  break;
 
3242
                }
 
3243
                var $cmp1516 = ($have_49 | 0) == 0;
 
3244
                if ($cmp1516) {
 
3245
                  var $ret_8 = $ret_6;
 
3246
                  var $next_58 = $next_49;
 
3247
                  var $have_58 = 0;
 
3248
                  var $hold_54 = $hold_45;
 
3249
                  var $bits_54 = $bits_45;
 
3250
                  var $out_4 = $out_0;
 
3251
                  break $_$12;
 
3252
                }
 
3253
                // XXX first chunk with a bug-causing difference
 
3254
                var $dec1520 = $have_49 - 1 | 0;
 
3255
                var $incdec_ptr1521 = $next_49 + 1 | 0;
 
3256
                var $168 = HEAPU8[$next_49];
 
3257
                var $conv1522 = $168 & 255;
 
3258
                var $shl1523 = $conv1522 << $bits_45;
 
3259
                var $add1524 = $shl1523 + $hold_45 | 0;
 
3260
                var $add1525 = $bits_45 + 8 | 0;
 
3261
                var $next_49 = $incdec_ptr1521;
 
3262
                var $have_49 = $dec1520;
 
3263
                var $hold_45 = $add1524;
 
3264
                var $bits_45 = $add1525;
 
3265
              }
 
3266
              var $shl1532 = 1 << $167;
 
3267
              var $sub1533 = $shl1532 - 1 | 0;
 
3268
              var $and1534 = $sub1533 & $hold_45;
 
3269
              var $169 = HEAP32[$30 >> 2];
 
3270
              var $add1536 = $169 + $and1534 | 0;
 
3271
              HEAP32[$30 >> 2] = $add1536;
 
3272
              var $shr1539 = $hold_45 >>> ($167 >>> 0);
 
3273
              var $sub1541 = $bits_45 - $167 | 0;
 
3274
              var $170 = HEAP32[$25 >> 2];
 
3275
              var $add1546 = $170 + $167 | 0;
 
3276
              HEAP32[$25 >> 2] = $add1546;
 
3277
              var $next_50 = $next_49;
 
3278
              var $have_50 = $have_49;
 
3279
              var $hold_46 = $shr1539;
 
3280
              var $bits_46 = $sub1541;
 
3281
            }
 
3282
            var $bits_46;
 
3283
            var $hold_46;
 
3284
            var $have_50;
 
3285
            var $next_50;
 
3286
            HEAP32[$mode >> 2] = 24;
 
3287
            var $ret_7 = $ret_6;
 
3288
            var $next_51 = $next_50;
 
3289
            var $have_51 = $have_50;
 
3290
            var $hold_47 = $hold_46;
 
3291
            var $bits_47 = $bits_46;
 
3292
            __label__ = 254;
 
3293
            break;
 
3294
          }
 
3295
        } while (0);
 
3296
        $_$380 : do {
 
3297
          if (__label__ == 254) {
 
3298
            var $bits_47;
 
3299
            var $hold_47;
 
3300
            var $have_51;
 
3301
            var $next_51;
 
3302
            var $ret_7;
 
3303
            var $cmp1550 = ($left_0 | 0) == 0;
 
3304
            if ($cmp1550) {
 
3305
              var $ret_8 = $ret_7;
 
3306
              var $next_58 = $next_51;
 
3307
              var $have_58 = $have_51;
 
3308
              var $hold_54 = $hold_47;
 
3309
              var $bits_54 = $bits_47;
 
3310
              var $out_4 = $out_0;
 
3311
              break $_$12;
 
3312
            }
 
3313
            var $sub1554 = $out_0 - $left_0 | 0;
 
3314
            var $171 = HEAPU32[$30 >> 2];
 
3315
            var $cmp1556 = $171 >>> 0 > $sub1554 >>> 0;
 
3316
            do {
 
3317
              if ($cmp1556) {
 
3318
                var $sub1560 = $171 - $sub1554 | 0;
 
3319
                var $172 = HEAPU32[$31 >> 2];
 
3320
                var $cmp1561 = $sub1560 >>> 0 > $172 >>> 0;
 
3321
                do {
 
3322
                  if ($cmp1561) {
 
3323
                    var $173 = HEAP32[$32 >> 2];
 
3324
                    var $tobool1564 = ($173 | 0) == 0;
 
3325
                    if ($tobool1564) {
 
3326
                      break;
 
3327
                    }
 
3328
                    HEAP32[$msg >> 2] = STRING_TABLE.__str169 | 0;
 
3329
                    HEAP32[$mode >> 2] = 29;
 
3330
                    var $ret_0_be = $ret_7;
 
3331
                    var $next_0_be = $next_51;
 
3332
                    var $put_0_be = $put_0;
 
3333
                    var $have_0_be = $have_51;
 
3334
                    var $left_0_be = $left_0;
 
3335
                    var $hold_0_be = $hold_47;
 
3336
                    var $bits_0_be = $bits_47;
 
3337
                    var $out_0_be = $out_0;
 
3338
                    break $_$380;
 
3339
                  }
 
3340
                } while (0);
 
3341
                var $174 = HEAPU32[$33 >> 2];
 
3342
                var $cmp1570 = $sub1560 >>> 0 > $174 >>> 0;
 
3343
                if ($cmp1570) {
 
3344
                  var $sub1574 = $sub1560 - $174 | 0;
 
3345
                  var $175 = HEAP32[$34 >> 2];
 
3346
                  var $176 = HEAP32[$35 >> 2];
 
3347
                  var $sub1575 = $176 - $sub1574 | 0;
 
3348
                  var $add_ptr1576 = $175 + $sub1575 | 0;
 
3349
                  var $from_0 = $add_ptr1576;
 
3350
                  var $copy_7 = $sub1574;
 
3351
                } else {
 
3352
                  var $177 = HEAP32[$34 >> 2];
 
3353
                  var $sub1580 = $174 - $sub1560 | 0;
 
3354
                  var $add_ptr1581 = $177 + $sub1580 | 0;
 
3355
                  var $from_0 = $add_ptr1581;
 
3356
                  var $copy_7 = $sub1560;
 
3357
                }
 
3358
                var $copy_7;
 
3359
                var $from_0;
 
3360
                var $178 = HEAPU32[$21 >> 2];
 
3361
                var $cmp1584 = $copy_7 >>> 0 > $178 >>> 0;
 
3362
                if (!$cmp1584) {
 
3363
                  var $from_1 = $from_0;
 
3364
                  var $copy_8 = $copy_7;
 
3365
                  var $180 = $178;
 
3366
                  break;
 
3367
                }
 
3368
                var $from_1 = $from_0;
 
3369
                var $copy_8 = $178;
 
3370
                var $180 = $178;
 
3371
              } else {
 
3372
                var $idx_neg = -$171 | 0;
 
3373
                var $add_ptr1591 = $put_0 + $idx_neg | 0;
 
3374
                var $179 = HEAP32[$21 >> 2];
 
3375
                var $from_1 = $add_ptr1591;
 
3376
                var $copy_8 = $179;
 
3377
                var $180 = $179;
 
3378
              }
 
3379
            } while (0);
 
3380
            var $180;
 
3381
            var $copy_8;
 
3382
            var $from_1;
 
3383
            var $cmp1594 = $copy_8 >>> 0 > $left_0 >>> 0;
 
3384
            var $copy_9 = $cmp1594 ? $left_0 : $copy_8;
 
3385
            var $sub1600 = $180 - $copy_9 | 0;
 
3386
            HEAP32[$21 >> 2] = $sub1600;
 
3387
            var $181 = $copy_8 ^ -1;
 
3388
            var $182 = $left_0 ^ -1;
 
3389
            var $183 = $181 >>> 0 > $182 >>> 0;
 
3390
            var $umax = $183 ? $181 : $182;
 
3391
            var $from_2 = $from_1;
 
3392
            var $put_1 = $put_0;
 
3393
            var $copy_10 = $copy_9;
 
3394
            while (1) {
 
3395
              var $copy_10;
 
3396
              var $put_1;
 
3397
              var $from_2;
 
3398
              var $incdec_ptr1602 = $from_2 + 1 | 0;
 
3399
              var $184 = HEAP8[$from_2];
 
3400
              var $incdec_ptr1603 = $put_1 + 1 | 0;
 
3401
              HEAP8[$put_1] = $184;
 
3402
              var $dec1605 = $copy_10 - 1 | 0;
 
3403
              var $tobool1606 = ($dec1605 | 0) == 0;
 
3404
              if ($tobool1606) {
 
3405
                break;
 
3406
              }
 
3407
              var $from_2 = $incdec_ptr1602;
 
3408
              var $put_1 = $incdec_ptr1603;
 
3409
              var $copy_10 = $dec1605;
 
3410
            }
 
3411
            var $sub1598 = $left_0 - $copy_9 | 0;
 
3412
            var $scevgep_sum = $umax ^ -1;
 
3413
            var $scevgep632 = $put_0 + $scevgep_sum | 0;
 
3414
            var $185 = HEAP32[$21 >> 2];
 
3415
            var $cmp1609 = ($185 | 0) == 0;
 
3416
            if (!$cmp1609) {
 
3417
              var $ret_0_be = $ret_7;
 
3418
              var $next_0_be = $next_51;
 
3419
              var $put_0_be = $scevgep632;
 
3420
              var $have_0_be = $have_51;
 
3421
              var $left_0_be = $sub1598;
 
3422
              var $hold_0_be = $hold_47;
 
3423
              var $bits_0_be = $bits_47;
 
3424
              var $out_0_be = $out_0;
 
3425
              break;
 
3426
            }
 
3427
            HEAP32[$mode >> 2] = 20;
 
3428
            var $ret_0_be = $ret_7;
 
3429
            var $next_0_be = $next_51;
 
3430
            var $put_0_be = $scevgep632;
 
3431
            var $have_0_be = $have_51;
 
3432
            var $left_0_be = $sub1598;
 
3433
            var $hold_0_be = $hold_47;
 
3434
            var $bits_0_be = $bits_47;
 
3435
            var $out_0_be = $out_0;
 
3436
          }
 
3437
        } while (0);
 
3438
        var $out_0_be;
 
3439
        var $bits_0_be;
 
3440
        var $hold_0_be;
 
3441
        var $left_0_be;
 
3442
        var $have_0_be;
 
3443
        var $put_0_be;
 
3444
        var $next_0_be;
 
3445
        var $ret_0_be;
 
3446
        var $_pre883 = HEAP32[$mode >> 2];
 
3447
        var $ret_0 = $ret_0_be;
 
3448
        var $next_0 = $next_0_be;
 
3449
        var $put_0 = $put_0_be;
 
3450
        var $have_0 = $have_0_be;
 
3451
        var $left_0 = $left_0_be;
 
3452
        var $hold_0 = $hold_0_be;
 
3453
        var $bits_0 = $bits_0_be;
 
3454
        var $out_0 = $out_0_be;
 
3455
        var $49 = $_pre883;
 
3456
      }
 
3457
      var $out_4;
 
3458
      var $bits_54;
 
3459
      var $hold_54;
 
3460
      var $have_58;
 
3461
      var $next_58;
 
3462
      var $ret_8;
 
3463
      HEAP32[$next_out >> 2] = $put_0;
 
3464
      HEAP32[$avail_out >> 2] = $left_0;
 
3465
      HEAP32[$next_in >> 2] = $next_58;
 
3466
      HEAP32[$avail_in15 >> 2] = $have_58;
 
3467
      HEAP32[$11 >> 2] = $hold_54;
 
3468
      HEAP32[$13 >> 2] = $bits_54;
 
3469
      var $199 = HEAP32[$35 >> 2];
 
3470
      var $tobool1755 = ($199 | 0) == 0;
 
3471
      do {
 
3472
        if ($tobool1755) {
 
3473
          var $200 = HEAPU32[$mode >> 2];
 
3474
          var $cmp1758 = $200 >>> 0 < 26;
 
3475
          if (!$cmp1758) {
 
3476
            __label__ = 300;
 
3477
            break;
 
3478
          }
 
3479
          var $201 = HEAP32[$avail_out >> 2];
 
3480
          var $cmp1762 = ($out_4 | 0) == ($201 | 0);
 
3481
          if ($cmp1762) {
 
3482
            __label__ = 300;
 
3483
            break;
 
3484
          }
 
3485
          __label__ = 298;
 
3486
          break;
 
3487
        } else {
 
3488
          __label__ = 298;
 
3489
        }
 
3490
      } while (0);
 
3491
      do {
 
3492
        if (__label__ == 298) {
 
3493
          var $call1765 = _updatewindow($strm, $out_4);
 
3494
          var $tobool1766 = ($call1765 | 0) == 0;
 
3495
          if ($tobool1766) {
 
3496
            break;
 
3497
          }
 
3498
          HEAP32[$mode >> 2] = 30;
 
3499
          var $retval_0 = -4;
 
3500
          break $_$2;
 
3501
        }
 
3502
      } while (0);
 
3503
      var $202 = HEAPU32[$avail_in15 >> 2];
 
3504
      var $203 = HEAPU32[$avail_out >> 2];
 
3505
      var $sub1774 = $out_4 - $203 | 0;
 
3506
      var $total_in = $strm + 8 | 0;
 
3507
      var $204 = HEAP32[$total_in >> 2];
 
3508
      var $sub1772 = $10 - $202 | 0;
 
3509
      var $add1775 = $sub1772 + $204 | 0;
 
3510
      HEAP32[$total_in >> 2] = $add1775;
 
3511
      var $205 = HEAP32[$total_out >> 2];
 
3512
      var $add1777 = $205 + $sub1774 | 0;
 
3513
      HEAP32[$total_out >> 2] = $add1777;
 
3514
      var $206 = HEAP32[$36 >> 2];
 
3515
      var $add1779 = $206 + $sub1774 | 0;
 
3516
      HEAP32[$36 >> 2] = $add1779;
 
3517
      var $207 = HEAP32[$15 >> 2];
 
3518
      var $tobool1781 = ($207 | 0) == 0;
 
3519
      var $tobool1783 = ($out_4 | 0) == ($203 | 0);
 
3520
      var $or_cond34 = $tobool1781 | $tobool1783;
 
3521
      if (!$or_cond34) {
 
3522
        var $208 = HEAP32[$17 >> 2];
 
3523
        var $tobool1786 = ($208 | 0) == 0;
 
3524
        var $209 = HEAP32[$16 >> 2];
 
3525
        var $210 = HEAP32[$next_out >> 2];
 
3526
        var $idx_neg1790 = -$sub1774 | 0;
 
3527
        var $add_ptr1791 = $210 + $idx_neg1790 | 0;
 
3528
        if ($tobool1786) {
 
3529
          var $call1798 = _adler32($209, $add_ptr1791, $sub1774);
 
3530
          var $cond1800 = $call1798;
 
3531
        } else {
 
3532
          var $call1792 = _crc32($209, $add_ptr1791, $sub1774);
 
3533
          var $cond1800 = $call1792;
 
3534
        }
 
3535
        var $cond1800;
 
3536
        HEAP32[$16 >> 2] = $cond1800;
 
3537
        HEAP32[$adler >> 2] = $cond1800;
 
3538
      }
 
3539
      var $211 = HEAP32[$13 >> 2];
 
3540
      var $212 = HEAP32[$24 >> 2];
 
3541
      var $tobool1806 = ($212 | 0) != 0;
 
3542
      var $cond1807 = $tobool1806 ? 64 : 0;
 
3543
      var $213 = HEAP32[$mode >> 2];
 
3544
      var $cmp1810 = ($213 | 0) == 11;
 
3545
      var $cond1812 = $cmp1810 ? 128 : 0;
 
3546
      var $cmp1815 = ($213 | 0) == 19;
 
3547
      if ($cmp1815) {
 
3548
        var $214 = 256;
 
3549
      } else {
 
3550
        var $cmp1818 = ($213 | 0) == 14;
 
3551
        var $phitmp = $cmp1818 ? 256 : 0;
 
3552
        var $214 = $phitmp;
 
3553
      }
 
3554
      var $214;
 
3555
      var $add1808 = $cond1807 + $211 | 0;
 
3556
      var $add1813 = $add1808 + $cond1812 | 0;
 
3557
      var $add1821 = $add1813 + $214 | 0;
 
3558
      var $data_type = $strm + 44 | 0;
 
3559
      HEAP32[$data_type >> 2] = $add1821;
 
3560
      var $cmp1822 = ($10 | 0) == ($202 | 0);
 
3561
      var $or_cond35 = $cmp1822 & $tobool1783;
 
3562
      var $cmp1828 = ($flush | 0) == 4;
 
3563
      var $or_cond36 = $or_cond35 | $cmp1828;
 
3564
      var $cmp1831 = ($ret_8 | 0) == 0;
 
3565
      var $or_cond37 = $or_cond36 & $cmp1831;
 
3566
      var $ret_9 = $or_cond37 ? -5 : $ret_8;
 
3567
      var $retval_0 = $ret_9;
 
3568
    }
 
3569
  } while (0);
 
3570
  var $retval_0;
 
3571
  STACKTOP = __stackBase__;
 
3572
  return $retval_0;
 
3573
  return null;
 
3574
}
 
3575
 
 
3576
function _malloc($bytes) {
 
3577
  var __label__;
 
3578
  var $1 = $bytes >>> 0 < 245;
 
3579
  $_$2 : do {
 
3580
    if ($1) {
 
3581
      var $3 = $bytes >>> 0 < 11;
 
3582
      if ($3) {
 
3583
        var $8 = 16;
 
3584
      } else {
 
3585
        var $5 = $bytes + 11 | 0;
 
3586
        var $6 = $5 & -8;
 
3587
        var $8 = $6;
 
3588
      }
 
3589
      var $8;
 
3590
      var $9 = $8 >>> 3;
 
3591
      var $10 = HEAPU32[(__gm_ | 0) >> 2];
 
3592
      var $11 = $10 >>> ($9 >>> 0);
 
3593
      var $12 = $11 & 3;
 
3594
      var $13 = ($12 | 0) == 0;
 
3595
      if (!$13) {
 
3596
        var $15 = $11 & 1;
 
3597
        var $16 = $15 ^ 1;
 
3598
        var $17 = $16 + $9 | 0;
 
3599
        var $18 = $17 << 1;
 
3600
        var $19 = __gm_ + 40 + ($18 << 2) | 0;
 
3601
        var $20 = $19;
 
3602
        var $_sum10 = $18 + 2 | 0;
 
3603
        var $21 = __gm_ + 40 + ($_sum10 << 2) | 0;
 
3604
        var $22 = HEAPU32[$21 >> 2];
 
3605
        var $23 = $22 + 8 | 0;
 
3606
        var $24 = HEAPU32[$23 >> 2];
 
3607
        var $25 = ($20 | 0) == ($24 | 0);
 
3608
        if ($25) {
 
3609
          var $27 = 1 << $17;
 
3610
          var $28 = $27 ^ -1;
 
3611
          var $29 = $10 & $28;
 
3612
          HEAP32[(__gm_ | 0) >> 2] = $29;
 
3613
        } else {
 
3614
          var $31 = $24;
 
3615
          var $32 = HEAPU32[(__gm_ + 16 | 0) >> 2];
 
3616
          var $33 = $31 >>> 0 < $32 >>> 0;
 
3617
          if ($33) {
 
3618
            _abort();
 
3619
          } else {
 
3620
            HEAP32[$21 >> 2] = $24;
 
3621
            var $35 = $24 + 12 | 0;
 
3622
            HEAP32[$35 >> 2] = $20;
 
3623
          }
 
3624
        }
 
3625
        var $38 = $17 << 3;
 
3626
        var $39 = $38 | 3;
 
3627
        var $40 = $22 + 4 | 0;
 
3628
        HEAP32[$40 >> 2] = $39;
 
3629
        var $41 = $22;
 
3630
        var $_sum1112 = $38 | 4;
 
3631
        var $42 = $41 + $_sum1112 | 0;
 
3632
        var $43 = $42;
 
3633
        var $44 = HEAP32[$43 >> 2];
 
3634
        var $45 = $44 | 1;
 
3635
        HEAP32[$43 >> 2] = $45;
 
3636
        var $46 = $23;
 
3637
        var $mem_0 = $46;
 
3638
        __label__ = 331;
 
3639
        break;
 
3640
      }
 
3641
      var $48 = HEAPU32[(__gm_ + 8 | 0) >> 2];
 
3642
      var $49 = $8 >>> 0 > $48 >>> 0;
 
3643
      if (!$49) {
 
3644
        var $nb_0 = $8;
 
3645
        __label__ = 155;
 
3646
        break;
 
3647
      }
 
3648
      var $51 = ($11 | 0) == 0;
 
3649
      if (!$51) {
 
3650
        var $53 = $11 << $9;
 
3651
        var $54 = 2 << $9;
 
3652
        var $55 = -$54 | 0;
 
3653
        var $56 = $54 | $55;
 
3654
        var $57 = $53 & $56;
 
3655
        var $58 = -$57 | 0;
 
3656
        var $59 = $57 & $58;
 
3657
        var $60 = $59 - 1 | 0;
 
3658
        var $61 = $60 >>> 12;
 
3659
        var $62 = $61 & 16;
 
3660
        var $63 = $60 >>> ($62 >>> 0);
 
3661
        var $64 = $63 >>> 5;
 
3662
        var $65 = $64 & 8;
 
3663
        var $66 = $63 >>> ($65 >>> 0);
 
3664
        var $67 = $66 >>> 2;
 
3665
        var $68 = $67 & 4;
 
3666
        var $69 = $66 >>> ($68 >>> 0);
 
3667
        var $70 = $69 >>> 1;
 
3668
        var $71 = $70 & 2;
 
3669
        var $72 = $69 >>> ($71 >>> 0);
 
3670
        var $73 = $72 >>> 1;
 
3671
        var $74 = $73 & 1;
 
3672
        var $75 = $65 | $62;
 
3673
        var $76 = $75 | $68;
 
3674
        var $77 = $76 | $71;
 
3675
        var $78 = $77 | $74;
 
3676
        var $79 = $72 >>> ($74 >>> 0);
 
3677
        var $80 = $78 + $79 | 0;
 
3678
        var $81 = $80 << 1;
 
3679
        var $82 = __gm_ + 40 + ($81 << 2) | 0;
 
3680
        var $83 = $82;
 
3681
        var $_sum4 = $81 + 2 | 0;
 
3682
        var $84 = __gm_ + 40 + ($_sum4 << 2) | 0;
 
3683
        var $85 = HEAPU32[$84 >> 2];
 
3684
        var $86 = $85 + 8 | 0;
 
3685
        var $87 = HEAPU32[$86 >> 2];
 
3686
        var $88 = ($83 | 0) == ($87 | 0);
 
3687
        if ($88) {
 
3688
          var $90 = 1 << $80;
 
3689
          var $91 = $90 ^ -1;
 
3690
          var $92 = $10 & $91;
 
3691
          HEAP32[(__gm_ | 0) >> 2] = $92;
 
3692
        } else {
 
3693
          var $94 = $87;
 
3694
          var $95 = HEAPU32[(__gm_ + 16 | 0) >> 2];
 
3695
          var $96 = $94 >>> 0 < $95 >>> 0;
 
3696
          if ($96) {
 
3697
            _abort();
 
3698
          } else {
 
3699
            HEAP32[$84 >> 2] = $87;
 
3700
            var $98 = $87 + 12 | 0;
 
3701
            HEAP32[$98 >> 2] = $83;
 
3702
          }
 
3703
        }
 
3704
        var $101 = $80 << 3;
 
3705
        var $102 = $101 - $8 | 0;
 
3706
        var $103 = $8 | 3;
 
3707
        var $104 = $85 + 4 | 0;
 
3708
        HEAP32[$104 >> 2] = $103;
 
3709
        var $105 = $85;
 
3710
        var $106 = $105 + $8 | 0;
 
3711
        var $107 = $106;
 
3712
        var $108 = $102 | 1;
 
3713
        var $_sum56 = $8 | 4;
 
3714
        var $109 = $105 + $_sum56 | 0;
 
3715
        var $110 = $109;
 
3716
        HEAP32[$110 >> 2] = $108;
 
3717
        var $111 = $105 + $101 | 0;
 
3718
        var $112 = $111;
 
3719
        HEAP32[$112 >> 2] = $102;
 
3720
        var $113 = HEAPU32[(__gm_ + 8 | 0) >> 2];
 
3721
        var $114 = ($113 | 0) == 0;
 
3722
        if (!$114) {
 
3723
          var $116 = HEAP32[(__gm_ + 20 | 0) >> 2];
 
3724
          var $117 = $113 >>> 3;
 
3725
          var $118 = $113 >>> 2;
 
3726
          var $119 = $118 & 1073741822;
 
3727
          var $120 = __gm_ + 40 + ($119 << 2) | 0;
 
3728
          var $121 = $120;
 
3729
          var $122 = HEAPU32[(__gm_ | 0) >> 2];
 
3730
          var $123 = 1 << $117;
 
3731
          var $124 = $122 & $123;
 
3732
          var $125 = ($124 | 0) == 0;
 
3733
          do {
 
3734
            if ($125) {
 
3735
              var $127 = $122 | $123;
 
3736
              HEAP32[(__gm_ | 0) >> 2] = $127;
 
3737
              var $_sum8_pre = $119 + 2 | 0;
 
3738
              var $_pre = __gm_ + 40 + ($_sum8_pre << 2) | 0;
 
3739
              var $F4_0 = $121;
 
3740
              var $_pre_phi = $_pre;
 
3741
            } else {
 
3742
              var $_sum9 = $119 + 2 | 0;
 
3743
              var $129 = __gm_ + 40 + ($_sum9 << 2) | 0;
 
3744
              var $130 = HEAPU32[$129 >> 2];
 
3745
              var $131 = $130;
 
3746
              var $132 = HEAPU32[(__gm_ + 16 | 0) >> 2];
 
3747
              var $133 = $131 >>> 0 < $132 >>> 0;
 
3748
              if (!$133) {
 
3749
                var $F4_0 = $130;
 
3750
                var $_pre_phi = $129;
 
3751
                break;
 
3752
              }
 
3753
              _abort();
 
3754
            }
 
3755
          } while (0);
 
3756
          var $_pre_phi;
 
3757
          var $F4_0;
 
3758
          HEAP32[$_pre_phi >> 2] = $116;
 
3759
          var $136 = $F4_0 + 12 | 0;
 
3760
          HEAP32[$136 >> 2] = $116;
 
3761
          var $137 = $116 + 8 | 0;
 
3762
          HEAP32[$137 >> 2] = $F4_0;
 
3763
          var $138 = $116 + 12 | 0;
 
3764
          HEAP32[$138 >> 2] = $121;
 
3765
        }
 
3766
        HEAP32[(__gm_ + 8 | 0) >> 2] = $102;
 
3767
        HEAP32[(__gm_ + 20 | 0) >> 2] = $107;
 
3768
        var $140 = $86;
 
3769
        var $mem_0 = $140;
 
3770
        __label__ = 331;
 
3771
        break;
 
3772
      }
 
3773
      var $142 = HEAP32[(__gm_ + 4 | 0) >> 2];
 
3774
      var $143 = ($142 | 0) == 0;
 
3775
      if ($143) {
 
3776
        var $nb_0 = $8;
 
3777
        __label__ = 155;
 
3778
        break;
 
3779
      }
 
3780
      var $145 = -$142 | 0;
 
3781
      var $146 = $142 & $145;
 
3782
      var $147 = $146 - 1 | 0;
 
3783
      var $148 = $147 >>> 12;
 
3784
      var $149 = $148 & 16;
 
3785
      var $150 = $147 >>> ($149 >>> 0);
 
3786
      var $151 = $150 >>> 5;
 
3787
      var $152 = $151 & 8;
 
3788
      var $153 = $150 >>> ($152 >>> 0);
 
3789
      var $154 = $153 >>> 2;
 
3790
      var $155 = $154 & 4;
 
3791
      var $156 = $153 >>> ($155 >>> 0);
 
3792
      var $157 = $156 >>> 1;
 
3793
      var $158 = $157 & 2;
 
3794
      var $159 = $156 >>> ($158 >>> 0);
 
3795
      var $160 = $159 >>> 1;
 
3796
      var $161 = $160 & 1;
 
3797
      var $162 = $152 | $149;
 
3798
      var $163 = $162 | $155;
 
3799
      var $164 = $163 | $158;
 
3800
      var $165 = $164 | $161;
 
3801
      var $166 = $159 >>> ($161 >>> 0);
 
3802
      var $167 = $165 + $166 | 0;
 
3803
      var $168 = __gm_ + 304 + ($167 << 2) | 0;
 
3804
      var $169 = HEAPU32[$168 >> 2];
 
3805
      var $170 = $169 + 4 | 0;
 
3806
      var $171 = HEAP32[$170 >> 2];
 
3807
      var $172 = $171 & -8;
 
3808
      var $173 = $172 - $8 | 0;
 
3809
      var $t_0_i = $169;
 
3810
      var $v_0_i = $169;
 
3811
      var $rsize_0_i = $173;
 
3812
      while (1) {
 
3813
        var $rsize_0_i;
 
3814
        var $v_0_i;
 
3815
        var $t_0_i;
 
3816
        var $175 = $t_0_i + 16 | 0;
 
3817
        var $176 = HEAP32[$175 >> 2];
 
3818
        var $177 = ($176 | 0) == 0;
 
3819
        if ($177) {
 
3820
          var $179 = $t_0_i + 20 | 0;
 
3821
          var $180 = HEAP32[$179 >> 2];
 
3822
          var $181 = ($180 | 0) == 0;
 
3823
          if ($181) {
 
3824
            break;
 
3825
          }
 
3826
          var $182 = $180;
 
3827
        } else {
 
3828
          var $182 = $176;
 
3829
        }
 
3830
        var $182;
 
3831
        var $183 = $182 + 4 | 0;
 
3832
        var $184 = HEAP32[$183 >> 2];
 
3833
        var $185 = $184 & -8;
 
3834
        var $186 = $185 - $8 | 0;
 
3835
        var $187 = $186 >>> 0 < $rsize_0_i >>> 0;
 
3836
        var $_rsize_0_i = $187 ? $186 : $rsize_0_i;
 
3837
        var $_v_0_i = $187 ? $182 : $v_0_i;
 
3838
        var $t_0_i = $182;
 
3839
        var $v_0_i = $_v_0_i;
 
3840
        var $rsize_0_i = $_rsize_0_i;
 
3841
      }
 
3842
      var $189 = $v_0_i;
 
3843
      var $190 = HEAPU32[(__gm_ + 16 | 0) >> 2];
 
3844
      var $191 = $189 >>> 0 < $190 >>> 0;
 
3845
      do {
 
3846
        if (!$191) {
 
3847
          var $193 = $189 + $8 | 0;
 
3848
          var $194 = $193;
 
3849
          var $195 = $189 >>> 0 < $193 >>> 0;
 
3850
          if (!$195) {
 
3851
            break;
 
3852
          }
 
3853
          var $197 = $v_0_i + 24 | 0;
 
3854
          var $198 = HEAPU32[$197 >> 2];
 
3855
          var $199 = $v_0_i + 12 | 0;
 
3856
          var $200 = HEAPU32[$199 >> 2];
 
3857
          var $201 = ($200 | 0) == ($v_0_i | 0);
 
3858
          do {
 
3859
            if ($201) {
 
3860
              var $212 = $v_0_i + 20 | 0;
 
3861
              var $213 = HEAP32[$212 >> 2];
 
3862
              var $214 = ($213 | 0) == 0;
 
3863
              if ($214) {
 
3864
                var $216 = $v_0_i + 16 | 0;
 
3865
                var $217 = HEAP32[$216 >> 2];
 
3866
                var $218 = ($217 | 0) == 0;
 
3867
                if ($218) {
 
3868
                  var $R_1_i = 0;
 
3869
                  break;
 
3870
                }
 
3871
                var $RP_0_i = $216;
 
3872
                var $R_0_i = $217;
 
3873
              } else {
 
3874
                var $RP_0_i = $212;
 
3875
                var $R_0_i = $213;
 
3876
                __label__ = 39;
 
3877
              }
 
3878
              while (1) {
 
3879
                var $R_0_i;
 
3880
                var $RP_0_i;
 
3881
                var $219 = $R_0_i + 20 | 0;
 
3882
                var $220 = HEAP32[$219 >> 2];
 
3883
                var $221 = ($220 | 0) == 0;
 
3884
                if (!$221) {
 
3885
                  var $RP_0_i = $219;
 
3886
                  var $R_0_i = $220;
 
3887
                  continue;
 
3888
                }
 
3889
                var $223 = $R_0_i + 16 | 0;
 
3890
                var $224 = HEAPU32[$223 >> 2];
 
3891
                var $225 = ($224 | 0) == 0;
 
3892
                if ($225) {
 
3893
                  break;
 
3894
                }
 
3895
                var $RP_0_i = $223;
 
3896
                var $R_0_i = $224;
 
3897
              }
 
3898
              var $227 = $RP_0_i;
 
3899
              var $228 = $227 >>> 0 < $190 >>> 0;
 
3900
              if ($228) {
 
3901
                _abort();
 
3902
              } else {
 
3903
                HEAP32[$RP_0_i >> 2] = 0;
 
3904
                var $R_1_i = $R_0_i;
 
3905
              }
 
3906
            } else {
 
3907
              var $203 = $v_0_i + 8 | 0;
 
3908
              var $204 = HEAPU32[$203 >> 2];
 
3909
              var $205 = $204;
 
3910
              var $206 = $205 >>> 0 < $190 >>> 0;
 
3911
              if ($206) {
 
3912
                _abort();
 
3913
              } else {
 
3914
                var $208 = $204 + 12 | 0;
 
3915
                HEAP32[$208 >> 2] = $200;
 
3916
                var $209 = $200 + 8 | 0;
 
3917
                HEAP32[$209 >> 2] = $204;
 
3918
                var $R_1_i = $200;
 
3919
              }
 
3920
            }
 
3921
          } while (0);
 
3922
          var $R_1_i;
 
3923
          var $232 = ($198 | 0) == 0;
 
3924
          $_$62 : do {
 
3925
            if (!$232) {
 
3926
              var $234 = $v_0_i + 28 | 0;
 
3927
              var $235 = HEAP32[$234 >> 2];
 
3928
              var $236 = __gm_ + 304 + ($235 << 2) | 0;
 
3929
              var $237 = HEAP32[$236 >> 2];
 
3930
              var $238 = ($v_0_i | 0) == ($237 | 0);
 
3931
              do {
 
3932
                if ($238) {
 
3933
                  HEAP32[$236 >> 2] = $R_1_i;
 
3934
                  var $cond_i = ($R_1_i | 0) == 0;
 
3935
                  if (!$cond_i) {
 
3936
                    break;
 
3937
                  }
 
3938
                  var $240 = HEAP32[$234 >> 2];
 
3939
                  var $241 = 1 << $240;
 
3940
                  var $242 = $241 ^ -1;
 
3941
                  var $243 = HEAP32[(__gm_ + 4 | 0) >> 2];
 
3942
                  var $244 = $243 & $242;
 
3943
                  HEAP32[(__gm_ + 4 | 0) >> 2] = $244;
 
3944
                  break $_$62;
 
3945
                }
 
3946
                var $246 = $198;
 
3947
                var $247 = HEAPU32[(__gm_ + 16 | 0) >> 2];
 
3948
                var $248 = $246 >>> 0 < $247 >>> 0;
 
3949
                if ($248) {
 
3950
                  _abort();
 
3951
                } else {
 
3952
                  var $250 = $198 + 16 | 0;
 
3953
                  var $251 = HEAP32[$250 >> 2];
 
3954
                  var $252 = ($251 | 0) == ($v_0_i | 0);
 
3955
                  if ($252) {
 
3956
                    HEAP32[$250 >> 2] = $R_1_i;
 
3957
                  } else {
 
3958
                    var $255 = $198 + 20 | 0;
 
3959
                    HEAP32[$255 >> 2] = $R_1_i;
 
3960
                  }
 
3961
                  var $258 = ($R_1_i | 0) == 0;
 
3962
                  if ($258) {
 
3963
                    break $_$62;
 
3964
                  }
 
3965
                }
 
3966
              } while (0);
 
3967
              var $260 = $R_1_i;
 
3968
              var $261 = HEAPU32[(__gm_ + 16 | 0) >> 2];
 
3969
              var $262 = $260 >>> 0 < $261 >>> 0;
 
3970
              if ($262) {
 
3971
                _abort();
 
3972
              } else {
 
3973
                var $264 = $R_1_i + 24 | 0;
 
3974
                HEAP32[$264 >> 2] = $198;
 
3975
                var $265 = $v_0_i + 16 | 0;
 
3976
                var $266 = HEAPU32[$265 >> 2];
 
3977
                var $267 = ($266 | 0) == 0;
 
3978
                if (!$267) {
 
3979
                  var $269 = $266;
 
3980
                  var $270 = HEAPU32[(__gm_ + 16 | 0) >> 2];
 
3981
                  var $271 = $269 >>> 0 < $270 >>> 0;
 
3982
                  if ($271) {
 
3983
                    _abort();
 
3984
                  } else {
 
3985
                    var $273 = $R_1_i + 16 | 0;
 
3986
                    HEAP32[$273 >> 2] = $266;
 
3987
                    var $274 = $266 + 24 | 0;
 
3988
                    HEAP32[$274 >> 2] = $R_1_i;
 
3989
                  }
 
3990
                }
 
3991
                var $277 = $v_0_i + 20 | 0;
 
3992
                var $278 = HEAPU32[$277 >> 2];
 
3993
                var $279 = ($278 | 0) == 0;
 
3994
                if ($279) {
 
3995
                  break;
 
3996
                }
 
3997
                var $281 = $278;
 
3998
                var $282 = HEAPU32[(__gm_ + 16 | 0) >> 2];
 
3999
                var $283 = $281 >>> 0 < $282 >>> 0;
 
4000
                if ($283) {
 
4001
                  _abort();
 
4002
                } else {
 
4003
                  var $285 = $R_1_i + 20 | 0;
 
4004
                  HEAP32[$285 >> 2] = $278;
 
4005
                  var $286 = $278 + 24 | 0;
 
4006
                  HEAP32[$286 >> 2] = $R_1_i;
 
4007
                }
 
4008
              }
 
4009
            }
 
4010
          } while (0);
 
4011
          var $290 = $rsize_0_i >>> 0 < 16;
 
4012
          if ($290) {
 
4013
            var $292 = $rsize_0_i + $8 | 0;
 
4014
            var $293 = $292 | 3;
 
4015
            var $294 = $v_0_i + 4 | 0;
 
4016
            HEAP32[$294 >> 2] = $293;
 
4017
            var $_sum4_i = $292 + 4 | 0;
 
4018
            var $295 = $189 + $_sum4_i | 0;
 
4019
            var $296 = $295;
 
4020
            var $297 = HEAP32[$296 >> 2];
 
4021
            var $298 = $297 | 1;
 
4022
            HEAP32[$296 >> 2] = $298;
 
4023
          } else {
 
4024
            var $300 = $8 | 3;
 
4025
            var $301 = $v_0_i + 4 | 0;
 
4026
            HEAP32[$301 >> 2] = $300;
 
4027
            var $302 = $rsize_0_i | 1;
 
4028
            var $_sum_i33 = $8 | 4;
 
4029
            var $303 = $189 + $_sum_i33 | 0;
 
4030
            var $304 = $303;
 
4031
            HEAP32[$304 >> 2] = $302;
 
4032
            var $_sum1_i = $rsize_0_i + $8 | 0;
 
4033
            var $305 = $189 + $_sum1_i | 0;
 
4034
            var $306 = $305;
 
4035
            HEAP32[$306 >> 2] = $rsize_0_i;
 
4036
            var $307 = HEAPU32[(__gm_ + 8 | 0) >> 2];
 
4037
            var $308 = ($307 | 0) == 0;
 
4038
            if (!$308) {
 
4039
              var $310 = HEAPU32[(__gm_ + 20 | 0) >> 2];
 
4040
              var $311 = $307 >>> 3;
 
4041
              var $312 = $307 >>> 2;
 
4042
              var $313 = $312 & 1073741822;
 
4043
              var $314 = __gm_ + 40 + ($313 << 2) | 0;
 
4044
              var $315 = $314;
 
4045
              var $316 = HEAPU32[(__gm_ | 0) >> 2];
 
4046
              var $317 = 1 << $311;
 
4047
              var $318 = $316 & $317;
 
4048
              var $319 = ($318 | 0) == 0;
 
4049
              do {
 
4050
                if ($319) {
 
4051
                  var $321 = $316 | $317;
 
4052
                  HEAP32[(__gm_ | 0) >> 2] = $321;
 
4053
                  var $_sum2_pre_i = $313 + 2 | 0;
 
4054
                  var $_pre_i = __gm_ + 40 + ($_sum2_pre_i << 2) | 0;
 
4055
                  var $F1_0_i = $315;
 
4056
                  var $_pre_phi_i = $_pre_i;
 
4057
                } else {
 
4058
                  var $_sum3_i = $313 + 2 | 0;
 
4059
                  var $323 = __gm_ + 40 + ($_sum3_i << 2) | 0;
 
4060
                  var $324 = HEAPU32[$323 >> 2];
 
4061
                  var $325 = $324;
 
4062
                  var $326 = HEAPU32[(__gm_ + 16 | 0) >> 2];
 
4063
                  var $327 = $325 >>> 0 < $326 >>> 0;
 
4064
                  if (!$327) {
 
4065
                    var $F1_0_i = $324;
 
4066
                    var $_pre_phi_i = $323;
 
4067
                    break;
 
4068
                  }
 
4069
                  _abort();
 
4070
                }
 
4071
              } while (0);
 
4072
              var $_pre_phi_i;
 
4073
              var $F1_0_i;
 
4074
              HEAP32[$_pre_phi_i >> 2] = $310;
 
4075
              var $330 = $F1_0_i + 12 | 0;
 
4076
              HEAP32[$330 >> 2] = $310;
 
4077
              var $331 = $310 + 8 | 0;
 
4078
              HEAP32[$331 >> 2] = $F1_0_i;
 
4079
              var $332 = $310 + 12 | 0;
 
4080
              HEAP32[$332 >> 2] = $315;
 
4081
            }
 
4082
            HEAP32[(__gm_ + 8 | 0) >> 2] = $rsize_0_i;
 
4083
            HEAP32[(__gm_ + 20 | 0) >> 2] = $194;
 
4084
          }
 
4085
          var $335 = $v_0_i + 8 | 0;
 
4086
          var $336 = $335;
 
4087
          var $337 = ($335 | 0) == 0;
 
4088
          if ($337) {
 
4089
            var $nb_0 = $8;
 
4090
            __label__ = 155;
 
4091
            break $_$2;
 
4092
          }
 
4093
          var $mem_0 = $336;
 
4094
          __label__ = 331;
 
4095
          break $_$2;
 
4096
        }
 
4097
      } while (0);
 
4098
      _abort();
 
4099
    } else {
 
4100
      var $339 = $bytes >>> 0 > 4294967231;
 
4101
      if ($339) {
 
4102
        var $nb_0 = -1;
 
4103
        __label__ = 155;
 
4104
        break;
 
4105
      }
 
4106
      var $341 = $bytes + 11 | 0;
 
4107
      var $342 = $341 & -8;
 
4108
      var $343 = HEAPU32[(__gm_ + 4 | 0) >> 2];
 
4109
      var $344 = ($343 | 0) == 0;
 
4110
      if ($344) {
 
4111
        var $nb_0 = $342;
 
4112
        __label__ = 155;
 
4113
        break;
 
4114
      }
 
4115
      var $346 = -$342 | 0;
 
4116
      var $347 = $341 >>> 8;
 
4117
      var $348 = ($347 | 0) == 0;
 
4118
      do {
 
4119
        if ($348) {
 
4120
          var $idx_0_i = 0;
 
4121
        } else {
 
4122
          var $350 = $342 >>> 0 > 16777215;
 
4123
          if ($350) {
 
4124
            var $idx_0_i = 31;
 
4125
            break;
 
4126
          }
 
4127
          var $352 = $347 + 1048320 | 0;
 
4128
          var $353 = $352 >>> 16;
 
4129
          var $354 = $353 & 8;
 
4130
          var $355 = $347 << $354;
 
4131
          var $356 = $355 + 520192 | 0;
 
4132
          var $357 = $356 >>> 16;
 
4133
          var $358 = $357 & 4;
 
4134
          var $359 = $355 << $358;
 
4135
          var $360 = $359 + 245760 | 0;
 
4136
          var $361 = $360 >>> 16;
 
4137
          var $362 = $361 & 2;
 
4138
          var $363 = $358 | $354;
 
4139
          var $364 = $363 | $362;
 
4140
          var $365 = 14 - $364 | 0;
 
4141
          var $366 = $359 << $362;
 
4142
          var $367 = $366 >>> 15;
 
4143
          var $368 = $365 + $367 | 0;
 
4144
          var $369 = $368 << 1;
 
4145
          var $370 = $368 + 7 | 0;
 
4146
          var $371 = $342 >>> ($370 >>> 0);
 
4147
          var $372 = $371 & 1;
 
4148
          var $373 = $372 | $369;
 
4149
          var $idx_0_i = $373;
 
4150
        }
 
4151
      } while (0);
 
4152
      var $idx_0_i;
 
4153
      var $375 = __gm_ + 304 + ($idx_0_i << 2) | 0;
 
4154
      var $376 = HEAPU32[$375 >> 2];
 
4155
      var $377 = ($376 | 0) == 0;
 
4156
      $_$110 : do {
 
4157
        if ($377) {
 
4158
          var $v_2_i = 0;
 
4159
          var $rsize_2_i = $346;
 
4160
          var $t_1_i = 0;
 
4161
        } else {
 
4162
          var $379 = ($idx_0_i | 0) == 31;
 
4163
          if ($379) {
 
4164
            var $384 = 0;
 
4165
          } else {
 
4166
            var $381 = $idx_0_i >>> 1;
 
4167
            var $382 = 25 - $381 | 0;
 
4168
            var $384 = $382;
 
4169
          }
 
4170
          var $384;
 
4171
          var $385 = $342 << $384;
 
4172
          var $v_0_i15 = 0;
 
4173
          var $rsize_0_i14 = $346;
 
4174
          var $t_0_i13 = $376;
 
4175
          var $sizebits_0_i = $385;
 
4176
          var $rst_0_i = 0;
 
4177
          while (1) {
 
4178
            var $rst_0_i;
 
4179
            var $sizebits_0_i;
 
4180
            var $t_0_i13;
 
4181
            var $rsize_0_i14;
 
4182
            var $v_0_i15;
 
4183
            var $387 = $t_0_i13 + 4 | 0;
 
4184
            var $388 = HEAP32[$387 >> 2];
 
4185
            var $389 = $388 & -8;
 
4186
            var $390 = $389 - $342 | 0;
 
4187
            var $391 = $390 >>> 0 < $rsize_0_i14 >>> 0;
 
4188
            if ($391) {
 
4189
              var $393 = ($389 | 0) == ($342 | 0);
 
4190
              if ($393) {
 
4191
                var $v_2_i = $t_0_i13;
 
4192
                var $rsize_2_i = $390;
 
4193
                var $t_1_i = $t_0_i13;
 
4194
                break $_$110;
 
4195
              }
 
4196
              var $v_1_i = $t_0_i13;
 
4197
              var $rsize_1_i = $390;
 
4198
            } else {
 
4199
              var $v_1_i = $v_0_i15;
 
4200
              var $rsize_1_i = $rsize_0_i14;
 
4201
            }
 
4202
            var $rsize_1_i;
 
4203
            var $v_1_i;
 
4204
            var $395 = $t_0_i13 + 20 | 0;
 
4205
            var $396 = HEAPU32[$395 >> 2];
 
4206
            var $397 = $sizebits_0_i >>> 31;
 
4207
            var $398 = $t_0_i13 + 16 + ($397 << 2) | 0;
 
4208
            var $399 = HEAPU32[$398 >> 2];
 
4209
            var $400 = ($396 | 0) == 0;
 
4210
            var $401 = ($396 | 0) == ($399 | 0);
 
4211
            var $or_cond_i = $400 | $401;
 
4212
            var $rst_1_i = $or_cond_i ? $rst_0_i : $396;
 
4213
            var $402 = ($399 | 0) == 0;
 
4214
            var $403 = $sizebits_0_i << 1;
 
4215
            if ($402) {
 
4216
              var $v_2_i = $v_1_i;
 
4217
              var $rsize_2_i = $rsize_1_i;
 
4218
              var $t_1_i = $rst_1_i;
 
4219
              break $_$110;
 
4220
            }
 
4221
            var $v_0_i15 = $v_1_i;
 
4222
            var $rsize_0_i14 = $rsize_1_i;
 
4223
            var $t_0_i13 = $399;
 
4224
            var $sizebits_0_i = $403;
 
4225
            var $rst_0_i = $rst_1_i;
 
4226
          }
 
4227
        }
 
4228
      } while (0);
 
4229
      var $t_1_i;
 
4230
      var $rsize_2_i;
 
4231
      var $v_2_i;
 
4232
      var $404 = ($t_1_i | 0) == 0;
 
4233
      var $405 = ($v_2_i | 0) == 0;
 
4234
      var $or_cond19_i = $404 & $405;
 
4235
      if ($or_cond19_i) {
 
4236
        var $407 = 2 << $idx_0_i;
 
4237
        var $408 = -$407 | 0;
 
4238
        var $409 = $407 | $408;
 
4239
        var $410 = $343 & $409;
 
4240
        var $411 = ($410 | 0) == 0;
 
4241
        if ($411) {
 
4242
          var $nb_0 = $342;
 
4243
          __label__ = 155;
 
4244
          break;
 
4245
        }
 
4246
        var $413 = -$410 | 0;
 
4247
        var $414 = $410 & $413;
 
4248
        var $415 = $414 - 1 | 0;
 
4249
        var $416 = $415 >>> 12;
 
4250
        var $417 = $416 & 16;
 
4251
        var $418 = $415 >>> ($417 >>> 0);
 
4252
        var $419 = $418 >>> 5;
 
4253
        var $420 = $419 & 8;
 
4254
        var $421 = $418 >>> ($420 >>> 0);
 
4255
        var $422 = $421 >>> 2;
 
4256
        var $423 = $422 & 4;
 
4257
        var $424 = $421 >>> ($423 >>> 0);
 
4258
        var $425 = $424 >>> 1;
 
4259
        var $426 = $425 & 2;
 
4260
        var $427 = $424 >>> ($426 >>> 0);
 
4261
        var $428 = $427 >>> 1;
 
4262
        var $429 = $428 & 1;
 
4263
        var $430 = $420 | $417;
 
4264
        var $431 = $430 | $423;
 
4265
        var $432 = $431 | $426;
 
4266
        var $433 = $432 | $429;
 
4267
        var $434 = $427 >>> ($429 >>> 0);
 
4268
        var $435 = $433 + $434 | 0;
 
4269
        var $436 = __gm_ + 304 + ($435 << 2) | 0;
 
4270
        var $437 = HEAP32[$436 >> 2];
 
4271
        var $t_2_ph_i = $437;
 
4272
      } else {
 
4273
        var $t_2_ph_i = $t_1_i;
 
4274
      }
 
4275
      var $t_2_ph_i;
 
4276
      var $438 = ($t_2_ph_i | 0) == 0;
 
4277
      $_$125 : do {
 
4278
        if ($438) {
 
4279
          var $rsize_3_lcssa_i = $rsize_2_i;
 
4280
          var $v_3_lcssa_i = $v_2_i;
 
4281
        } else {
 
4282
          var $t_224_i = $t_2_ph_i;
 
4283
          var $rsize_325_i = $rsize_2_i;
 
4284
          var $v_326_i = $v_2_i;
 
4285
          while (1) {
 
4286
            var $v_326_i;
 
4287
            var $rsize_325_i;
 
4288
            var $t_224_i;
 
4289
            var $439 = $t_224_i + 4 | 0;
 
4290
            var $440 = HEAP32[$439 >> 2];
 
4291
            var $441 = $440 & -8;
 
4292
            var $442 = $441 - $342 | 0;
 
4293
            var $443 = $442 >>> 0 < $rsize_325_i >>> 0;
 
4294
            var $_rsize_3_i = $443 ? $442 : $rsize_325_i;
 
4295
            var $t_2_v_3_i = $443 ? $t_224_i : $v_326_i;
 
4296
            var $444 = $t_224_i + 16 | 0;
 
4297
            var $445 = HEAPU32[$444 >> 2];
 
4298
            var $446 = ($445 | 0) == 0;
 
4299
            if (!$446) {
 
4300
              var $t_224_i = $445;
 
4301
              var $rsize_325_i = $_rsize_3_i;
 
4302
              var $v_326_i = $t_2_v_3_i;
 
4303
              continue;
 
4304
            }
 
4305
            var $447 = $t_224_i + 20 | 0;
 
4306
            var $448 = HEAPU32[$447 >> 2];
 
4307
            var $449 = ($448 | 0) == 0;
 
4308
            if ($449) {
 
4309
              var $rsize_3_lcssa_i = $_rsize_3_i;
 
4310
              var $v_3_lcssa_i = $t_2_v_3_i;
 
4311
              break $_$125;
 
4312
            }
 
4313
            var $t_224_i = $448;
 
4314
            var $rsize_325_i = $_rsize_3_i;
 
4315
            var $v_326_i = $t_2_v_3_i;
 
4316
          }
 
4317
        }
 
4318
      } while (0);
 
4319
      var $v_3_lcssa_i;
 
4320
      var $rsize_3_lcssa_i;
 
4321
      var $450 = ($v_3_lcssa_i | 0) == 0;
 
4322
      if ($450) {
 
4323
        var $nb_0 = $342;
 
4324
        __label__ = 155;
 
4325
        break;
 
4326
      }
 
4327
      var $452 = HEAP32[(__gm_ + 8 | 0) >> 2];
 
4328
      var $453 = $452 - $342 | 0;
 
4329
      var $454 = $rsize_3_lcssa_i >>> 0 < $453 >>> 0;
 
4330
      if (!$454) {
 
4331
        var $nb_0 = $342;
 
4332
        __label__ = 155;
 
4333
        break;
 
4334
      }
 
4335
      var $456 = $v_3_lcssa_i;
 
4336
      var $457 = HEAPU32[(__gm_ + 16 | 0) >> 2];
 
4337
      var $458 = $456 >>> 0 < $457 >>> 0;
 
4338
      do {
 
4339
        if (!$458) {
 
4340
          var $460 = $456 + $342 | 0;
 
4341
          var $461 = $460;
 
4342
          var $462 = $456 >>> 0 < $460 >>> 0;
 
4343
          if (!$462) {
 
4344
            break;
 
4345
          }
 
4346
          var $464 = $v_3_lcssa_i + 24 | 0;
 
4347
          var $465 = HEAPU32[$464 >> 2];
 
4348
          var $466 = $v_3_lcssa_i + 12 | 0;
 
4349
          var $467 = HEAPU32[$466 >> 2];
 
4350
          var $468 = ($467 | 0) == ($v_3_lcssa_i | 0);
 
4351
          do {
 
4352
            if ($468) {
 
4353
              var $479 = $v_3_lcssa_i + 20 | 0;
 
4354
              var $480 = HEAP32[$479 >> 2];
 
4355
              var $481 = ($480 | 0) == 0;
 
4356
              if ($481) {
 
4357
                var $483 = $v_3_lcssa_i + 16 | 0;
 
4358
                var $484 = HEAP32[$483 >> 2];
 
4359
                var $485 = ($484 | 0) == 0;
 
4360
                if ($485) {
 
4361
                  var $R_1_i19 = 0;
 
4362
                  break;
 
4363
                }
 
4364
                var $RP_0_i17 = $483;
 
4365
                var $R_0_i16 = $484;
 
4366
              } else {
 
4367
                var $RP_0_i17 = $479;
 
4368
                var $R_0_i16 = $480;
 
4369
                __label__ = 103;
 
4370
              }
 
4371
              while (1) {
 
4372
                var $R_0_i16;
 
4373
                var $RP_0_i17;
 
4374
                var $486 = $R_0_i16 + 20 | 0;
 
4375
                var $487 = HEAP32[$486 >> 2];
 
4376
                var $488 = ($487 | 0) == 0;
 
4377
                if (!$488) {
 
4378
                  var $RP_0_i17 = $486;
 
4379
                  var $R_0_i16 = $487;
 
4380
                  continue;
 
4381
                }
 
4382
                var $490 = $R_0_i16 + 16 | 0;
 
4383
                var $491 = HEAPU32[$490 >> 2];
 
4384
                var $492 = ($491 | 0) == 0;
 
4385
                if ($492) {
 
4386
                  break;
 
4387
                }
 
4388
                var $RP_0_i17 = $490;
 
4389
                var $R_0_i16 = $491;
 
4390
              }
 
4391
              var $494 = $RP_0_i17;
 
4392
              var $495 = $494 >>> 0 < $457 >>> 0;
 
4393
              if ($495) {
 
4394
                _abort();
 
4395
              } else {
 
4396
                HEAP32[$RP_0_i17 >> 2] = 0;
 
4397
                var $R_1_i19 = $R_0_i16;
 
4398
              }
 
4399
            } else {
 
4400
              var $470 = $v_3_lcssa_i + 8 | 0;
 
4401
              var $471 = HEAPU32[$470 >> 2];
 
4402
              var $472 = $471;
 
4403
              var $473 = $472 >>> 0 < $457 >>> 0;
 
4404
              if ($473) {
 
4405
                _abort();
 
4406
              } else {
 
4407
                var $475 = $471 + 12 | 0;
 
4408
                HEAP32[$475 >> 2] = $467;
 
4409
                var $476 = $467 + 8 | 0;
 
4410
                HEAP32[$476 >> 2] = $471;
 
4411
                var $R_1_i19 = $467;
 
4412
              }
 
4413
            }
 
4414
          } while (0);
 
4415
          var $R_1_i19;
 
4416
          var $499 = ($465 | 0) == 0;
 
4417
          $_$151 : do {
 
4418
            if (!$499) {
 
4419
              var $501 = $v_3_lcssa_i + 28 | 0;
 
4420
              var $502 = HEAP32[$501 >> 2];
 
4421
              var $503 = __gm_ + 304 + ($502 << 2) | 0;
 
4422
              var $504 = HEAP32[$503 >> 2];
 
4423
              var $505 = ($v_3_lcssa_i | 0) == ($504 | 0);
 
4424
              do {
 
4425
                if ($505) {
 
4426
                  HEAP32[$503 >> 2] = $R_1_i19;
 
4427
                  var $cond_i20 = ($R_1_i19 | 0) == 0;
 
4428
                  if (!$cond_i20) {
 
4429
                    break;
 
4430
                  }
 
4431
                  var $507 = HEAP32[$501 >> 2];
 
4432
                  var $508 = 1 << $507;
 
4433
                  var $509 = $508 ^ -1;
 
4434
                  var $510 = HEAP32[(__gm_ + 4 | 0) >> 2];
 
4435
                  var $511 = $510 & $509;
 
4436
                  HEAP32[(__gm_ + 4 | 0) >> 2] = $511;
 
4437
                  break $_$151;
 
4438
                }
 
4439
                var $513 = $465;
 
4440
                var $514 = HEAPU32[(__gm_ + 16 | 0) >> 2];
 
4441
                var $515 = $513 >>> 0 < $514 >>> 0;
 
4442
                if ($515) {
 
4443
                  _abort();
 
4444
                } else {
 
4445
                  var $517 = $465 + 16 | 0;
 
4446
                  var $518 = HEAP32[$517 >> 2];
 
4447
                  var $519 = ($518 | 0) == ($v_3_lcssa_i | 0);
 
4448
                  if ($519) {
 
4449
                    HEAP32[$517 >> 2] = $R_1_i19;
 
4450
                  } else {
 
4451
                    var $522 = $465 + 20 | 0;
 
4452
                    HEAP32[$522 >> 2] = $R_1_i19;
 
4453
                  }
 
4454
                  var $525 = ($R_1_i19 | 0) == 0;
 
4455
                  if ($525) {
 
4456
                    break $_$151;
 
4457
                  }
 
4458
                }
 
4459
              } while (0);
 
4460
              var $527 = $R_1_i19;
 
4461
              var $528 = HEAPU32[(__gm_ + 16 | 0) >> 2];
 
4462
              var $529 = $527 >>> 0 < $528 >>> 0;
 
4463
              if ($529) {
 
4464
                _abort();
 
4465
              } else {
 
4466
                var $531 = $R_1_i19 + 24 | 0;
 
4467
                HEAP32[$531 >> 2] = $465;
 
4468
                var $532 = $v_3_lcssa_i + 16 | 0;
 
4469
                var $533 = HEAPU32[$532 >> 2];
 
4470
                var $534 = ($533 | 0) == 0;
 
4471
                if (!$534) {
 
4472
                  var $536 = $533;
 
4473
                  var $537 = HEAPU32[(__gm_ + 16 | 0) >> 2];
 
4474
                  var $538 = $536 >>> 0 < $537 >>> 0;
 
4475
                  if ($538) {
 
4476
                    _abort();
 
4477
                  } else {
 
4478
                    var $540 = $R_1_i19 + 16 | 0;
 
4479
                    HEAP32[$540 >> 2] = $533;
 
4480
                    var $541 = $533 + 24 | 0;
 
4481
                    HEAP32[$541 >> 2] = $R_1_i19;
 
4482
                  }
 
4483
                }
 
4484
                var $544 = $v_3_lcssa_i + 20 | 0;
 
4485
                var $545 = HEAPU32[$544 >> 2];
 
4486
                var $546 = ($545 | 0) == 0;
 
4487
                if ($546) {
 
4488
                  break;
 
4489
                }
 
4490
                var $548 = $545;
 
4491
                var $549 = HEAPU32[(__gm_ + 16 | 0) >> 2];
 
4492
                var $550 = $548 >>> 0 < $549 >>> 0;
 
4493
                if ($550) {
 
4494
                  _abort();
 
4495
                } else {
 
4496
                  var $552 = $R_1_i19 + 20 | 0;
 
4497
                  HEAP32[$552 >> 2] = $545;
 
4498
                  var $553 = $545 + 24 | 0;
 
4499
                  HEAP32[$553 >> 2] = $R_1_i19;
 
4500
                }
 
4501
              }
 
4502
            }
 
4503
          } while (0);
 
4504
          var $557 = $rsize_3_lcssa_i >>> 0 < 16;
 
4505
          $_$179 : do {
 
4506
            if ($557) {
 
4507
              var $559 = $rsize_3_lcssa_i + $342 | 0;
 
4508
              var $560 = $559 | 3;
 
4509
              var $561 = $v_3_lcssa_i + 4 | 0;
 
4510
              HEAP32[$561 >> 2] = $560;
 
4511
              var $_sum18_i = $559 + 4 | 0;
 
4512
              var $562 = $456 + $_sum18_i | 0;
 
4513
              var $563 = $562;
 
4514
              var $564 = HEAP32[$563 >> 2];
 
4515
              var $565 = $564 | 1;
 
4516
              HEAP32[$563 >> 2] = $565;
 
4517
            } else {
 
4518
              var $567 = $342 | 3;
 
4519
              var $568 = $v_3_lcssa_i + 4 | 0;
 
4520
              HEAP32[$568 >> 2] = $567;
 
4521
              var $569 = $rsize_3_lcssa_i | 1;
 
4522
              var $_sum_i2232 = $342 | 4;
 
4523
              var $570 = $456 + $_sum_i2232 | 0;
 
4524
              var $571 = $570;
 
4525
              HEAP32[$571 >> 2] = $569;
 
4526
              var $_sum1_i23 = $rsize_3_lcssa_i + $342 | 0;
 
4527
              var $572 = $456 + $_sum1_i23 | 0;
 
4528
              var $573 = $572;
 
4529
              HEAP32[$573 >> 2] = $rsize_3_lcssa_i;
 
4530
              var $574 = $rsize_3_lcssa_i >>> 0 < 256;
 
4531
              if ($574) {
 
4532
                var $576 = $rsize_3_lcssa_i >>> 3;
 
4533
                var $577 = $rsize_3_lcssa_i >>> 2;
 
4534
                var $578 = $577 & 1073741822;
 
4535
                var $579 = __gm_ + 40 + ($578 << 2) | 0;
 
4536
                var $580 = $579;
 
4537
                var $581 = HEAPU32[(__gm_ | 0) >> 2];
 
4538
                var $582 = 1 << $576;
 
4539
                var $583 = $581 & $582;
 
4540
                var $584 = ($583 | 0) == 0;
 
4541
                do {
 
4542
                  if ($584) {
 
4543
                    var $586 = $581 | $582;
 
4544
                    HEAP32[(__gm_ | 0) >> 2] = $586;
 
4545
                    var $_sum14_pre_i = $578 + 2 | 0;
 
4546
                    var $_pre_i24 = __gm_ + 40 + ($_sum14_pre_i << 2) | 0;
 
4547
                    var $F5_0_i = $580;
 
4548
                    var $_pre_phi_i25 = $_pre_i24;
 
4549
                  } else {
 
4550
                    var $_sum17_i = $578 + 2 | 0;
 
4551
                    var $588 = __gm_ + 40 + ($_sum17_i << 2) | 0;
 
4552
                    var $589 = HEAPU32[$588 >> 2];
 
4553
                    var $590 = $589;
 
4554
                    var $591 = HEAPU32[(__gm_ + 16 | 0) >> 2];
 
4555
                    var $592 = $590 >>> 0 < $591 >>> 0;
 
4556
                    if (!$592) {
 
4557
                      var $F5_0_i = $589;
 
4558
                      var $_pre_phi_i25 = $588;
 
4559
                      break;
 
4560
                    }
 
4561
                    _abort();
 
4562
                  }
 
4563
                } while (0);
 
4564
                var $_pre_phi_i25;
 
4565
                var $F5_0_i;
 
4566
                HEAP32[$_pre_phi_i25 >> 2] = $461;
 
4567
                var $595 = $F5_0_i + 12 | 0;
 
4568
                HEAP32[$595 >> 2] = $461;
 
4569
                var $_sum15_i = $342 + 8 | 0;
 
4570
                var $596 = $456 + $_sum15_i | 0;
 
4571
                var $597 = $596;
 
4572
                HEAP32[$597 >> 2] = $F5_0_i;
 
4573
                var $_sum16_i = $342 + 12 | 0;
 
4574
                var $598 = $456 + $_sum16_i | 0;
 
4575
                var $599 = $598;
 
4576
                HEAP32[$599 >> 2] = $580;
 
4577
              } else {
 
4578
                var $601 = $460;
 
4579
                var $602 = $rsize_3_lcssa_i >>> 8;
 
4580
                var $603 = ($602 | 0) == 0;
 
4581
                do {
 
4582
                  if ($603) {
 
4583
                    var $I7_0_i = 0;
 
4584
                  } else {
 
4585
                    var $605 = $rsize_3_lcssa_i >>> 0 > 16777215;
 
4586
                    if ($605) {
 
4587
                      var $I7_0_i = 31;
 
4588
                      break;
 
4589
                    }
 
4590
                    var $607 = $602 + 1048320 | 0;
 
4591
                    var $608 = $607 >>> 16;
 
4592
                    var $609 = $608 & 8;
 
4593
                    var $610 = $602 << $609;
 
4594
                    var $611 = $610 + 520192 | 0;
 
4595
                    var $612 = $611 >>> 16;
 
4596
                    var $613 = $612 & 4;
 
4597
                    var $614 = $610 << $613;
 
4598
                    var $615 = $614 + 245760 | 0;
 
4599
                    var $616 = $615 >>> 16;
 
4600
                    var $617 = $616 & 2;
 
4601
                    var $618 = $613 | $609;
 
4602
                    var $619 = $618 | $617;
 
4603
                    var $620 = 14 - $619 | 0;
 
4604
                    var $621 = $614 << $617;
 
4605
                    var $622 = $621 >>> 15;
 
4606
                    var $623 = $620 + $622 | 0;
 
4607
                    var $624 = $623 << 1;
 
4608
                    var $625 = $623 + 7 | 0;
 
4609
                    var $626 = $rsize_3_lcssa_i >>> ($625 >>> 0);
 
4610
                    var $627 = $626 & 1;
 
4611
                    var $628 = $627 | $624;
 
4612
                    var $I7_0_i = $628;
 
4613
                  }
 
4614
                } while (0);
 
4615
                var $I7_0_i;
 
4616
                var $630 = __gm_ + 304 + ($I7_0_i << 2) | 0;
 
4617
                var $_sum2_i = $342 + 28 | 0;
 
4618
                var $631 = $456 + $_sum2_i | 0;
 
4619
                var $632 = $631;
 
4620
                HEAP32[$632 >> 2] = $I7_0_i;
 
4621
                var $_sum3_i26 = $342 + 16 | 0;
 
4622
                var $633 = $456 + $_sum3_i26 | 0;
 
4623
                var $_sum4_i27 = $342 + 20 | 0;
 
4624
                var $634 = $456 + $_sum4_i27 | 0;
 
4625
                var $635 = $634;
 
4626
                HEAP32[$635 >> 2] = 0;
 
4627
                var $636 = $633;
 
4628
                HEAP32[$636 >> 2] = 0;
 
4629
                var $637 = HEAP32[(__gm_ + 4 | 0) >> 2];
 
4630
                var $638 = 1 << $I7_0_i;
 
4631
                var $639 = $637 & $638;
 
4632
                var $640 = ($639 | 0) == 0;
 
4633
                if ($640) {
 
4634
                  var $642 = $637 | $638;
 
4635
                  HEAP32[(__gm_ + 4 | 0) >> 2] = $642;
 
4636
                  HEAP32[$630 >> 2] = $601;
 
4637
                  var $643 = $630;
 
4638
                  var $_sum5_i = $342 + 24 | 0;
 
4639
                  var $644 = $456 + $_sum5_i | 0;
 
4640
                  var $645 = $644;
 
4641
                  HEAP32[$645 >> 2] = $643;
 
4642
                  var $_sum6_i = $342 + 12 | 0;
 
4643
                  var $646 = $456 + $_sum6_i | 0;
 
4644
                  var $647 = $646;
 
4645
                  HEAP32[$647 >> 2] = $601;
 
4646
                  var $_sum7_i = $342 + 8 | 0;
 
4647
                  var $648 = $456 + $_sum7_i | 0;
 
4648
                  var $649 = $648;
 
4649
                  HEAP32[$649 >> 2] = $601;
 
4650
                } else {
 
4651
                  var $651 = HEAP32[$630 >> 2];
 
4652
                  var $652 = ($I7_0_i | 0) == 31;
 
4653
                  if ($652) {
 
4654
                    var $657 = 0;
 
4655
                  } else {
 
4656
                    var $654 = $I7_0_i >>> 1;
 
4657
                    var $655 = 25 - $654 | 0;
 
4658
                    var $657 = $655;
 
4659
                  }
 
4660
                  var $657;
 
4661
                  var $658 = $rsize_3_lcssa_i << $657;
 
4662
                  var $K12_0_i = $658;
 
4663
                  var $T_0_i = $651;
 
4664
                  while (1) {
 
4665
                    var $T_0_i;
 
4666
                    var $K12_0_i;
 
4667
                    var $660 = $T_0_i + 4 | 0;
 
4668
                    var $661 = HEAP32[$660 >> 2];
 
4669
                    var $662 = $661 & -8;
 
4670
                    var $663 = ($662 | 0) == ($rsize_3_lcssa_i | 0);
 
4671
                    if ($663) {
 
4672
                      var $683 = $T_0_i + 8 | 0;
 
4673
                      var $684 = HEAPU32[$683 >> 2];
 
4674
                      var $685 = $T_0_i;
 
4675
                      var $686 = HEAPU32[(__gm_ + 16 | 0) >> 2];
 
4676
                      var $687 = $685 >>> 0 < $686 >>> 0;
 
4677
                      do {
 
4678
                        if (!$687) {
 
4679
                          var $689 = $684;
 
4680
                          var $690 = $689 >>> 0 < $686 >>> 0;
 
4681
                          if ($690) {
 
4682
                            break;
 
4683
                          }
 
4684
                          var $692 = $684 + 12 | 0;
 
4685
                          HEAP32[$692 >> 2] = $601;
 
4686
                          HEAP32[$683 >> 2] = $601;
 
4687
                          var $_sum8_i = $342 + 8 | 0;
 
4688
                          var $693 = $456 + $_sum8_i | 0;
 
4689
                          var $694 = $693;
 
4690
                          HEAP32[$694 >> 2] = $684;
 
4691
                          var $_sum9_i = $342 + 12 | 0;
 
4692
                          var $695 = $456 + $_sum9_i | 0;
 
4693
                          var $696 = $695;
 
4694
                          HEAP32[$696 >> 2] = $T_0_i;
 
4695
                          var $_sum10_i = $342 + 24 | 0;
 
4696
                          var $697 = $456 + $_sum10_i | 0;
 
4697
                          var $698 = $697;
 
4698
                          HEAP32[$698 >> 2] = 0;
 
4699
                          break $_$179;
 
4700
                        }
 
4701
                      } while (0);
 
4702
                      _abort();
 
4703
                    } else {
 
4704
                      var $665 = $K12_0_i >>> 31;
 
4705
                      var $666 = $T_0_i + 16 + ($665 << 2) | 0;
 
4706
                      var $667 = HEAPU32[$666 >> 2];
 
4707
                      var $668 = ($667 | 0) == 0;
 
4708
                      var $669 = $K12_0_i << 1;
 
4709
                      if (!$668) {
 
4710
                        var $K12_0_i = $669;
 
4711
                        var $T_0_i = $667;
 
4712
                        continue;
 
4713
                      }
 
4714
                      var $671 = $666;
 
4715
                      var $672 = HEAPU32[(__gm_ + 16 | 0) >> 2];
 
4716
                      var $673 = $671 >>> 0 < $672 >>> 0;
 
4717
                      if (!$673) {
 
4718
                        HEAP32[$666 >> 2] = $601;
 
4719
                        var $_sum11_i = $342 + 24 | 0;
 
4720
                        var $675 = $456 + $_sum11_i | 0;
 
4721
                        var $676 = $675;
 
4722
                        HEAP32[$676 >> 2] = $T_0_i;
 
4723
                        var $_sum12_i = $342 + 12 | 0;
 
4724
                        var $677 = $456 + $_sum12_i | 0;
 
4725
                        var $678 = $677;
 
4726
                        HEAP32[$678 >> 2] = $601;
 
4727
                        var $_sum13_i = $342 + 8 | 0;
 
4728
                        var $679 = $456 + $_sum13_i | 0;
 
4729
                        var $680 = $679;
 
4730
                        HEAP32[$680 >> 2] = $601;
 
4731
                        break $_$179;
 
4732
                      }
 
4733
                      _abort();
 
4734
                    }
 
4735
                  }
 
4736
                }
 
4737
              }
 
4738
            }
 
4739
          } while (0);
 
4740
          var $700 = $v_3_lcssa_i + 8 | 0;
 
4741
          var $701 = $700;
 
4742
          var $702 = ($700 | 0) == 0;
 
4743
          if ($702) {
 
4744
            var $nb_0 = $342;
 
4745
            __label__ = 155;
 
4746
            break $_$2;
 
4747
          }
 
4748
          var $mem_0 = $701;
 
4749
          __label__ = 331;
 
4750
          break $_$2;
 
4751
        }
 
4752
      } while (0);
 
4753
      _abort();
 
4754
    }
 
4755
  } while (0);
 
4756
  $_$215 : do {
 
4757
    if (__label__ == 155) {
 
4758
      var $nb_0;
 
4759
      var $703 = HEAPU32[(__gm_ + 8 | 0) >> 2];
 
4760
      var $704 = $nb_0 >>> 0 > $703 >>> 0;
 
4761
      if ($704) {
 
4762
        var $732 = HEAPU32[(__gm_ + 12 | 0) >> 2];
 
4763
        var $733 = $nb_0 >>> 0 < $732 >>> 0;
 
4764
        if ($733) {
 
4765
          var $735 = $732 - $nb_0 | 0;
 
4766
          HEAP32[(__gm_ + 12 | 0) >> 2] = $735;
 
4767
          var $736 = HEAPU32[(__gm_ + 24 | 0) >> 2];
 
4768
          var $737 = $736;
 
4769
          var $738 = $737 + $nb_0 | 0;
 
4770
          var $739 = $738;
 
4771
          HEAP32[(__gm_ + 24 | 0) >> 2] = $739;
 
4772
          var $740 = $735 | 1;
 
4773
          var $_sum = $nb_0 + 4 | 0;
 
4774
          var $741 = $737 + $_sum | 0;
 
4775
          var $742 = $741;
 
4776
          HEAP32[$742 >> 2] = $740;
 
4777
          var $743 = $nb_0 | 3;
 
4778
          var $744 = $736 + 4 | 0;
 
4779
          HEAP32[$744 >> 2] = $743;
 
4780
          var $745 = $736 + 8 | 0;
 
4781
          var $746 = $745;
 
4782
          var $mem_0 = $746;
 
4783
        } else {
 
4784
          var $748 = HEAP32[(_mparams | 0) >> 2];
 
4785
          var $749 = ($748 | 0) == 0;
 
4786
          do {
 
4787
            if ($749) {
 
4788
              var $751 = HEAP32[(_mparams | 0) >> 2];
 
4789
              var $752 = ($751 | 0) == 0;
 
4790
              if (!$752) {
 
4791
                break;
 
4792
              }
 
4793
              var $754 = _sysconf(8);
 
4794
              var $755 = $754 - 1 | 0;
 
4795
              var $756 = $755 & $754;
 
4796
              var $757 = ($756 | 0) == 0;
 
4797
              if ($757) {
 
4798
                HEAP32[(_mparams + 8 | 0) >> 2] = $754;
 
4799
                HEAP32[(_mparams + 4 | 0) >> 2] = $754;
 
4800
                HEAP32[(_mparams + 12 | 0) >> 2] = -1;
 
4801
                HEAP32[(_mparams + 16 | 0) >> 2] = 2097152;
 
4802
                HEAP32[(_mparams + 20 | 0) >> 2] = 0;
 
4803
                HEAP32[(__gm_ + 440 | 0) >> 2] = 0;
 
4804
                var $760 = _time(0);
 
4805
                var $761 = $760 & -16;
 
4806
                var $762 = $761 ^ 1431655768;
 
4807
                HEAP32[(_mparams | 0) >> 2] = $762;
 
4808
              } else {
 
4809
                _abort();
 
4810
              }
 
4811
            }
 
4812
          } while (0);
 
4813
          var $763 = HEAP32[(__gm_ + 440 | 0) >> 2];
 
4814
          var $764 = $763 & 4;
 
4815
          var $765 = ($764 | 0) == 0;
 
4816
          $_$234 : do {
 
4817
            if ($765) {
 
4818
              var $767 = HEAP32[(__gm_ + 24 | 0) >> 2];
 
4819
              var $768 = ($767 | 0) == 0;
 
4820
              $_$236 : do {
 
4821
                if (!$768) {
 
4822
                  var $770 = $767;
 
4823
                  var $sp_0_i_i = __gm_ + 444 | 0;
 
4824
                  while (1) {
 
4825
                    var $sp_0_i_i;
 
4826
                    var $772 = $sp_0_i_i | 0;
 
4827
                    var $773 = HEAPU32[$772 >> 2];
 
4828
                    var $774 = $773 >>> 0 > $770 >>> 0;
 
4829
                    if (!$774) {
 
4830
                      var $776 = $sp_0_i_i + 4 | 0;
 
4831
                      var $777 = HEAP32[$776 >> 2];
 
4832
                      var $778 = $773 + $777 | 0;
 
4833
                      var $779 = $778 >>> 0 > $770 >>> 0;
 
4834
                      if ($779) {
 
4835
                        break;
 
4836
                      }
 
4837
                    }
 
4838
                    var $781 = $sp_0_i_i + 8 | 0;
 
4839
                    var $782 = HEAPU32[$781 >> 2];
 
4840
                    var $783 = ($782 | 0) == 0;
 
4841
                    if ($783) {
 
4842
                      __label__ = 174;
 
4843
                      break $_$236;
 
4844
                    }
 
4845
                    var $sp_0_i_i = $782;
 
4846
                  }
 
4847
                  var $784 = ($sp_0_i_i | 0) == 0;
 
4848
                  if ($784) {
 
4849
                    __label__ = 174;
 
4850
                    break;
 
4851
                  }
 
4852
                  var $810 = HEAP32[(__gm_ + 12 | 0) >> 2];
 
4853
                  var $811 = HEAP32[(_mparams + 8 | 0) >> 2];
 
4854
                  var $812 = $nb_0 + 47 | 0;
 
4855
                  var $813 = $812 - $810 | 0;
 
4856
                  var $814 = $813 + $811 | 0;
 
4857
                  var $815 = -$811 | 0;
 
4858
                  var $816 = $814 & $815;
 
4859
                  var $817 = $816 >>> 0 < 2147483647;
 
4860
                  if (!$817) {
 
4861
                    var $tsize_0242932_ph_i = 0;
 
4862
                    __label__ = 189;
 
4863
                    break;
 
4864
                  }
 
4865
                  var $819 = _sbrk($816);
 
4866
                  var $820 = HEAP32[$772 >> 2];
 
4867
                  var $821 = HEAP32[$776 >> 2];
 
4868
                  var $822 = $820 + $821 | 0;
 
4869
                  var $823 = ($819 | 0) == ($822 | 0);
 
4870
                  var $_1_i = $823 ? $816 : 0;
 
4871
                  var $_2_i = $823 ? $819 : -1;
 
4872
                  var $tbase_0_i = $_2_i;
 
4873
                  var $tsize_0_i = $_1_i;
 
4874
                  var $asize_1_i = $816;
 
4875
                  var $br_0_i = $819;
 
4876
                  __label__ = 181;
 
4877
                  break;
 
4878
                }
 
4879
                __label__ = 174;
 
4880
              } while (0);
 
4881
              do {
 
4882
                if (__label__ == 174) {
 
4883
                  var $785 = _sbrk(0);
 
4884
                  var $786 = ($785 | 0) == -1;
 
4885
                  if ($786) {
 
4886
                    var $tsize_0242932_ph_i = 0;
 
4887
                    __label__ = 189;
 
4888
                    break;
 
4889
                  }
 
4890
                  var $788 = HEAP32[(_mparams + 8 | 0) >> 2];
 
4891
                  var $789 = $nb_0 + 47 | 0;
 
4892
                  var $790 = $789 + $788 | 0;
 
4893
                  var $791 = -$788 | 0;
 
4894
                  var $792 = $790 & $791;
 
4895
                  var $793 = $785;
 
4896
                  var $794 = HEAP32[(_mparams + 4 | 0) >> 2];
 
4897
                  var $795 = $794 - 1 | 0;
 
4898
                  var $796 = $795 & $793;
 
4899
                  var $797 = ($796 | 0) == 0;
 
4900
                  if ($797) {
 
4901
                    var $asize_0_i = $792;
 
4902
                  } else {
 
4903
                    var $799 = $795 + $793 | 0;
 
4904
                    var $800 = -$794 | 0;
 
4905
                    var $801 = $799 & $800;
 
4906
                    var $802 = $792 - $793 | 0;
 
4907
                    var $803 = $802 + $801 | 0;
 
4908
                    var $asize_0_i = $803;
 
4909
                  }
 
4910
                  var $asize_0_i;
 
4911
                  var $805 = $asize_0_i >>> 0 < 2147483647;
 
4912
                  if (!$805) {
 
4913
                    var $tsize_0242932_ph_i = 0;
 
4914
                    __label__ = 189;
 
4915
                    break;
 
4916
                  }
 
4917
                  var $807 = _sbrk($asize_0_i);
 
4918
                  var $808 = ($807 | 0) == ($785 | 0);
 
4919
                  var $asize_0__i = $808 ? $asize_0_i : 0;
 
4920
                  var $__i = $808 ? $785 : -1;
 
4921
                  var $tbase_0_i = $__i;
 
4922
                  var $tsize_0_i = $asize_0__i;
 
4923
                  var $asize_1_i = $asize_0_i;
 
4924
                  var $br_0_i = $807;
 
4925
                  __label__ = 181;
 
4926
                  break;
 
4927
                }
 
4928
              } while (0);
 
4929
              $_$253 : do {
 
4930
                if (__label__ == 181) {
 
4931
                  var $br_0_i;
 
4932
                  var $asize_1_i;
 
4933
                  var $tsize_0_i;
 
4934
                  var $tbase_0_i;
 
4935
                  var $825 = -$asize_1_i | 0;
 
4936
                  var $826 = ($tbase_0_i | 0) == -1;
 
4937
                  if (!$826) {
 
4938
                    var $tsize_242_i = $tsize_0_i;
 
4939
                    var $tbase_243_i = $tbase_0_i;
 
4940
                    __label__ = 194;
 
4941
                    break $_$234;
 
4942
                  }
 
4943
                  var $828 = ($br_0_i | 0) != -1;
 
4944
                  var $829 = $asize_1_i >>> 0 < 2147483647;
 
4945
                  var $or_cond_i28 = $828 & $829;
 
4946
                  do {
 
4947
                    if ($or_cond_i28) {
 
4948
                      var $831 = $nb_0 + 48 | 0;
 
4949
                      var $832 = $asize_1_i >>> 0 < $831 >>> 0;
 
4950
                      if (!$832) {
 
4951
                        var $asize_2_i = $asize_1_i;
 
4952
                        break;
 
4953
                      }
 
4954
                      var $834 = HEAP32[(_mparams + 8 | 0) >> 2];
 
4955
                      var $835 = $nb_0 + 47 | 0;
 
4956
                      var $836 = $835 - $asize_1_i | 0;
 
4957
                      var $837 = $836 + $834 | 0;
 
4958
                      var $838 = -$834 | 0;
 
4959
                      var $839 = $837 & $838;
 
4960
                      var $840 = $839 >>> 0 < 2147483647;
 
4961
                      if (!$840) {
 
4962
                        var $asize_2_i = $asize_1_i;
 
4963
                        break;
 
4964
                      }
 
4965
                      var $842 = _sbrk($839);
 
4966
                      var $843 = ($842 | 0) == -1;
 
4967
                      if ($843) {
 
4968
                        var $847 = _sbrk($825);
 
4969
                        var $tsize_0242932_ph_i = $tsize_0_i;
 
4970
                        break $_$253;
 
4971
                      }
 
4972
                      var $845 = $839 + $asize_1_i | 0;
 
4973
                      var $asize_2_i = $845;
 
4974
                    } else {
 
4975
                      var $asize_2_i = $asize_1_i;
 
4976
                    }
 
4977
                  } while (0);
 
4978
                  var $asize_2_i;
 
4979
                  var $849 = ($br_0_i | 0) == -1;
 
4980
                  if (!$849) {
 
4981
                    var $tsize_242_i = $asize_2_i;
 
4982
                    var $tbase_243_i = $br_0_i;
 
4983
                    __label__ = 194;
 
4984
                    break $_$234;
 
4985
                  }
 
4986
                  var $852 = HEAP32[(__gm_ + 440 | 0) >> 2];
 
4987
                  var $853 = $852 | 4;
 
4988
                  HEAP32[(__gm_ + 440 | 0) >> 2] = $853;
 
4989
                  var $tsize_137_i = $tsize_0_i;
 
4990
                  __label__ = 191;
 
4991
                  break $_$234;
 
4992
                }
 
4993
              } while (0);
 
4994
              var $tsize_0242932_ph_i;
 
4995
              var $850 = HEAP32[(__gm_ + 440 | 0) >> 2];
 
4996
              var $851 = $850 | 4;
 
4997
              HEAP32[(__gm_ + 440 | 0) >> 2] = $851;
 
4998
              var $tsize_137_i = $tsize_0242932_ph_i;
 
4999
              __label__ = 191;
 
5000
              break;
 
5001
            }
 
5002
            var $tsize_137_i = 0;
 
5003
            __label__ = 191;
 
5004
          } while (0);
 
5005
          do {
 
5006
            if (__label__ == 191) {
 
5007
              var $tsize_137_i;
 
5008
              var $854 = HEAP32[(_mparams + 8 | 0) >> 2];
 
5009
              var $855 = $nb_0 + 47 | 0;
 
5010
              var $856 = $855 + $854 | 0;
 
5011
              var $857 = -$854 | 0;
 
5012
              var $858 = $856 & $857;
 
5013
              var $859 = $858 >>> 0 < 2147483647;
 
5014
              if (!$859) {
 
5015
                __label__ = 330;
 
5016
                break;
 
5017
              }
 
5018
              var $861 = _sbrk($858);
 
5019
              var $862 = _sbrk(0);
 
5020
              var $notlhs_i = ($861 | 0) != -1;
 
5021
              var $notrhs_i = ($862 | 0) != -1;
 
5022
              var $or_cond3_not_i = $notrhs_i & $notlhs_i;
 
5023
              var $863 = $861 >>> 0 < $862 >>> 0;
 
5024
              var $or_cond4_i = $or_cond3_not_i & $863;
 
5025
              if (!$or_cond4_i) {
 
5026
                __label__ = 330;
 
5027
                break;
 
5028
              }
 
5029
              var $864 = $862;
 
5030
              var $865 = $861;
 
5031
              var $866 = $864 - $865 | 0;
 
5032
              var $867 = $nb_0 + 40 | 0;
 
5033
              var $868 = $866 >>> 0 > $867 >>> 0;
 
5034
              var $_tsize_1_i = $868 ? $866 : $tsize_137_i;
 
5035
              var $_tbase_1_i = $868 ? $861 : -1;
 
5036
              var $869 = ($_tbase_1_i | 0) == -1;
 
5037
              if ($869) {
 
5038
                __label__ = 330;
 
5039
                break;
 
5040
              }
 
5041
              var $tsize_242_i = $_tsize_1_i;
 
5042
              var $tbase_243_i = $_tbase_1_i;
 
5043
              __label__ = 194;
 
5044
              break;
 
5045
            }
 
5046
          } while (0);
 
5047
          do {
 
5048
            if (__label__ == 194) {
 
5049
              var $tbase_243_i;
 
5050
              var $tsize_242_i;
 
5051
              var $870 = HEAP32[(__gm_ + 432 | 0) >> 2];
 
5052
              var $871 = $870 + $tsize_242_i | 0;
 
5053
              HEAP32[(__gm_ + 432 | 0) >> 2] = $871;
 
5054
              var $872 = HEAPU32[(__gm_ + 436 | 0) >> 2];
 
5055
              var $873 = $871 >>> 0 > $872 >>> 0;
 
5056
              if ($873) {
 
5057
                HEAP32[(__gm_ + 436 | 0) >> 2] = $871;
 
5058
              }
 
5059
              var $876 = HEAPU32[(__gm_ + 24 | 0) >> 2];
 
5060
              var $877 = ($876 | 0) == 0;
 
5061
              $_$275 : do {
 
5062
                if ($877) {
 
5063
                  var $879 = HEAPU32[(__gm_ + 16 | 0) >> 2];
 
5064
                  var $880 = ($879 | 0) == 0;
 
5065
                  var $881 = $tbase_243_i >>> 0 < $879 >>> 0;
 
5066
                  var $or_cond5_i = $880 | $881;
 
5067
                  if ($or_cond5_i) {
 
5068
                    HEAP32[(__gm_ + 16 | 0) >> 2] = $tbase_243_i;
 
5069
                  }
 
5070
                  HEAP32[(__gm_ + 444 | 0) >> 2] = $tbase_243_i;
 
5071
                  HEAP32[(__gm_ + 448 | 0) >> 2] = $tsize_242_i;
 
5072
                  HEAP32[(__gm_ + 456 | 0) >> 2] = 0;
 
5073
                  var $884 = HEAP32[(_mparams | 0) >> 2];
 
5074
                  HEAP32[(__gm_ + 36 | 0) >> 2] = $884;
 
5075
                  HEAP32[(__gm_ + 32 | 0) >> 2] = -1;
 
5076
                  var $i_02_i_i = 0;
 
5077
                  while (1) {
 
5078
                    var $i_02_i_i;
 
5079
                    var $886 = $i_02_i_i << 1;
 
5080
                    var $887 = __gm_ + 40 + ($886 << 2) | 0;
 
5081
                    var $888 = $887;
 
5082
                    var $_sum_i_i = $886 + 3 | 0;
 
5083
                    var $889 = __gm_ + 40 + ($_sum_i_i << 2) | 0;
 
5084
                    HEAP32[$889 >> 2] = $888;
 
5085
                    var $_sum1_i_i = $886 + 2 | 0;
 
5086
                    var $890 = __gm_ + 40 + ($_sum1_i_i << 2) | 0;
 
5087
                    HEAP32[$890 >> 2] = $888;
 
5088
                    var $891 = $i_02_i_i + 1 | 0;
 
5089
                    var $exitcond_i_i = ($891 | 0) == 32;
 
5090
                    if ($exitcond_i_i) {
 
5091
                      break;
 
5092
                    }
 
5093
                    var $i_02_i_i = $891;
 
5094
                  }
 
5095
                  var $892 = $tbase_243_i + 8 | 0;
 
5096
                  var $893 = $892;
 
5097
                  var $894 = $893 & 7;
 
5098
                  var $895 = ($894 | 0) == 0;
 
5099
                  if ($895) {
 
5100
                    var $899 = 0;
 
5101
                  } else {
 
5102
                    var $897 = -$893 | 0;
 
5103
                    var $898 = $897 & 7;
 
5104
                    var $899 = $898;
 
5105
                  }
 
5106
                  var $899;
 
5107
                  var $900 = $tbase_243_i + $899 | 0;
 
5108
                  var $901 = $900;
 
5109
                  var $902 = $tsize_242_i - 40 | 0;
 
5110
                  var $903 = $902 - $899 | 0;
 
5111
                  HEAP32[(__gm_ + 24 | 0) >> 2] = $901;
 
5112
                  HEAP32[(__gm_ + 12 | 0) >> 2] = $903;
 
5113
                  var $904 = $903 | 1;
 
5114
                  var $_sum_i9_i = $899 + 4 | 0;
 
5115
                  var $905 = $tbase_243_i + $_sum_i9_i | 0;
 
5116
                  var $906 = $905;
 
5117
                  HEAP32[$906 >> 2] = $904;
 
5118
                  var $_sum2_i_i = $tsize_242_i - 36 | 0;
 
5119
                  var $907 = $tbase_243_i + $_sum2_i_i | 0;
 
5120
                  var $908 = $907;
 
5121
                  HEAP32[$908 >> 2] = 40;
 
5122
                  var $909 = HEAP32[(_mparams + 16 | 0) >> 2];
 
5123
                  HEAP32[(__gm_ + 28 | 0) >> 2] = $909;
 
5124
                } else {
 
5125
                  var $sp_0_i = __gm_ + 444 | 0;
 
5126
                  while (1) {
 
5127
                    var $sp_0_i;
 
5128
                    var $910 = ($sp_0_i | 0) == 0;
 
5129
                    if ($910) {
 
5130
                      break;
 
5131
                    }
 
5132
                    var $912 = $sp_0_i | 0;
 
5133
                    var $913 = HEAPU32[$912 >> 2];
 
5134
                    var $914 = $sp_0_i + 4 | 0;
 
5135
                    var $915 = HEAPU32[$914 >> 2];
 
5136
                    var $916 = $913 + $915 | 0;
 
5137
                    var $917 = ($tbase_243_i | 0) == ($916 | 0);
 
5138
                    if ($917) {
 
5139
                      var $921 = $sp_0_i + 12 | 0;
 
5140
                      var $922 = HEAP32[$921 >> 2];
 
5141
                      var $923 = $922 & 8;
 
5142
                      var $924 = ($923 | 0) == 0;
 
5143
                      if (!$924) {
 
5144
                        break;
 
5145
                      }
 
5146
                      var $926 = $876;
 
5147
                      var $927 = $926 >>> 0 >= $913 >>> 0;
 
5148
                      var $928 = $926 >>> 0 < $tbase_243_i >>> 0;
 
5149
                      var $or_cond44_i = $927 & $928;
 
5150
                      if (!$or_cond44_i) {
 
5151
                        break;
 
5152
                      }
 
5153
                      var $930 = $915 + $tsize_242_i | 0;
 
5154
                      HEAP32[$914 >> 2] = $930;
 
5155
                      var $931 = HEAP32[(__gm_ + 24 | 0) >> 2];
 
5156
                      var $932 = HEAP32[(__gm_ + 12 | 0) >> 2];
 
5157
                      var $933 = $932 + $tsize_242_i | 0;
 
5158
                      var $934 = $931;
 
5159
                      var $935 = $931 + 8 | 0;
 
5160
                      var $936 = $935;
 
5161
                      var $937 = $936 & 7;
 
5162
                      var $938 = ($937 | 0) == 0;
 
5163
                      if ($938) {
 
5164
                        var $942 = 0;
 
5165
                      } else {
 
5166
                        var $940 = -$936 | 0;
 
5167
                        var $941 = $940 & 7;
 
5168
                        var $942 = $941;
 
5169
                      }
 
5170
                      var $942;
 
5171
                      var $943 = $934 + $942 | 0;
 
5172
                      var $944 = $943;
 
5173
                      var $945 = $933 - $942 | 0;
 
5174
                      HEAP32[(__gm_ + 24 | 0) >> 2] = $944;
 
5175
                      HEAP32[(__gm_ + 12 | 0) >> 2] = $945;
 
5176
                      var $946 = $945 | 1;
 
5177
                      var $_sum_i13_i = $942 + 4 | 0;
 
5178
                      var $947 = $934 + $_sum_i13_i | 0;
 
5179
                      var $948 = $947;
 
5180
                      HEAP32[$948 >> 2] = $946;
 
5181
                      var $_sum2_i14_i = $933 + 4 | 0;
 
5182
                      var $949 = $934 + $_sum2_i14_i | 0;
 
5183
                      var $950 = $949;
 
5184
                      HEAP32[$950 >> 2] = 40;
 
5185
                      var $951 = HEAP32[(_mparams + 16 | 0) >> 2];
 
5186
                      HEAP32[(__gm_ + 28 | 0) >> 2] = $951;
 
5187
                      break $_$275;
 
5188
                    }
 
5189
                    var $919 = $sp_0_i + 8 | 0;
 
5190
                    var $920 = HEAP32[$919 >> 2];
 
5191
                    var $sp_0_i = $920;
 
5192
                  }
 
5193
                  var $952 = HEAPU32[(__gm_ + 16 | 0) >> 2];
 
5194
                  var $953 = $tbase_243_i >>> 0 < $952 >>> 0;
 
5195
                  if ($953) {
 
5196
                    HEAP32[(__gm_ + 16 | 0) >> 2] = $tbase_243_i;
 
5197
                  }
 
5198
                  var $955 = $tbase_243_i + $tsize_242_i | 0;
 
5199
                  var $sp_1_i = __gm_ + 444 | 0;
 
5200
                  while (1) {
 
5201
                    var $sp_1_i;
 
5202
                    var $957 = ($sp_1_i | 0) == 0;
 
5203
                    if ($957) {
 
5204
                      __label__ = 293;
 
5205
                      break;
 
5206
                    }
 
5207
                    var $959 = $sp_1_i | 0;
 
5208
                    var $960 = HEAP32[$959 >> 2];
 
5209
                    var $961 = ($960 | 0) == ($955 | 0);
 
5210
                    if ($961) {
 
5211
                      __label__ = 218;
 
5212
                      break;
 
5213
                    }
 
5214
                    var $963 = $sp_1_i + 8 | 0;
 
5215
                    var $964 = HEAP32[$963 >> 2];
 
5216
                    var $sp_1_i = $964;
 
5217
                  }
 
5218
                  do {
 
5219
                    if (__label__ == 218) {
 
5220
                      var $965 = $sp_1_i + 12 | 0;
 
5221
                      var $966 = HEAP32[$965 >> 2];
 
5222
                      var $967 = $966 & 8;
 
5223
                      var $968 = ($967 | 0) == 0;
 
5224
                      if (!$968) {
 
5225
                        break;
 
5226
                      }
 
5227
                      HEAP32[$959 >> 2] = $tbase_243_i;
 
5228
                      var $970 = $sp_1_i + 4 | 0;
 
5229
                      var $971 = HEAP32[$970 >> 2];
 
5230
                      var $972 = $971 + $tsize_242_i | 0;
 
5231
                      HEAP32[$970 >> 2] = $972;
 
5232
                      var $973 = $tbase_243_i + 8 | 0;
 
5233
                      var $974 = $973;
 
5234
                      var $975 = $974 & 7;
 
5235
                      var $976 = ($975 | 0) == 0;
 
5236
                      if ($976) {
 
5237
                        var $981 = 0;
 
5238
                      } else {
 
5239
                        var $978 = -$974 | 0;
 
5240
                        var $979 = $978 & 7;
 
5241
                        var $981 = $979;
 
5242
                      }
 
5243
                      var $981;
 
5244
                      var $982 = $tbase_243_i + $981 | 0;
 
5245
                      var $_sum79_i = $tsize_242_i + 8 | 0;
 
5246
                      var $983 = $tbase_243_i + $_sum79_i | 0;
 
5247
                      var $984 = $983;
 
5248
                      var $985 = $984 & 7;
 
5249
                      var $986 = ($985 | 0) == 0;
 
5250
                      if ($986) {
 
5251
                        var $991 = 0;
 
5252
                      } else {
 
5253
                        var $988 = -$984 | 0;
 
5254
                        var $989 = $988 & 7;
 
5255
                        var $991 = $989;
 
5256
                      }
 
5257
                      var $991;
 
5258
                      var $_sum80_i = $991 + $tsize_242_i | 0;
 
5259
                      var $992 = $tbase_243_i + $_sum80_i | 0;
 
5260
                      var $993 = $992;
 
5261
                      var $994 = $992;
 
5262
                      var $995 = $982;
 
5263
                      var $996 = $994 - $995 | 0;
 
5264
                      var $_sum_i16_i = $981 + $nb_0 | 0;
 
5265
                      var $997 = $tbase_243_i + $_sum_i16_i | 0;
 
5266
                      var $998 = $997;
 
5267
                      var $999 = $996 - $nb_0 | 0;
 
5268
                      var $1000 = $nb_0 | 3;
 
5269
                      var $_sum1_i17_i = $981 + 4 | 0;
 
5270
                      var $1001 = $tbase_243_i + $_sum1_i17_i | 0;
 
5271
                      var $1002 = $1001;
 
5272
                      HEAP32[$1002 >> 2] = $1000;
 
5273
                      var $1003 = HEAP32[(__gm_ + 24 | 0) >> 2];
 
5274
                      var $1004 = ($993 | 0) == ($1003 | 0);
 
5275
                      $_$314 : do {
 
5276
                        if ($1004) {
 
5277
                          var $1006 = HEAP32[(__gm_ + 12 | 0) >> 2];
 
5278
                          var $1007 = $1006 + $999 | 0;
 
5279
                          HEAP32[(__gm_ + 12 | 0) >> 2] = $1007;
 
5280
                          HEAP32[(__gm_ + 24 | 0) >> 2] = $998;
 
5281
                          var $1008 = $1007 | 1;
 
5282
                          var $_sum42_i_i = $_sum_i16_i + 4 | 0;
 
5283
                          var $1009 = $tbase_243_i + $_sum42_i_i | 0;
 
5284
                          var $1010 = $1009;
 
5285
                          HEAP32[$1010 >> 2] = $1008;
 
5286
                        } else {
 
5287
                          var $1012 = HEAP32[(__gm_ + 20 | 0) >> 2];
 
5288
                          var $1013 = ($993 | 0) == ($1012 | 0);
 
5289
                          if ($1013) {
 
5290
                            var $1015 = HEAP32[(__gm_ + 8 | 0) >> 2];
 
5291
                            var $1016 = $1015 + $999 | 0;
 
5292
                            HEAP32[(__gm_ + 8 | 0) >> 2] = $1016;
 
5293
                            HEAP32[(__gm_ + 20 | 0) >> 2] = $998;
 
5294
                            var $1017 = $1016 | 1;
 
5295
                            var $_sum40_i_i = $_sum_i16_i + 4 | 0;
 
5296
                            var $1018 = $tbase_243_i + $_sum40_i_i | 0;
 
5297
                            var $1019 = $1018;
 
5298
                            HEAP32[$1019 >> 2] = $1017;
 
5299
                            var $_sum41_i_i = $1016 + $_sum_i16_i | 0;
 
5300
                            var $1020 = $tbase_243_i + $_sum41_i_i | 0;
 
5301
                            var $1021 = $1020;
 
5302
                            HEAP32[$1021 >> 2] = $1016;
 
5303
                          } else {
 
5304
                            var $_sum2_i18_i = $tsize_242_i + 4 | 0;
 
5305
                            var $_sum81_i = $_sum2_i18_i + $991 | 0;
 
5306
                            var $1023 = $tbase_243_i + $_sum81_i | 0;
 
5307
                            var $1024 = $1023;
 
5308
                            var $1025 = HEAPU32[$1024 >> 2];
 
5309
                            var $1026 = $1025 & 3;
 
5310
                            var $1027 = ($1026 | 0) == 1;
 
5311
                            if ($1027) {
 
5312
                              var $1029 = $1025 & -8;
 
5313
                              var $1030 = $1025 >>> 3;
 
5314
                              var $1031 = $1025 >>> 0 < 256;
 
5315
                              $_$322 : do {
 
5316
                                if ($1031) {
 
5317
                                  var $_sum3738_i_i = $991 | 8;
 
5318
                                  var $_sum91_i = $_sum3738_i_i + $tsize_242_i | 0;
 
5319
                                  var $1033 = $tbase_243_i + $_sum91_i | 0;
 
5320
                                  var $1034 = $1033;
 
5321
                                  var $1035 = HEAPU32[$1034 >> 2];
 
5322
                                  var $_sum39_i_i = $tsize_242_i + 12 | 0;
 
5323
                                  var $_sum92_i = $_sum39_i_i + $991 | 0;
 
5324
                                  var $1036 = $tbase_243_i + $_sum92_i | 0;
 
5325
                                  var $1037 = $1036;
 
5326
                                  var $1038 = HEAPU32[$1037 >> 2];
 
5327
                                  var $1039 = ($1035 | 0) == ($1038 | 0);
 
5328
                                  if ($1039) {
 
5329
                                    var $1041 = 1 << $1030;
 
5330
                                    var $1042 = $1041 ^ -1;
 
5331
                                    var $1043 = HEAP32[(__gm_ | 0) >> 2];
 
5332
                                    var $1044 = $1043 & $1042;
 
5333
                                    HEAP32[(__gm_ | 0) >> 2] = $1044;
 
5334
                                  } else {
 
5335
                                    var $1046 = $1025 >>> 2;
 
5336
                                    var $1047 = $1046 & 1073741822;
 
5337
                                    var $1048 = __gm_ + 40 + ($1047 << 2) | 0;
 
5338
                                    var $1049 = $1048;
 
5339
                                    var $1050 = ($1035 | 0) == ($1049 | 0);
 
5340
                                    do {
 
5341
                                      if ($1050) {
 
5342
                                        __label__ = 233;
 
5343
                                      } else {
 
5344
                                        var $1052 = $1035;
 
5345
                                        var $1053 = HEAPU32[(__gm_ + 16 | 0) >> 2];
 
5346
                                        var $1054 = $1052 >>> 0 < $1053 >>> 0;
 
5347
                                        if ($1054) {
 
5348
                                          __label__ = 236;
 
5349
                                          break;
 
5350
                                        }
 
5351
                                        __label__ = 233;
 
5352
                                        break;
 
5353
                                      }
 
5354
                                    } while (0);
 
5355
                                    do {
 
5356
                                      if (__label__ == 233) {
 
5357
                                        var $1056 = ($1038 | 0) == ($1049 | 0);
 
5358
                                        if (!$1056) {
 
5359
                                          var $1058 = $1038;
 
5360
                                          var $1059 = HEAPU32[(__gm_ + 16 | 0) >> 2];
 
5361
                                          var $1060 = $1058 >>> 0 < $1059 >>> 0;
 
5362
                                          if ($1060) {
 
5363
                                            break;
 
5364
                                          }
 
5365
                                        }
 
5366
                                        var $1061 = $1035 + 12 | 0;
 
5367
                                        HEAP32[$1061 >> 2] = $1038;
 
5368
                                        var $1062 = $1038 + 8 | 0;
 
5369
                                        HEAP32[$1062 >> 2] = $1035;
 
5370
                                        break $_$322;
 
5371
                                      }
 
5372
                                    } while (0);
 
5373
                                    _abort();
 
5374
                                  }
 
5375
                                } else {
 
5376
                                  var $1064 = $992;
 
5377
                                  var $_sum34_i_i = $991 | 24;
 
5378
                                  var $_sum82_i = $_sum34_i_i + $tsize_242_i | 0;
 
5379
                                  var $1065 = $tbase_243_i + $_sum82_i | 0;
 
5380
                                  var $1066 = $1065;
 
5381
                                  var $1067 = HEAPU32[$1066 >> 2];
 
5382
                                  var $_sum5_i_i = $tsize_242_i + 12 | 0;
 
5383
                                  var $_sum83_i = $_sum5_i_i + $991 | 0;
 
5384
                                  var $1068 = $tbase_243_i + $_sum83_i | 0;
 
5385
                                  var $1069 = $1068;
 
5386
                                  var $1070 = HEAPU32[$1069 >> 2];
 
5387
                                  var $1071 = ($1070 | 0) == ($1064 | 0);
 
5388
                                  do {
 
5389
                                    if ($1071) {
 
5390
                                      var $_sum67_i_i = $991 | 16;
 
5391
                                      var $_sum89_i = $_sum2_i18_i + $_sum67_i_i | 0;
 
5392
                                      var $1084 = $tbase_243_i + $_sum89_i | 0;
 
5393
                                      var $1085 = $1084;
 
5394
                                      var $1086 = HEAP32[$1085 >> 2];
 
5395
                                      var $1087 = ($1086 | 0) == 0;
 
5396
                                      if ($1087) {
 
5397
                                        var $_sum90_i = $_sum67_i_i + $tsize_242_i | 0;
 
5398
                                        var $1089 = $tbase_243_i + $_sum90_i | 0;
 
5399
                                        var $1090 = $1089;
 
5400
                                        var $1091 = HEAP32[$1090 >> 2];
 
5401
                                        var $1092 = ($1091 | 0) == 0;
 
5402
                                        if ($1092) {
 
5403
                                          var $R_1_i_i = 0;
 
5404
                                          break;
 
5405
                                        }
 
5406
                                        var $RP_0_i_i = $1090;
 
5407
                                        var $R_0_i_i = $1091;
 
5408
                                      } else {
 
5409
                                        var $RP_0_i_i = $1085;
 
5410
                                        var $R_0_i_i = $1086;
 
5411
                                        __label__ = 243;
 
5412
                                      }
 
5413
                                      while (1) {
 
5414
                                        var $R_0_i_i;
 
5415
                                        var $RP_0_i_i;
 
5416
                                        var $1093 = $R_0_i_i + 20 | 0;
 
5417
                                        var $1094 = HEAP32[$1093 >> 2];
 
5418
                                        var $1095 = ($1094 | 0) == 0;
 
5419
                                        if (!$1095) {
 
5420
                                          var $RP_0_i_i = $1093;
 
5421
                                          var $R_0_i_i = $1094;
 
5422
                                          continue;
 
5423
                                        }
 
5424
                                        var $1097 = $R_0_i_i + 16 | 0;
 
5425
                                        var $1098 = HEAPU32[$1097 >> 2];
 
5426
                                        var $1099 = ($1098 | 0) == 0;
 
5427
                                        if ($1099) {
 
5428
                                          break;
 
5429
                                        }
 
5430
                                        var $RP_0_i_i = $1097;
 
5431
                                        var $R_0_i_i = $1098;
 
5432
                                      }
 
5433
                                      var $1101 = $RP_0_i_i;
 
5434
                                      var $1102 = HEAPU32[(__gm_ + 16 | 0) >> 2];
 
5435
                                      var $1103 = $1101 >>> 0 < $1102 >>> 0;
 
5436
                                      if ($1103) {
 
5437
                                        _abort();
 
5438
                                      } else {
 
5439
                                        HEAP32[$RP_0_i_i >> 2] = 0;
 
5440
                                        var $R_1_i_i = $R_0_i_i;
 
5441
                                      }
 
5442
                                    } else {
 
5443
                                      var $_sum3536_i_i = $991 | 8;
 
5444
                                      var $_sum84_i = $_sum3536_i_i + $tsize_242_i | 0;
 
5445
                                      var $1073 = $tbase_243_i + $_sum84_i | 0;
 
5446
                                      var $1074 = $1073;
 
5447
                                      var $1075 = HEAPU32[$1074 >> 2];
 
5448
                                      var $1076 = $1075;
 
5449
                                      var $1077 = HEAPU32[(__gm_ + 16 | 0) >> 2];
 
5450
                                      var $1078 = $1076 >>> 0 < $1077 >>> 0;
 
5451
                                      if ($1078) {
 
5452
                                        _abort();
 
5453
                                      } else {
 
5454
                                        var $1080 = $1075 + 12 | 0;
 
5455
                                        HEAP32[$1080 >> 2] = $1070;
 
5456
                                        var $1081 = $1070 + 8 | 0;
 
5457
                                        HEAP32[$1081 >> 2] = $1075;
 
5458
                                        var $R_1_i_i = $1070;
 
5459
                                      }
 
5460
                                    }
 
5461
                                  } while (0);
 
5462
                                  var $R_1_i_i;
 
5463
                                  var $1107 = ($1067 | 0) == 0;
 
5464
                                  if ($1107) {
 
5465
                                    break;
 
5466
                                  }
 
5467
                                  var $_sum30_i_i = $tsize_242_i + 28 | 0;
 
5468
                                  var $_sum85_i = $_sum30_i_i + $991 | 0;
 
5469
                                  var $1109 = $tbase_243_i + $_sum85_i | 0;
 
5470
                                  var $1110 = $1109;
 
5471
                                  var $1111 = HEAP32[$1110 >> 2];
 
5472
                                  var $1112 = __gm_ + 304 + ($1111 << 2) | 0;
 
5473
                                  var $1113 = HEAP32[$1112 >> 2];
 
5474
                                  var $1114 = ($1064 | 0) == ($1113 | 0);
 
5475
                                  do {
 
5476
                                    if ($1114) {
 
5477
                                      HEAP32[$1112 >> 2] = $R_1_i_i;
 
5478
                                      var $cond_i_i = ($R_1_i_i | 0) == 0;
 
5479
                                      if (!$cond_i_i) {
 
5480
                                        break;
 
5481
                                      }
 
5482
                                      var $1116 = HEAP32[$1110 >> 2];
 
5483
                                      var $1117 = 1 << $1116;
 
5484
                                      var $1118 = $1117 ^ -1;
 
5485
                                      var $1119 = HEAP32[(__gm_ + 4 | 0) >> 2];
 
5486
                                      var $1120 = $1119 & $1118;
 
5487
                                      HEAP32[(__gm_ + 4 | 0) >> 2] = $1120;
 
5488
                                      break $_$322;
 
5489
                                    }
 
5490
                                    var $1122 = $1067;
 
5491
                                    var $1123 = HEAPU32[(__gm_ + 16 | 0) >> 2];
 
5492
                                    var $1124 = $1122 >>> 0 < $1123 >>> 0;
 
5493
                                    if ($1124) {
 
5494
                                      _abort();
 
5495
                                    } else {
 
5496
                                      var $1126 = $1067 + 16 | 0;
 
5497
                                      var $1127 = HEAP32[$1126 >> 2];
 
5498
                                      var $1128 = ($1127 | 0) == ($1064 | 0);
 
5499
                                      if ($1128) {
 
5500
                                        HEAP32[$1126 >> 2] = $R_1_i_i;
 
5501
                                      } else {
 
5502
                                        var $1131 = $1067 + 20 | 0;
 
5503
                                        HEAP32[$1131 >> 2] = $R_1_i_i;
 
5504
                                      }
 
5505
                                      var $1134 = ($R_1_i_i | 0) == 0;
 
5506
                                      if ($1134) {
 
5507
                                        break $_$322;
 
5508
                                      }
 
5509
                                    }
 
5510
                                  } while (0);
 
5511
                                  var $1136 = $R_1_i_i;
 
5512
                                  var $1137 = HEAPU32[(__gm_ + 16 | 0) >> 2];
 
5513
                                  var $1138 = $1136 >>> 0 < $1137 >>> 0;
 
5514
                                  if ($1138) {
 
5515
                                    _abort();
 
5516
                                  } else {
 
5517
                                    var $1140 = $R_1_i_i + 24 | 0;
 
5518
                                    HEAP32[$1140 >> 2] = $1067;
 
5519
                                    var $_sum3132_i_i = $991 | 16;
 
5520
                                    var $_sum86_i = $_sum3132_i_i + $tsize_242_i | 0;
 
5521
                                    var $1141 = $tbase_243_i + $_sum86_i | 0;
 
5522
                                    var $1142 = $1141;
 
5523
                                    var $1143 = HEAPU32[$1142 >> 2];
 
5524
                                    var $1144 = ($1143 | 0) == 0;
 
5525
                                    if (!$1144) {
 
5526
                                      var $1146 = $1143;
 
5527
                                      var $1147 = HEAPU32[(__gm_ + 16 | 0) >> 2];
 
5528
                                      var $1148 = $1146 >>> 0 < $1147 >>> 0;
 
5529
                                      if ($1148) {
 
5530
                                        _abort();
 
5531
                                      } else {
 
5532
                                        var $1150 = $R_1_i_i + 16 | 0;
 
5533
                                        HEAP32[$1150 >> 2] = $1143;
 
5534
                                        var $1151 = $1143 + 24 | 0;
 
5535
                                        HEAP32[$1151 >> 2] = $R_1_i_i;
 
5536
                                      }
 
5537
                                    }
 
5538
                                    var $_sum87_i = $_sum2_i18_i + $_sum3132_i_i | 0;
 
5539
                                    var $1154 = $tbase_243_i + $_sum87_i | 0;
 
5540
                                    var $1155 = $1154;
 
5541
                                    var $1156 = HEAPU32[$1155 >> 2];
 
5542
                                    var $1157 = ($1156 | 0) == 0;
 
5543
                                    if ($1157) {
 
5544
                                      break;
 
5545
                                    }
 
5546
                                    var $1159 = $1156;
 
5547
                                    var $1160 = HEAPU32[(__gm_ + 16 | 0) >> 2];
 
5548
                                    var $1161 = $1159 >>> 0 < $1160 >>> 0;
 
5549
                                    if ($1161) {
 
5550
                                      _abort();
 
5551
                                    } else {
 
5552
                                      var $1163 = $R_1_i_i + 20 | 0;
 
5553
                                      HEAP32[$1163 >> 2] = $1156;
 
5554
                                      var $1164 = $1156 + 24 | 0;
 
5555
                                      HEAP32[$1164 >> 2] = $R_1_i_i;
 
5556
                                    }
 
5557
                                  }
 
5558
                                }
 
5559
                              } while (0);
 
5560
                              var $_sum9_i_i = $1029 | $991;
 
5561
                              var $_sum88_i = $_sum9_i_i + $tsize_242_i | 0;
 
5562
                              var $1168 = $tbase_243_i + $_sum88_i | 0;
 
5563
                              var $1169 = $1168;
 
5564
                              var $1170 = $1029 + $999 | 0;
 
5565
                              var $oldfirst_0_i_i = $1169;
 
5566
                              var $qsize_0_i_i = $1170;
 
5567
                            } else {
 
5568
                              var $oldfirst_0_i_i = $993;
 
5569
                              var $qsize_0_i_i = $999;
 
5570
                            }
 
5571
                            var $qsize_0_i_i;
 
5572
                            var $oldfirst_0_i_i;
 
5573
                            var $1172 = $oldfirst_0_i_i + 4 | 0;
 
5574
                            var $1173 = HEAP32[$1172 >> 2];
 
5575
                            var $1174 = $1173 & -2;
 
5576
                            HEAP32[$1172 >> 2] = $1174;
 
5577
                            var $1175 = $qsize_0_i_i | 1;
 
5578
                            var $_sum10_i_i = $_sum_i16_i + 4 | 0;
 
5579
                            var $1176 = $tbase_243_i + $_sum10_i_i | 0;
 
5580
                            var $1177 = $1176;
 
5581
                            HEAP32[$1177 >> 2] = $1175;
 
5582
                            var $_sum11_i19_i = $qsize_0_i_i + $_sum_i16_i | 0;
 
5583
                            var $1178 = $tbase_243_i + $_sum11_i19_i | 0;
 
5584
                            var $1179 = $1178;
 
5585
                            HEAP32[$1179 >> 2] = $qsize_0_i_i;
 
5586
                            var $1180 = $qsize_0_i_i >>> 0 < 256;
 
5587
                            if ($1180) {
 
5588
                              var $1182 = $qsize_0_i_i >>> 3;
 
5589
                              var $1183 = $qsize_0_i_i >>> 2;
 
5590
                              var $1184 = $1183 & 1073741822;
 
5591
                              var $1185 = __gm_ + 40 + ($1184 << 2) | 0;
 
5592
                              var $1186 = $1185;
 
5593
                              var $1187 = HEAPU32[(__gm_ | 0) >> 2];
 
5594
                              var $1188 = 1 << $1182;
 
5595
                              var $1189 = $1187 & $1188;
 
5596
                              var $1190 = ($1189 | 0) == 0;
 
5597
                              do {
 
5598
                                if ($1190) {
 
5599
                                  var $1192 = $1187 | $1188;
 
5600
                                  HEAP32[(__gm_ | 0) >> 2] = $1192;
 
5601
                                  var $_sum26_pre_i_i = $1184 + 2 | 0;
 
5602
                                  var $_pre_i_i = __gm_ + 40 + ($_sum26_pre_i_i << 2) | 0;
 
5603
                                  var $F4_0_i_i = $1186;
 
5604
                                  var $_pre_phi_i20_i = $_pre_i_i;
 
5605
                                } else {
 
5606
                                  var $_sum29_i_i = $1184 + 2 | 0;
 
5607
                                  var $1194 = __gm_ + 40 + ($_sum29_i_i << 2) | 0;
 
5608
                                  var $1195 = HEAPU32[$1194 >> 2];
 
5609
                                  var $1196 = $1195;
 
5610
                                  var $1197 = HEAPU32[(__gm_ + 16 | 0) >> 2];
 
5611
                                  var $1198 = $1196 >>> 0 < $1197 >>> 0;
 
5612
                                  if (!$1198) {
 
5613
                                    var $F4_0_i_i = $1195;
 
5614
                                    var $_pre_phi_i20_i = $1194;
 
5615
                                    break;
 
5616
                                  }
 
5617
                                  _abort();
 
5618
                                }
 
5619
                              } while (0);
 
5620
                              var $_pre_phi_i20_i;
 
5621
                              var $F4_0_i_i;
 
5622
                              HEAP32[$_pre_phi_i20_i >> 2] = $998;
 
5623
                              var $1201 = $F4_0_i_i + 12 | 0;
 
5624
                              HEAP32[$1201 >> 2] = $998;
 
5625
                              var $_sum27_i_i = $_sum_i16_i + 8 | 0;
 
5626
                              var $1202 = $tbase_243_i + $_sum27_i_i | 0;
 
5627
                              var $1203 = $1202;
 
5628
                              HEAP32[$1203 >> 2] = $F4_0_i_i;
 
5629
                              var $_sum28_i_i = $_sum_i16_i + 12 | 0;
 
5630
                              var $1204 = $tbase_243_i + $_sum28_i_i | 0;
 
5631
                              var $1205 = $1204;
 
5632
                              HEAP32[$1205 >> 2] = $1186;
 
5633
                            } else {
 
5634
                              var $1207 = $997;
 
5635
                              var $1208 = $qsize_0_i_i >>> 8;
 
5636
                              var $1209 = ($1208 | 0) == 0;
 
5637
                              do {
 
5638
                                if ($1209) {
 
5639
                                  var $I7_0_i_i = 0;
 
5640
                                } else {
 
5641
                                  var $1211 = $qsize_0_i_i >>> 0 > 16777215;
 
5642
                                  if ($1211) {
 
5643
                                    var $I7_0_i_i = 31;
 
5644
                                    break;
 
5645
                                  }
 
5646
                                  var $1213 = $1208 + 1048320 | 0;
 
5647
                                  var $1214 = $1213 >>> 16;
 
5648
                                  var $1215 = $1214 & 8;
 
5649
                                  var $1216 = $1208 << $1215;
 
5650
                                  var $1217 = $1216 + 520192 | 0;
 
5651
                                  var $1218 = $1217 >>> 16;
 
5652
                                  var $1219 = $1218 & 4;
 
5653
                                  var $1220 = $1216 << $1219;
 
5654
                                  var $1221 = $1220 + 245760 | 0;
 
5655
                                  var $1222 = $1221 >>> 16;
 
5656
                                  var $1223 = $1222 & 2;
 
5657
                                  var $1224 = $1219 | $1215;
 
5658
                                  var $1225 = $1224 | $1223;
 
5659
                                  var $1226 = 14 - $1225 | 0;
 
5660
                                  var $1227 = $1220 << $1223;
 
5661
                                  var $1228 = $1227 >>> 15;
 
5662
                                  var $1229 = $1226 + $1228 | 0;
 
5663
                                  var $1230 = $1229 << 1;
 
5664
                                  var $1231 = $1229 + 7 | 0;
 
5665
                                  var $1232 = $qsize_0_i_i >>> ($1231 >>> 0);
 
5666
                                  var $1233 = $1232 & 1;
 
5667
                                  var $1234 = $1233 | $1230;
 
5668
                                  var $I7_0_i_i = $1234;
 
5669
                                }
 
5670
                              } while (0);
 
5671
                              var $I7_0_i_i;
 
5672
                              var $1236 = __gm_ + 304 + ($I7_0_i_i << 2) | 0;
 
5673
                              var $_sum12_i_i = $_sum_i16_i + 28 | 0;
 
5674
                              var $1237 = $tbase_243_i + $_sum12_i_i | 0;
 
5675
                              var $1238 = $1237;
 
5676
                              HEAP32[$1238 >> 2] = $I7_0_i_i;
 
5677
                              var $_sum13_i_i = $_sum_i16_i + 16 | 0;
 
5678
                              var $1239 = $tbase_243_i + $_sum13_i_i | 0;
 
5679
                              var $_sum14_i_i = $_sum_i16_i + 20 | 0;
 
5680
                              var $1240 = $tbase_243_i + $_sum14_i_i | 0;
 
5681
                              var $1241 = $1240;
 
5682
                              HEAP32[$1241 >> 2] = 0;
 
5683
                              var $1242 = $1239;
 
5684
                              HEAP32[$1242 >> 2] = 0;
 
5685
                              var $1243 = HEAP32[(__gm_ + 4 | 0) >> 2];
 
5686
                              var $1244 = 1 << $I7_0_i_i;
 
5687
                              var $1245 = $1243 & $1244;
 
5688
                              var $1246 = ($1245 | 0) == 0;
 
5689
                              if ($1246) {
 
5690
                                var $1248 = $1243 | $1244;
 
5691
                                HEAP32[(__gm_ + 4 | 0) >> 2] = $1248;
 
5692
                                HEAP32[$1236 >> 2] = $1207;
 
5693
                                var $1249 = $1236;
 
5694
                                var $_sum15_i_i = $_sum_i16_i + 24 | 0;
 
5695
                                var $1250 = $tbase_243_i + $_sum15_i_i | 0;
 
5696
                                var $1251 = $1250;
 
5697
                                HEAP32[$1251 >> 2] = $1249;
 
5698
                                var $_sum16_i_i = $_sum_i16_i + 12 | 0;
 
5699
                                var $1252 = $tbase_243_i + $_sum16_i_i | 0;
 
5700
                                var $1253 = $1252;
 
5701
                                HEAP32[$1253 >> 2] = $1207;
 
5702
                                var $_sum17_i_i = $_sum_i16_i + 8 | 0;
 
5703
                                var $1254 = $tbase_243_i + $_sum17_i_i | 0;
 
5704
                                var $1255 = $1254;
 
5705
                                HEAP32[$1255 >> 2] = $1207;
 
5706
                              } else {
 
5707
                                var $1257 = HEAP32[$1236 >> 2];
 
5708
                                var $1258 = ($I7_0_i_i | 0) == 31;
 
5709
                                if ($1258) {
 
5710
                                  var $1263 = 0;
 
5711
                                } else {
 
5712
                                  var $1260 = $I7_0_i_i >>> 1;
 
5713
                                  var $1261 = 25 - $1260 | 0;
 
5714
                                  var $1263 = $1261;
 
5715
                                }
 
5716
                                var $1263;
 
5717
                                var $1264 = $qsize_0_i_i << $1263;
 
5718
                                var $K8_0_i_i = $1264;
 
5719
                                var $T_0_i21_i = $1257;
 
5720
                                while (1) {
 
5721
                                  var $T_0_i21_i;
 
5722
                                  var $K8_0_i_i;
 
5723
                                  var $1266 = $T_0_i21_i + 4 | 0;
 
5724
                                  var $1267 = HEAP32[$1266 >> 2];
 
5725
                                  var $1268 = $1267 & -8;
 
5726
                                  var $1269 = ($1268 | 0) == ($qsize_0_i_i | 0);
 
5727
                                  if ($1269) {
 
5728
                                    var $1289 = $T_0_i21_i + 8 | 0;
 
5729
                                    var $1290 = HEAPU32[$1289 >> 2];
 
5730
                                    var $1291 = $T_0_i21_i;
 
5731
                                    var $1292 = HEAPU32[(__gm_ + 16 | 0) >> 2];
 
5732
                                    var $1293 = $1291 >>> 0 < $1292 >>> 0;
 
5733
                                    do {
 
5734
                                      if (!$1293) {
 
5735
                                        var $1295 = $1290;
 
5736
                                        var $1296 = $1295 >>> 0 < $1292 >>> 0;
 
5737
                                        if ($1296) {
 
5738
                                          break;
 
5739
                                        }
 
5740
                                        var $1298 = $1290 + 12 | 0;
 
5741
                                        HEAP32[$1298 >> 2] = $1207;
 
5742
                                        HEAP32[$1289 >> 2] = $1207;
 
5743
                                        var $_sum20_i_i = $_sum_i16_i + 8 | 0;
 
5744
                                        var $1299 = $tbase_243_i + $_sum20_i_i | 0;
 
5745
                                        var $1300 = $1299;
 
5746
                                        HEAP32[$1300 >> 2] = $1290;
 
5747
                                        var $_sum21_i_i = $_sum_i16_i + 12 | 0;
 
5748
                                        var $1301 = $tbase_243_i + $_sum21_i_i | 0;
 
5749
                                        var $1302 = $1301;
 
5750
                                        HEAP32[$1302 >> 2] = $T_0_i21_i;
 
5751
                                        var $_sum22_i_i = $_sum_i16_i + 24 | 0;
 
5752
                                        var $1303 = $tbase_243_i + $_sum22_i_i | 0;
 
5753
                                        var $1304 = $1303;
 
5754
                                        HEAP32[$1304 >> 2] = 0;
 
5755
                                        break $_$314;
 
5756
                                      }
 
5757
                                    } while (0);
 
5758
                                    _abort();
 
5759
                                  } else {
 
5760
                                    var $1271 = $K8_0_i_i >>> 31;
 
5761
                                    var $1272 = $T_0_i21_i + 16 + ($1271 << 2) | 0;
 
5762
                                    var $1273 = HEAPU32[$1272 >> 2];
 
5763
                                    var $1274 = ($1273 | 0) == 0;
 
5764
                                    var $1275 = $K8_0_i_i << 1;
 
5765
                                    if (!$1274) {
 
5766
                                      var $K8_0_i_i = $1275;
 
5767
                                      var $T_0_i21_i = $1273;
 
5768
                                      continue;
 
5769
                                    }
 
5770
                                    var $1277 = $1272;
 
5771
                                    var $1278 = HEAPU32[(__gm_ + 16 | 0) >> 2];
 
5772
                                    var $1279 = $1277 >>> 0 < $1278 >>> 0;
 
5773
                                    if (!$1279) {
 
5774
                                      HEAP32[$1272 >> 2] = $1207;
 
5775
                                      var $_sum23_i_i = $_sum_i16_i + 24 | 0;
 
5776
                                      var $1281 = $tbase_243_i + $_sum23_i_i | 0;
 
5777
                                      var $1282 = $1281;
 
5778
                                      HEAP32[$1282 >> 2] = $T_0_i21_i;
 
5779
                                      var $_sum24_i_i = $_sum_i16_i + 12 | 0;
 
5780
                                      var $1283 = $tbase_243_i + $_sum24_i_i | 0;
 
5781
                                      var $1284 = $1283;
 
5782
                                      HEAP32[$1284 >> 2] = $1207;
 
5783
                                      var $_sum25_i_i = $_sum_i16_i + 8 | 0;
 
5784
                                      var $1285 = $tbase_243_i + $_sum25_i_i | 0;
 
5785
                                      var $1286 = $1285;
 
5786
                                      HEAP32[$1286 >> 2] = $1207;
 
5787
                                      break $_$314;
 
5788
                                    }
 
5789
                                    _abort();
 
5790
                                  }
 
5791
                                }
 
5792
                              }
 
5793
                            }
 
5794
                          }
 
5795
                        }
 
5796
                      } while (0);
 
5797
                      var $_sum1819_i_i = $981 | 8;
 
5798
                      var $1305 = $tbase_243_i + $_sum1819_i_i | 0;
 
5799
                      var $mem_0 = $1305;
 
5800
                      break $_$215;
 
5801
                    }
 
5802
                  } while (0);
 
5803
                  var $1306 = $876;
 
5804
                  var $sp_0_i_i_i = __gm_ + 444 | 0;
 
5805
                  while (1) {
 
5806
                    var $sp_0_i_i_i;
 
5807
                    var $1308 = $sp_0_i_i_i | 0;
 
5808
                    var $1309 = HEAPU32[$1308 >> 2];
 
5809
                    var $1310 = $1309 >>> 0 > $1306 >>> 0;
 
5810
                    if (!$1310) {
 
5811
                      var $1312 = $sp_0_i_i_i + 4 | 0;
 
5812
                      var $1313 = HEAPU32[$1312 >> 2];
 
5813
                      var $1314 = $1309 + $1313 | 0;
 
5814
                      var $1315 = $1314 >>> 0 > $1306 >>> 0;
 
5815
                      if ($1315) {
 
5816
                        var $1321 = $1309;
 
5817
                        var $1320 = $1313;
 
5818
                        break;
 
5819
                      }
 
5820
                    }
 
5821
                    var $1317 = $sp_0_i_i_i + 8 | 0;
 
5822
                    var $1318 = HEAPU32[$1317 >> 2];
 
5823
                    var $1319 = ($1318 | 0) == 0;
 
5824
                    if (!$1319) {
 
5825
                      var $sp_0_i_i_i = $1318;
 
5826
                      continue;
 
5827
                    }
 
5828
                    var $_pre14_i_i = 4;
 
5829
                    var $1321 = 0;
 
5830
                    var $1320 = $_pre14_i_i;
 
5831
                    break;
 
5832
                  }
 
5833
                  var $1320;
 
5834
                  var $1321;
 
5835
                  var $1322 = $1321 + $1320 | 0;
 
5836
                  var $_sum1_i10_i = $1320 - 39 | 0;
 
5837
                  var $1323 = $1321 + $_sum1_i10_i | 0;
 
5838
                  var $1324 = $1323;
 
5839
                  var $1325 = $1324 & 7;
 
5840
                  var $1326 = ($1325 | 0) == 0;
 
5841
                  if ($1326) {
 
5842
                    var $1331 = 0;
 
5843
                  } else {
 
5844
                    var $1328 = -$1324 | 0;
 
5845
                    var $1329 = $1328 & 7;
 
5846
                    var $1331 = $1329;
 
5847
                  }
 
5848
                  var $1331;
 
5849
                  var $_sum_i11_i = $1320 - 47 | 0;
 
5850
                  var $_sum2_i12_i = $_sum_i11_i + $1331 | 0;
 
5851
                  var $1332 = $1321 + $_sum2_i12_i | 0;
 
5852
                  var $1333 = $876 + 16 | 0;
 
5853
                  var $1334 = $1333;
 
5854
                  var $1335 = $1332 >>> 0 < $1334 >>> 0;
 
5855
                  var $1336 = $1335 ? $1306 : $1332;
 
5856
                  var $1337 = $1336 + 8 | 0;
 
5857
                  var $1338 = $1337;
 
5858
                  var $1339 = $tbase_243_i + 8 | 0;
 
5859
                  var $1340 = $1339;
 
5860
                  var $1341 = $1340 & 7;
 
5861
                  var $1342 = ($1341 | 0) == 0;
 
5862
                  if ($1342) {
 
5863
                    var $1346 = 0;
 
5864
                  } else {
 
5865
                    var $1344 = -$1340 | 0;
 
5866
                    var $1345 = $1344 & 7;
 
5867
                    var $1346 = $1345;
 
5868
                  }
 
5869
                  var $1346;
 
5870
                  var $1347 = $tbase_243_i + $1346 | 0;
 
5871
                  var $1348 = $1347;
 
5872
                  var $1349 = $tsize_242_i - 40 | 0;
 
5873
                  var $1350 = $1349 - $1346 | 0;
 
5874
                  HEAP32[(__gm_ + 24 | 0) >> 2] = $1348;
 
5875
                  HEAP32[(__gm_ + 12 | 0) >> 2] = $1350;
 
5876
                  var $1351 = $1350 | 1;
 
5877
                  var $_sum_i_i_i = $1346 + 4 | 0;
 
5878
                  var $1352 = $tbase_243_i + $_sum_i_i_i | 0;
 
5879
                  var $1353 = $1352;
 
5880
                  HEAP32[$1353 >> 2] = $1351;
 
5881
                  var $_sum2_i_i_i = $tsize_242_i - 36 | 0;
 
5882
                  var $1354 = $tbase_243_i + $_sum2_i_i_i | 0;
 
5883
                  var $1355 = $1354;
 
5884
                  HEAP32[$1355 >> 2] = 40;
 
5885
                  var $1356 = HEAP32[(_mparams + 16 | 0) >> 2];
 
5886
                  HEAP32[(__gm_ + 28 | 0) >> 2] = $1356;
 
5887
                  var $1357 = $1336 + 4 | 0;
 
5888
                  var $1358 = $1357;
 
5889
                  HEAP32[$1358 >> 2] = 27;
 
5890
                  HEAP32[$1337 >> 2] = HEAP32[(__gm_ + 444 | 0) >> 2];
 
5891
                  HEAP32[$1337 + 4 >> 2] = HEAP32[(__gm_ + 444 | 0) + 4 >> 2];
 
5892
                  HEAP32[$1337 + 8 >> 2] = HEAP32[(__gm_ + 444 | 0) + 8 >> 2];
 
5893
                  HEAP32[$1337 + 12 >> 2] = HEAP32[(__gm_ + 444 | 0) + 12 >> 2];
 
5894
                  HEAP32[(__gm_ + 444 | 0) >> 2] = $tbase_243_i;
 
5895
                  HEAP32[(__gm_ + 448 | 0) >> 2] = $tsize_242_i;
 
5896
                  HEAP32[(__gm_ + 456 | 0) >> 2] = 0;
 
5897
                  HEAP32[(__gm_ + 452 | 0) >> 2] = $1338;
 
5898
                  var $1359 = $1336 + 28 | 0;
 
5899
                  var $1360 = $1359;
 
5900
                  HEAP32[$1360 >> 2] = 7;
 
5901
                  var $1361 = $1336 + 32 | 0;
 
5902
                  var $1362 = $1361 >>> 0 < $1322 >>> 0;
 
5903
                  $_$426 : do {
 
5904
                    if ($1362) {
 
5905
                      var $1363 = $1360;
 
5906
                      while (1) {
 
5907
                        var $1363;
 
5908
                        var $1364 = $1363 + 4 | 0;
 
5909
                        HEAP32[$1364 >> 2] = 7;
 
5910
                        var $1365 = $1363 + 8 | 0;
 
5911
                        var $1366 = $1365;
 
5912
                        var $1367 = $1366 >>> 0 < $1322 >>> 0;
 
5913
                        if (!$1367) {
 
5914
                          break $_$426;
 
5915
                        }
 
5916
                        var $1363 = $1364;
 
5917
                      }
 
5918
                    }
 
5919
                  } while (0);
 
5920
                  var $1368 = ($1336 | 0) == ($1306 | 0);
 
5921
                  if ($1368) {
 
5922
                    break;
 
5923
                  }
 
5924
                  var $1370 = $1336;
 
5925
                  var $1371 = $876;
 
5926
                  var $1372 = $1370 - $1371 | 0;
 
5927
                  var $1373 = $1306 + $1372 | 0;
 
5928
                  var $_sum3_i_i = $1372 + 4 | 0;
 
5929
                  var $1374 = $1306 + $_sum3_i_i | 0;
 
5930
                  var $1375 = $1374;
 
5931
                  var $1376 = HEAP32[$1375 >> 2];
 
5932
                  var $1377 = $1376 & -2;
 
5933
                  HEAP32[$1375 >> 2] = $1377;
 
5934
                  var $1378 = $1372 | 1;
 
5935
                  var $1379 = $876 + 4 | 0;
 
5936
                  HEAP32[$1379 >> 2] = $1378;
 
5937
                  var $1380 = $1373;
 
5938
                  HEAP32[$1380 >> 2] = $1372;
 
5939
                  var $1381 = $1372 >>> 0 < 256;
 
5940
                  if ($1381) {
 
5941
                    var $1383 = $1372 >>> 3;
 
5942
                    var $1384 = $1372 >>> 2;
 
5943
                    var $1385 = $1384 & 1073741822;
 
5944
                    var $1386 = __gm_ + 40 + ($1385 << 2) | 0;
 
5945
                    var $1387 = $1386;
 
5946
                    var $1388 = HEAPU32[(__gm_ | 0) >> 2];
 
5947
                    var $1389 = 1 << $1383;
 
5948
                    var $1390 = $1388 & $1389;
 
5949
                    var $1391 = ($1390 | 0) == 0;
 
5950
                    do {
 
5951
                      if ($1391) {
 
5952
                        var $1393 = $1388 | $1389;
 
5953
                        HEAP32[(__gm_ | 0) >> 2] = $1393;
 
5954
                        var $_sum10_pre_i_i = $1385 + 2 | 0;
 
5955
                        var $_pre15_i_i = __gm_ + 40 + ($_sum10_pre_i_i << 2) | 0;
 
5956
                        var $F_0_i_i = $1387;
 
5957
                        var $_pre_phi_i_i = $_pre15_i_i;
 
5958
                      } else {
 
5959
                        var $_sum11_i_i = $1385 + 2 | 0;
 
5960
                        var $1395 = __gm_ + 40 + ($_sum11_i_i << 2) | 0;
 
5961
                        var $1396 = HEAPU32[$1395 >> 2];
 
5962
                        var $1397 = $1396;
 
5963
                        var $1398 = HEAPU32[(__gm_ + 16 | 0) >> 2];
 
5964
                        var $1399 = $1397 >>> 0 < $1398 >>> 0;
 
5965
                        if (!$1399) {
 
5966
                          var $F_0_i_i = $1396;
 
5967
                          var $_pre_phi_i_i = $1395;
 
5968
                          break;
 
5969
                        }
 
5970
                        _abort();
 
5971
                      }
 
5972
                    } while (0);
 
5973
                    var $_pre_phi_i_i;
 
5974
                    var $F_0_i_i;
 
5975
                    HEAP32[$_pre_phi_i_i >> 2] = $876;
 
5976
                    var $1402 = $F_0_i_i + 12 | 0;
 
5977
                    HEAP32[$1402 >> 2] = $876;
 
5978
                    var $1403 = $876 + 8 | 0;
 
5979
                    HEAP32[$1403 >> 2] = $F_0_i_i;
 
5980
                    var $1404 = $876 + 12 | 0;
 
5981
                    HEAP32[$1404 >> 2] = $1387;
 
5982
                  } else {
 
5983
                    var $1406 = $876;
 
5984
                    var $1407 = $1372 >>> 8;
 
5985
                    var $1408 = ($1407 | 0) == 0;
 
5986
                    do {
 
5987
                      if ($1408) {
 
5988
                        var $I1_0_i_i = 0;
 
5989
                      } else {
 
5990
                        var $1410 = $1372 >>> 0 > 16777215;
 
5991
                        if ($1410) {
 
5992
                          var $I1_0_i_i = 31;
 
5993
                          break;
 
5994
                        }
 
5995
                        var $1412 = $1407 + 1048320 | 0;
 
5996
                        var $1413 = $1412 >>> 16;
 
5997
                        var $1414 = $1413 & 8;
 
5998
                        var $1415 = $1407 << $1414;
 
5999
                        var $1416 = $1415 + 520192 | 0;
 
6000
                        var $1417 = $1416 >>> 16;
 
6001
                        var $1418 = $1417 & 4;
 
6002
                        var $1419 = $1415 << $1418;
 
6003
                        var $1420 = $1419 + 245760 | 0;
 
6004
                        var $1421 = $1420 >>> 16;
 
6005
                        var $1422 = $1421 & 2;
 
6006
                        var $1423 = $1418 | $1414;
 
6007
                        var $1424 = $1423 | $1422;
 
6008
                        var $1425 = 14 - $1424 | 0;
 
6009
                        var $1426 = $1419 << $1422;
 
6010
                        var $1427 = $1426 >>> 15;
 
6011
                        var $1428 = $1425 + $1427 | 0;
 
6012
                        var $1429 = $1428 << 1;
 
6013
                        var $1430 = $1428 + 7 | 0;
 
6014
                        var $1431 = $1372 >>> ($1430 >>> 0);
 
6015
                        var $1432 = $1431 & 1;
 
6016
                        var $1433 = $1432 | $1429;
 
6017
                        var $I1_0_i_i = $1433;
 
6018
                      }
 
6019
                    } while (0);
 
6020
                    var $I1_0_i_i;
 
6021
                    var $1435 = __gm_ + 304 + ($I1_0_i_i << 2) | 0;
 
6022
                    var $1436 = $876 + 28 | 0;
 
6023
                    var $I1_0_c_i_i = $I1_0_i_i;
 
6024
                    HEAP32[$1436 >> 2] = $I1_0_c_i_i;
 
6025
                    var $1437 = $876 + 20 | 0;
 
6026
                    HEAP32[$1437 >> 2] = 0;
 
6027
                    var $1438 = $876 + 16 | 0;
 
6028
                    HEAP32[$1438 >> 2] = 0;
 
6029
                    var $1439 = HEAP32[(__gm_ + 4 | 0) >> 2];
 
6030
                    var $1440 = 1 << $I1_0_i_i;
 
6031
                    var $1441 = $1439 & $1440;
 
6032
                    var $1442 = ($1441 | 0) == 0;
 
6033
                    if ($1442) {
 
6034
                      var $1444 = $1439 | $1440;
 
6035
                      HEAP32[(__gm_ + 4 | 0) >> 2] = $1444;
 
6036
                      HEAP32[$1435 >> 2] = $1406;
 
6037
                      var $1445 = $876 + 24 | 0;
 
6038
                      var $_c_i_i = $1435;
 
6039
                      HEAP32[$1445 >> 2] = $_c_i_i;
 
6040
                      var $1446 = $876 + 12 | 0;
 
6041
                      HEAP32[$1446 >> 2] = $876;
 
6042
                      var $1447 = $876 + 8 | 0;
 
6043
                      HEAP32[$1447 >> 2] = $876;
 
6044
                    } else {
 
6045
                      var $1449 = HEAP32[$1435 >> 2];
 
6046
                      var $1450 = ($I1_0_i_i | 0) == 31;
 
6047
                      if ($1450) {
 
6048
                        var $1455 = 0;
 
6049
                      } else {
 
6050
                        var $1452 = $I1_0_i_i >>> 1;
 
6051
                        var $1453 = 25 - $1452 | 0;
 
6052
                        var $1455 = $1453;
 
6053
                      }
 
6054
                      var $1455;
 
6055
                      var $1456 = $1372 << $1455;
 
6056
                      var $K2_0_i_i = $1456;
 
6057
                      var $T_0_i_i = $1449;
 
6058
                      while (1) {
 
6059
                        var $T_0_i_i;
 
6060
                        var $K2_0_i_i;
 
6061
                        var $1458 = $T_0_i_i + 4 | 0;
 
6062
                        var $1459 = HEAP32[$1458 >> 2];
 
6063
                        var $1460 = $1459 & -8;
 
6064
                        var $1461 = ($1460 | 0) == ($1372 | 0);
 
6065
                        if ($1461) {
 
6066
                          var $1478 = $T_0_i_i + 8 | 0;
 
6067
                          var $1479 = HEAPU32[$1478 >> 2];
 
6068
                          var $1480 = $T_0_i_i;
 
6069
                          var $1481 = HEAPU32[(__gm_ + 16 | 0) >> 2];
 
6070
                          var $1482 = $1480 >>> 0 < $1481 >>> 0;
 
6071
                          do {
 
6072
                            if (!$1482) {
 
6073
                              var $1484 = $1479;
 
6074
                              var $1485 = $1484 >>> 0 < $1481 >>> 0;
 
6075
                              if ($1485) {
 
6076
                                break;
 
6077
                              }
 
6078
                              var $1487 = $1479 + 12 | 0;
 
6079
                              HEAP32[$1487 >> 2] = $1406;
 
6080
                              HEAP32[$1478 >> 2] = $1406;
 
6081
                              var $1488 = $876 + 8 | 0;
 
6082
                              var $_c6_i_i = $1479;
 
6083
                              HEAP32[$1488 >> 2] = $_c6_i_i;
 
6084
                              var $1489 = $876 + 12 | 0;
 
6085
                              var $T_0_c_i_i = $T_0_i_i;
 
6086
                              HEAP32[$1489 >> 2] = $T_0_c_i_i;
 
6087
                              var $1490 = $876 + 24 | 0;
 
6088
                              HEAP32[$1490 >> 2] = 0;
 
6089
                              break $_$275;
 
6090
                            }
 
6091
                          } while (0);
 
6092
                          _abort();
 
6093
                        } else {
 
6094
                          var $1463 = $K2_0_i_i >>> 31;
 
6095
                          var $1464 = $T_0_i_i + 16 + ($1463 << 2) | 0;
 
6096
                          var $1465 = HEAPU32[$1464 >> 2];
 
6097
                          var $1466 = ($1465 | 0) == 0;
 
6098
                          var $1467 = $K2_0_i_i << 1;
 
6099
                          if (!$1466) {
 
6100
                            var $K2_0_i_i = $1467;
 
6101
                            var $T_0_i_i = $1465;
 
6102
                            continue;
 
6103
                          }
 
6104
                          var $1469 = $1464;
 
6105
                          var $1470 = HEAPU32[(__gm_ + 16 | 0) >> 2];
 
6106
                          var $1471 = $1469 >>> 0 < $1470 >>> 0;
 
6107
                          if (!$1471) {
 
6108
                            HEAP32[$1464 >> 2] = $1406;
 
6109
                            var $1473 = $876 + 24 | 0;
 
6110
                            var $T_0_c7_i_i = $T_0_i_i;
 
6111
                            HEAP32[$1473 >> 2] = $T_0_c7_i_i;
 
6112
                            var $1474 = $876 + 12 | 0;
 
6113
                            HEAP32[$1474 >> 2] = $876;
 
6114
                            var $1475 = $876 + 8 | 0;
 
6115
                            HEAP32[$1475 >> 2] = $876;
 
6116
                            break $_$275;
 
6117
                          }
 
6118
                          _abort();
 
6119
                        }
 
6120
                      }
 
6121
                    }
 
6122
                  }
 
6123
                }
 
6124
              } while (0);
 
6125
              var $1491 = HEAPU32[(__gm_ + 12 | 0) >> 2];
 
6126
              var $1492 = $1491 >>> 0 > $nb_0 >>> 0;
 
6127
              if (!$1492) {
 
6128
                break;
 
6129
              }
 
6130
              var $1494 = $1491 - $nb_0 | 0;
 
6131
              HEAP32[(__gm_ + 12 | 0) >> 2] = $1494;
 
6132
              var $1495 = HEAPU32[(__gm_ + 24 | 0) >> 2];
 
6133
              var $1496 = $1495;
 
6134
              var $1497 = $1496 + $nb_0 | 0;
 
6135
              var $1498 = $1497;
 
6136
              HEAP32[(__gm_ + 24 | 0) >> 2] = $1498;
 
6137
              var $1499 = $1494 | 1;
 
6138
              var $_sum_i30 = $nb_0 + 4 | 0;
 
6139
              var $1500 = $1496 + $_sum_i30 | 0;
 
6140
              var $1501 = $1500;
 
6141
              HEAP32[$1501 >> 2] = $1499;
 
6142
              var $1502 = $nb_0 | 3;
 
6143
              var $1503 = $1495 + 4 | 0;
 
6144
              HEAP32[$1503 >> 2] = $1502;
 
6145
              var $1504 = $1495 + 8 | 0;
 
6146
              var $1505 = $1504;
 
6147
              var $mem_0 = $1505;
 
6148
              break $_$215;
 
6149
            }
 
6150
          } while (0);
 
6151
          var $1506 = ___errno();
 
6152
          HEAP32[$1506 >> 2] = 12;
 
6153
          var $mem_0 = 0;
 
6154
        }
 
6155
      } else {
 
6156
        var $706 = $703 - $nb_0 | 0;
 
6157
        var $707 = HEAPU32[(__gm_ + 20 | 0) >> 2];
 
6158
        var $708 = $706 >>> 0 > 15;
 
6159
        if ($708) {
 
6160
          var $710 = $707;
 
6161
          var $711 = $710 + $nb_0 | 0;
 
6162
          var $712 = $711;
 
6163
          HEAP32[(__gm_ + 20 | 0) >> 2] = $712;
 
6164
          HEAP32[(__gm_ + 8 | 0) >> 2] = $706;
 
6165
          var $713 = $706 | 1;
 
6166
          var $_sum2 = $nb_0 + 4 | 0;
 
6167
          var $714 = $710 + $_sum2 | 0;
 
6168
          var $715 = $714;
 
6169
          HEAP32[$715 >> 2] = $713;
 
6170
          var $716 = $710 + $703 | 0;
 
6171
          var $717 = $716;
 
6172
          HEAP32[$717 >> 2] = $706;
 
6173
          var $718 = $nb_0 | 3;
 
6174
          var $719 = $707 + 4 | 0;
 
6175
          HEAP32[$719 >> 2] = $718;
 
6176
        } else {
 
6177
          HEAP32[(__gm_ + 8 | 0) >> 2] = 0;
 
6178
          HEAP32[(__gm_ + 20 | 0) >> 2] = 0;
 
6179
          var $721 = $703 | 3;
 
6180
          var $722 = $707 + 4 | 0;
 
6181
          HEAP32[$722 >> 2] = $721;
 
6182
          var $723 = $707;
 
6183
          var $_sum1 = $703 + 4 | 0;
 
6184
          var $724 = $723 + $_sum1 | 0;
 
6185
          var $725 = $724;
 
6186
          var $726 = HEAP32[$725 >> 2];
 
6187
          var $727 = $726 | 1;
 
6188
          HEAP32[$725 >> 2] = $727;
 
6189
        }
 
6190
        var $729 = $707 + 8 | 0;
 
6191
        var $730 = $729;
 
6192
        var $mem_0 = $730;
 
6193
      }
 
6194
    }
 
6195
  } while (0);
 
6196
  var $mem_0;
 
6197
  return $mem_0;
 
6198
  return null;
 
6199
}
 
6200
function _mallocNoU($bytes) {
 
6201
  var __label__;
 
6202
  var $1 = $bytes >>> 0 < 245;
 
6203
  $_$2 : do {
 
6204
    if ($1) {
 
6205
      var $3 = $bytes >>> 0 < 11;
 
6206
      if ($3) {
 
6207
        var $8 = 16;
 
6208
      } else {
 
6209
        var $5 = $bytes + 11 | 0;
 
6210
        var $6 = $5 & -8;
 
6211
        var $8 = $6;
 
6212
      }
 
6213
      var $8;
 
6214
      var $9 = $8 >>> 3;
 
6215
      var $10 = HEAP32[(__gm_ | 0) >> 2];
 
6216
      var $11 = $10 >>> ($9 >>> 0);
 
6217
      var $12 = $11 & 3;
 
6218
      var $13 = ($12 | 0) == 0;
 
6219
      if (!$13) {
 
6220
        var $15 = $11 & 1;
 
6221
        var $16 = $15 ^ 1;
 
6222
        var $17 = $16 + $9 | 0;
 
6223
        var $18 = $17 << 1;
 
6224
        var $19 = __gm_ + 40 + ($18 << 2) | 0;
 
6225
        var $20 = $19;
 
6226
        var $_sum10 = $18 + 2 | 0;
 
6227
        var $21 = __gm_ + 40 + ($_sum10 << 2) | 0;
 
6228
        var $22 = HEAP32[$21 >> 2];
 
6229
        var $23 = $22 + 8 | 0;
 
6230
        var $24 = HEAP32[$23 >> 2];
 
6231
        var $25 = ($20 | 0) == ($24 | 0);
 
6232
        if ($25) {
 
6233
          var $27 = 1 << $17;
 
6234
          var $28 = $27 ^ -1;
 
6235
          var $29 = $10 & $28;
 
6236
          HEAP32[(__gm_ | 0) >> 2] = $29;
 
6237
        } else {
 
6238
          var $31 = $24;
 
6239
          var $32 = HEAP32[(__gm_ + 16 | 0) >> 2];
 
6240
          var $33 = $31 >>> 0 < $32 >>> 0;
 
6241
          if ($33) {
 
6242
            _abort();
 
6243
          } else {
 
6244
            HEAP32[$21 >> 2] = $24;
 
6245
            var $35 = $24 + 12 | 0;
 
6246
            HEAP32[$35 >> 2] = $20;
 
6247
          }
 
6248
        }
 
6249
        var $38 = $17 << 3;
 
6250
        var $39 = $38 | 3;
 
6251
        var $40 = $22 + 4 | 0;
 
6252
        HEAP32[$40 >> 2] = $39;
 
6253
        var $41 = $22;
 
6254
        var $_sum1112 = $38 | 4;
 
6255
        var $42 = $41 + $_sum1112 | 0;
 
6256
        var $43 = $42;
 
6257
        var $44 = HEAP32[$43 >> 2];
 
6258
        var $45 = $44 | 1;
 
6259
        HEAP32[$43 >> 2] = $45;
 
6260
        var $46 = $23;
 
6261
        var $mem_0 = $46;
 
6262
        __label__ = 331;
 
6263
        break;
 
6264
      }
 
6265
      var $48 = HEAP32[(__gm_ + 8 | 0) >> 2];
 
6266
      var $49 = $8 >>> 0 > $48 >>> 0;
 
6267
      if (!$49) {
 
6268
        var $nb_0 = $8;
 
6269
        __label__ = 155;
 
6270
        break;
 
6271
      }
 
6272
      var $51 = ($11 | 0) == 0;
 
6273
      if (!$51) {
 
6274
        var $53 = $11 << $9;
 
6275
        var $54 = 2 << $9;
 
6276
        var $55 = -$54 | 0;
 
6277
        var $56 = $54 | $55;
 
6278
        var $57 = $53 & $56;
 
6279
        var $58 = -$57 | 0;
 
6280
        var $59 = $57 & $58;
 
6281
        var $60 = $59 - 1 | 0;
 
6282
        var $61 = $60 >>> 12;
 
6283
        var $62 = $61 & 16;
 
6284
        var $63 = $60 >>> ($62 >>> 0);
 
6285
        var $64 = $63 >>> 5;
 
6286
        var $65 = $64 & 8;
 
6287
        var $66 = $63 >>> ($65 >>> 0);
 
6288
        var $67 = $66 >>> 2;
 
6289
        var $68 = $67 & 4;
 
6290
        var $69 = $66 >>> ($68 >>> 0);
 
6291
        var $70 = $69 >>> 1;
 
6292
        var $71 = $70 & 2;
 
6293
        var $72 = $69 >>> ($71 >>> 0);
 
6294
        var $73 = $72 >>> 1;
 
6295
        var $74 = $73 & 1;
 
6296
        var $75 = $65 | $62;
 
6297
        var $76 = $75 | $68;
 
6298
        var $77 = $76 | $71;
 
6299
        var $78 = $77 | $74;
 
6300
        var $79 = $72 >>> ($74 >>> 0);
 
6301
        var $80 = $78 + $79 | 0;
 
6302
        var $81 = $80 << 1;
 
6303
        var $82 = __gm_ + 40 + ($81 << 2) | 0;
 
6304
        var $83 = $82;
 
6305
        var $_sum4 = $81 + 2 | 0;
 
6306
        var $84 = __gm_ + 40 + ($_sum4 << 2) | 0;
 
6307
        var $85 = HEAP32[$84 >> 2];
 
6308
        var $86 = $85 + 8 | 0;
 
6309
        var $87 = HEAP32[$86 >> 2];
 
6310
        var $88 = ($83 | 0) == ($87 | 0);
 
6311
        if ($88) {
 
6312
          var $90 = 1 << $80;
 
6313
          var $91 = $90 ^ -1;
 
6314
          var $92 = $10 & $91;
 
6315
          HEAP32[(__gm_ | 0) >> 2] = $92;
 
6316
        } else {
 
6317
          var $94 = $87;
 
6318
          var $95 = HEAP32[(__gm_ + 16 | 0) >> 2];
 
6319
          var $96 = $94 >>> 0 < $95 >>> 0;
 
6320
          if ($96) {
 
6321
            _abort();
 
6322
          } else {
 
6323
            HEAP32[$84 >> 2] = $87;
 
6324
            var $98 = $87 + 12 | 0;
 
6325
            HEAP32[$98 >> 2] = $83;
 
6326
          }
 
6327
        }
 
6328
        var $101 = $80 << 3;
 
6329
        var $102 = $101 - $8 | 0;
 
6330
        var $103 = $8 | 3;
 
6331
        var $104 = $85 + 4 | 0;
 
6332
        HEAP32[$104 >> 2] = $103;
 
6333
        var $105 = $85;
 
6334
        var $106 = $105 + $8 | 0;
 
6335
        var $107 = $106;
 
6336
        var $108 = $102 | 1;
 
6337
        var $_sum56 = $8 | 4;
 
6338
        var $109 = $105 + $_sum56 | 0;
 
6339
        var $110 = $109;
 
6340
        HEAP32[$110 >> 2] = $108;
 
6341
        var $111 = $105 + $101 | 0;
 
6342
        var $112 = $111;
 
6343
        HEAP32[$112 >> 2] = $102;
 
6344
        var $113 = HEAP32[(__gm_ + 8 | 0) >> 2];
 
6345
        var $114 = ($113 | 0) == 0;
 
6346
        if (!$114) {
 
6347
          var $116 = HEAP32[(__gm_ + 20 | 0) >> 2];
 
6348
          var $117 = $113 >>> 3;
 
6349
          var $118 = $113 >>> 2;
 
6350
          var $119 = $118 & 1073741822;
 
6351
          var $120 = __gm_ + 40 + ($119 << 2) | 0;
 
6352
          var $121 = $120;
 
6353
          var $122 = HEAP32[(__gm_ | 0) >> 2];
 
6354
          var $123 = 1 << $117;
 
6355
          var $124 = $122 & $123;
 
6356
          var $125 = ($124 | 0) == 0;
 
6357
          do {
 
6358
            if ($125) {
 
6359
              var $127 = $122 | $123;
 
6360
              HEAP32[(__gm_ | 0) >> 2] = $127;
 
6361
              var $_sum8_pre = $119 + 2 | 0;
 
6362
              var $_pre = __gm_ + 40 + ($_sum8_pre << 2) | 0;
 
6363
              var $F4_0 = $121;
 
6364
              var $_pre_phi = $_pre;
 
6365
            } else {
 
6366
              var $_sum9 = $119 + 2 | 0;
 
6367
              var $129 = __gm_ + 40 + ($_sum9 << 2) | 0;
 
6368
              var $130 = HEAP32[$129 >> 2];
 
6369
              var $131 = $130;
 
6370
              var $132 = HEAP32[(__gm_ + 16 | 0) >> 2];
 
6371
              var $133 = $131 >>> 0 < $132 >>> 0;
 
6372
              if (!$133) {
 
6373
                var $F4_0 = $130;
 
6374
                var $_pre_phi = $129;
 
6375
                break;
 
6376
              }
 
6377
              _abort();
 
6378
            }
 
6379
          } while (0);
 
6380
          var $_pre_phi;
 
6381
          var $F4_0;
 
6382
          HEAP32[$_pre_phi >> 2] = $116;
 
6383
          var $136 = $F4_0 + 12 | 0;
 
6384
          HEAP32[$136 >> 2] = $116;
 
6385
          var $137 = $116 + 8 | 0;
 
6386
          HEAP32[$137 >> 2] = $F4_0;
 
6387
          var $138 = $116 + 12 | 0;
 
6388
          HEAP32[$138 >> 2] = $121;
 
6389
        }
 
6390
        HEAP32[(__gm_ + 8 | 0) >> 2] = $102;
 
6391
        HEAP32[(__gm_ + 20 | 0) >> 2] = $107;
 
6392
        var $140 = $86;
 
6393
        var $mem_0 = $140;
 
6394
        __label__ = 331;
 
6395
        break;
 
6396
      }
 
6397
      var $142 = HEAP32[(__gm_ + 4 | 0) >> 2];
 
6398
      var $143 = ($142 | 0) == 0;
 
6399
      if ($143) {
 
6400
        var $nb_0 = $8;
 
6401
        __label__ = 155;
 
6402
        break;
 
6403
      }
 
6404
      var $145 = -$142 | 0;
 
6405
      var $146 = $142 & $145;
 
6406
      var $147 = $146 - 1 | 0;
 
6407
      var $148 = $147 >>> 12;
 
6408
      var $149 = $148 & 16;
 
6409
      var $150 = $147 >>> ($149 >>> 0);
 
6410
      var $151 = $150 >>> 5;
 
6411
      var $152 = $151 & 8;
 
6412
      var $153 = $150 >>> ($152 >>> 0);
 
6413
      var $154 = $153 >>> 2;
 
6414
      var $155 = $154 & 4;
 
6415
      var $156 = $153 >>> ($155 >>> 0);
 
6416
      var $157 = $156 >>> 1;
 
6417
      var $158 = $157 & 2;
 
6418
      var $159 = $156 >>> ($158 >>> 0);
 
6419
      var $160 = $159 >>> 1;
 
6420
      var $161 = $160 & 1;
 
6421
      var $162 = $152 | $149;
 
6422
      var $163 = $162 | $155;
 
6423
      var $164 = $163 | $158;
 
6424
      var $165 = $164 | $161;
 
6425
      var $166 = $159 >>> ($161 >>> 0);
 
6426
      var $167 = $165 + $166 | 0;
 
6427
      var $168 = __gm_ + 304 + ($167 << 2) | 0;
 
6428
      var $169 = HEAP32[$168 >> 2];
 
6429
      var $170 = $169 + 4 | 0;
 
6430
      var $171 = HEAP32[$170 >> 2];
 
6431
      var $172 = $171 & -8;
 
6432
      var $173 = $172 - $8 | 0;
 
6433
      var $t_0_i = $169;
 
6434
      var $v_0_i = $169;
 
6435
      var $rsize_0_i = $173;
 
6436
      while (1) {
 
6437
        var $rsize_0_i;
 
6438
        var $v_0_i;
 
6439
        var $t_0_i;
 
6440
        var $175 = $t_0_i + 16 | 0;
 
6441
        var $176 = HEAP32[$175 >> 2];
 
6442
        var $177 = ($176 | 0) == 0;
 
6443
        if ($177) {
 
6444
          var $179 = $t_0_i + 20 | 0;
 
6445
          var $180 = HEAP32[$179 >> 2];
 
6446
          var $181 = ($180 | 0) == 0;
 
6447
          if ($181) {
 
6448
            break;
 
6449
          }
 
6450
          var $182 = $180;
 
6451
        } else {
 
6452
          var $182 = $176;
 
6453
        }
 
6454
        var $182;
 
6455
        var $183 = $182 + 4 | 0;
 
6456
        var $184 = HEAP32[$183 >> 2];
 
6457
        var $185 = $184 & -8;
 
6458
        var $186 = $185 - $8 | 0;
 
6459
        var $187 = $186 >>> 0 < $rsize_0_i >>> 0;
 
6460
        var $_rsize_0_i = $187 ? $186 : $rsize_0_i;
 
6461
        var $_v_0_i = $187 ? $182 : $v_0_i;
 
6462
        var $t_0_i = $182;
 
6463
        var $v_0_i = $_v_0_i;
 
6464
        var $rsize_0_i = $_rsize_0_i;
 
6465
      }
 
6466
      var $189 = $v_0_i;
 
6467
      var $190 = HEAP32[(__gm_ + 16 | 0) >> 2];
 
6468
      var $191 = $189 >>> 0 < $190 >>> 0;
 
6469
      do {
 
6470
        if (!$191) {
 
6471
          var $193 = $189 + $8 | 0;
 
6472
          var $194 = $193;
 
6473
          var $195 = $189 >>> 0 < $193 >>> 0;
 
6474
          if (!$195) {
 
6475
            break;
 
6476
          }
 
6477
          var $197 = $v_0_i + 24 | 0;
 
6478
          var $198 = HEAP32[$197 >> 2];
 
6479
          var $199 = $v_0_i + 12 | 0;
 
6480
          var $200 = HEAP32[$199 >> 2];
 
6481
          var $201 = ($200 | 0) == ($v_0_i | 0);
 
6482
          do {
 
6483
            if ($201) {
 
6484
              var $212 = $v_0_i + 20 | 0;
 
6485
              var $213 = HEAP32[$212 >> 2];
 
6486
              var $214 = ($213 | 0) == 0;
 
6487
              if ($214) {
 
6488
                var $216 = $v_0_i + 16 | 0;
 
6489
                var $217 = HEAP32[$216 >> 2];
 
6490
                var $218 = ($217 | 0) == 0;
 
6491
                if ($218) {
 
6492
                  var $R_1_i = 0;
 
6493
                  break;
 
6494
                }
 
6495
                var $RP_0_i = $216;
 
6496
                var $R_0_i = $217;
 
6497
              } else {
 
6498
                var $RP_0_i = $212;
 
6499
                var $R_0_i = $213;
 
6500
                __label__ = 39;
 
6501
              }
 
6502
              while (1) {
 
6503
                var $R_0_i;
 
6504
                var $RP_0_i;
 
6505
                var $219 = $R_0_i + 20 | 0;
 
6506
                var $220 = HEAP32[$219 >> 2];
 
6507
                var $221 = ($220 | 0) == 0;
 
6508
                if (!$221) {
 
6509
                  var $RP_0_i = $219;
 
6510
                  var $R_0_i = $220;
 
6511
                  continue;
 
6512
                }
 
6513
                var $223 = $R_0_i + 16 | 0;
 
6514
                var $224 = HEAP32[$223 >> 2];
 
6515
                var $225 = ($224 | 0) == 0;
 
6516
                if ($225) {
 
6517
                  break;
 
6518
                }
 
6519
                var $RP_0_i = $223;
 
6520
                var $R_0_i = $224;
 
6521
              }
 
6522
              var $227 = $RP_0_i;
 
6523
              var $228 = $227 >>> 0 < $190 >>> 0;
 
6524
              if ($228) {
 
6525
                _abort();
 
6526
              } else {
 
6527
                HEAP32[$RP_0_i >> 2] = 0;
 
6528
                var $R_1_i = $R_0_i;
 
6529
              }
 
6530
            } else {
 
6531
              var $203 = $v_0_i + 8 | 0;
 
6532
              var $204 = HEAP32[$203 >> 2];
 
6533
              var $205 = $204;
 
6534
              var $206 = $205 >>> 0 < $190 >>> 0;
 
6535
              if ($206) {
 
6536
                _abort();
 
6537
              } else {
 
6538
                var $208 = $204 + 12 | 0;
 
6539
                HEAP32[$208 >> 2] = $200;
 
6540
                var $209 = $200 + 8 | 0;
 
6541
                HEAP32[$209 >> 2] = $204;
 
6542
                var $R_1_i = $200;
 
6543
              }
 
6544
            }
 
6545
          } while (0);
 
6546
          var $R_1_i;
 
6547
          var $232 = ($198 | 0) == 0;
 
6548
          $_$62 : do {
 
6549
            if (!$232) {
 
6550
              var $234 = $v_0_i + 28 | 0;
 
6551
              var $235 = HEAP32[$234 >> 2];
 
6552
              var $236 = __gm_ + 304 + ($235 << 2) | 0;
 
6553
              var $237 = HEAP32[$236 >> 2];
 
6554
              var $238 = ($v_0_i | 0) == ($237 | 0);
 
6555
              do {
 
6556
                if ($238) {
 
6557
                  HEAP32[$236 >> 2] = $R_1_i;
 
6558
                  var $cond_i = ($R_1_i | 0) == 0;
 
6559
                  if (!$cond_i) {
 
6560
                    break;
 
6561
                  }
 
6562
                  var $240 = HEAP32[$234 >> 2];
 
6563
                  var $241 = 1 << $240;
 
6564
                  var $242 = $241 ^ -1;
 
6565
                  var $243 = HEAP32[(__gm_ + 4 | 0) >> 2];
 
6566
                  var $244 = $243 & $242;
 
6567
                  HEAP32[(__gm_ + 4 | 0) >> 2] = $244;
 
6568
                  break $_$62;
 
6569
                }
 
6570
                var $246 = $198;
 
6571
                var $247 = HEAP32[(__gm_ + 16 | 0) >> 2];
 
6572
                var $248 = $246 >>> 0 < $247 >>> 0;
 
6573
                if ($248) {
 
6574
                  _abort();
 
6575
                } else {
 
6576
                  var $250 = $198 + 16 | 0;
 
6577
                  var $251 = HEAP32[$250 >> 2];
 
6578
                  var $252 = ($251 | 0) == ($v_0_i | 0);
 
6579
                  if ($252) {
 
6580
                    HEAP32[$250 >> 2] = $R_1_i;
 
6581
                  } else {
 
6582
                    var $255 = $198 + 20 | 0;
 
6583
                    HEAP32[$255 >> 2] = $R_1_i;
 
6584
                  }
 
6585
                  var $258 = ($R_1_i | 0) == 0;
 
6586
                  if ($258) {
 
6587
                    break $_$62;
 
6588
                  }
 
6589
                }
 
6590
              } while (0);
 
6591
              var $260 = $R_1_i;
 
6592
              var $261 = HEAP32[(__gm_ + 16 | 0) >> 2];
 
6593
              var $262 = $260 >>> 0 < $261 >>> 0;
 
6594
              if ($262) {
 
6595
                _abort();
 
6596
              } else {
 
6597
                var $264 = $R_1_i + 24 | 0;
 
6598
                HEAP32[$264 >> 2] = $198;
 
6599
                var $265 = $v_0_i + 16 | 0;
 
6600
                var $266 = HEAP32[$265 >> 2];
 
6601
                var $267 = ($266 | 0) == 0;
 
6602
                if (!$267) {
 
6603
                  var $269 = $266;
 
6604
                  var $270 = HEAP32[(__gm_ + 16 | 0) >> 2];
 
6605
                  var $271 = $269 >>> 0 < $270 >>> 0;
 
6606
                  if ($271) {
 
6607
                    _abort();
 
6608
                  } else {
 
6609
                    var $273 = $R_1_i + 16 | 0;
 
6610
                    HEAP32[$273 >> 2] = $266;
 
6611
                    var $274 = $266 + 24 | 0;
 
6612
                    HEAP32[$274 >> 2] = $R_1_i;
 
6613
                  }
 
6614
                }
 
6615
                var $277 = $v_0_i + 20 | 0;
 
6616
                var $278 = HEAP32[$277 >> 2];
 
6617
                var $279 = ($278 | 0) == 0;
 
6618
                if ($279) {
 
6619
                  break;
 
6620
                }
 
6621
                var $281 = $278;
 
6622
                var $282 = HEAP32[(__gm_ + 16 | 0) >> 2];
 
6623
                var $283 = $281 >>> 0 < $282 >>> 0;
 
6624
                if ($283) {
 
6625
                  _abort();
 
6626
                } else {
 
6627
                  var $285 = $R_1_i + 20 | 0;
 
6628
                  HEAP32[$285 >> 2] = $278;
 
6629
                  var $286 = $278 + 24 | 0;
 
6630
                  HEAP32[$286 >> 2] = $R_1_i;
 
6631
                }
 
6632
              }
 
6633
            }
 
6634
          } while (0);
 
6635
          var $290 = $rsize_0_i >>> 0 < 16;
 
6636
          if ($290) {
 
6637
            var $292 = $rsize_0_i + $8 | 0;
 
6638
            var $293 = $292 | 3;
 
6639
            var $294 = $v_0_i + 4 | 0;
 
6640
            HEAP32[$294 >> 2] = $293;
 
6641
            var $_sum4_i = $292 + 4 | 0;
 
6642
            var $295 = $189 + $_sum4_i | 0;
 
6643
            var $296 = $295;
 
6644
            var $297 = HEAP32[$296 >> 2];
 
6645
            var $298 = $297 | 1;
 
6646
            HEAP32[$296 >> 2] = $298;
 
6647
          } else {
 
6648
            var $300 = $8 | 3;
 
6649
            var $301 = $v_0_i + 4 | 0;
 
6650
            HEAP32[$301 >> 2] = $300;
 
6651
            var $302 = $rsize_0_i | 1;
 
6652
            var $_sum_i33 = $8 | 4;
 
6653
            var $303 = $189 + $_sum_i33 | 0;
 
6654
            var $304 = $303;
 
6655
            HEAP32[$304 >> 2] = $302;
 
6656
            var $_sum1_i = $rsize_0_i + $8 | 0;
 
6657
            var $305 = $189 + $_sum1_i | 0;
 
6658
            var $306 = $305;
 
6659
            HEAP32[$306 >> 2] = $rsize_0_i;
 
6660
            var $307 = HEAP32[(__gm_ + 8 | 0) >> 2];
 
6661
            var $308 = ($307 | 0) == 0;
 
6662
            if (!$308) {
 
6663
              var $310 = HEAP32[(__gm_ + 20 | 0) >> 2];
 
6664
              var $311 = $307 >>> 3;
 
6665
              var $312 = $307 >>> 2;
 
6666
              var $313 = $312 & 1073741822;
 
6667
              var $314 = __gm_ + 40 + ($313 << 2) | 0;
 
6668
              var $315 = $314;
 
6669
              var $316 = HEAP32[(__gm_ | 0) >> 2];
 
6670
              var $317 = 1 << $311;
 
6671
              var $318 = $316 & $317;
 
6672
              var $319 = ($318 | 0) == 0;
 
6673
              do {
 
6674
                if ($319) {
 
6675
                  var $321 = $316 | $317;
 
6676
                  HEAP32[(__gm_ | 0) >> 2] = $321;
 
6677
                  var $_sum2_pre_i = $313 + 2 | 0;
 
6678
                  var $_pre_i = __gm_ + 40 + ($_sum2_pre_i << 2) | 0;
 
6679
                  var $F1_0_i = $315;
 
6680
                  var $_pre_phi_i = $_pre_i;
 
6681
                } else {
 
6682
                  var $_sum3_i = $313 + 2 | 0;
 
6683
                  var $323 = __gm_ + 40 + ($_sum3_i << 2) | 0;
 
6684
                  var $324 = HEAP32[$323 >> 2];
 
6685
                  var $325 = $324;
 
6686
                  var $326 = HEAP32[(__gm_ + 16 | 0) >> 2];
 
6687
                  var $327 = $325 >>> 0 < $326 >>> 0;
 
6688
                  if (!$327) {
 
6689
                    var $F1_0_i = $324;
 
6690
                    var $_pre_phi_i = $323;
 
6691
                    break;
 
6692
                  }
 
6693
                  _abort();
 
6694
                }
 
6695
              } while (0);
 
6696
              var $_pre_phi_i;
 
6697
              var $F1_0_i;
 
6698
              HEAP32[$_pre_phi_i >> 2] = $310;
 
6699
              var $330 = $F1_0_i + 12 | 0;
 
6700
              HEAP32[$330 >> 2] = $310;
 
6701
              var $331 = $310 + 8 | 0;
 
6702
              HEAP32[$331 >> 2] = $F1_0_i;
 
6703
              var $332 = $310 + 12 | 0;
 
6704
              HEAP32[$332 >> 2] = $315;
 
6705
            }
 
6706
            HEAP32[(__gm_ + 8 | 0) >> 2] = $rsize_0_i;
 
6707
            HEAP32[(__gm_ + 20 | 0) >> 2] = $194;
 
6708
          }
 
6709
          var $335 = $v_0_i + 8 | 0;
 
6710
          var $336 = $335;
 
6711
          var $337 = ($335 | 0) == 0;
 
6712
          if ($337) {
 
6713
            var $nb_0 = $8;
 
6714
            __label__ = 155;
 
6715
            break $_$2;
 
6716
          }
 
6717
          var $mem_0 = $336;
 
6718
          __label__ = 331;
 
6719
          break $_$2;
 
6720
        }
 
6721
      } while (0);
 
6722
      _abort();
 
6723
    } else {
 
6724
      var $339 = $bytes >>> 0 > 4294967231;
 
6725
      if ($339) {
 
6726
        var $nb_0 = -1;
 
6727
        __label__ = 155;
 
6728
        break;
 
6729
      }
 
6730
      var $341 = $bytes + 11 | 0;
 
6731
      var $342 = $341 & -8;
 
6732
      var $343 = HEAP32[(__gm_ + 4 | 0) >> 2];
 
6733
      var $344 = ($343 | 0) == 0;
 
6734
      if ($344) {
 
6735
        var $nb_0 = $342;
 
6736
        __label__ = 155;
 
6737
        break;
 
6738
      }
 
6739
      var $346 = -$342 | 0;
 
6740
      var $347 = $341 >>> 8;
 
6741
      var $348 = ($347 | 0) == 0;
 
6742
      do {
 
6743
        if ($348) {
 
6744
          var $idx_0_i = 0;
 
6745
        } else {
 
6746
          var $350 = $342 >>> 0 > 16777215;
 
6747
          if ($350) {
 
6748
            var $idx_0_i = 31;
 
6749
            break;
 
6750
          }
 
6751
          var $352 = $347 + 1048320 | 0;
 
6752
          var $353 = $352 >>> 16;
 
6753
          var $354 = $353 & 8;
 
6754
          var $355 = $347 << $354;
 
6755
          var $356 = $355 + 520192 | 0;
 
6756
          var $357 = $356 >>> 16;
 
6757
          var $358 = $357 & 4;
 
6758
          var $359 = $355 << $358;
 
6759
          var $360 = $359 + 245760 | 0;
 
6760
          var $361 = $360 >>> 16;
 
6761
          var $362 = $361 & 2;
 
6762
          var $363 = $358 | $354;
 
6763
          var $364 = $363 | $362;
 
6764
          var $365 = 14 - $364 | 0;
 
6765
          var $366 = $359 << $362;
 
6766
          var $367 = $366 >>> 15;
 
6767
          var $368 = $365 + $367 | 0;
 
6768
          var $369 = $368 << 1;
 
6769
          var $370 = $368 + 7 | 0;
 
6770
          var $371 = $342 >>> ($370 >>> 0);
 
6771
          var $372 = $371 & 1;
 
6772
          var $373 = $372 | $369;
 
6773
          var $idx_0_i = $373;
 
6774
        }
 
6775
      } while (0);
 
6776
      var $idx_0_i;
 
6777
      var $375 = __gm_ + 304 + ($idx_0_i << 2) | 0;
 
6778
      var $376 = HEAP32[$375 >> 2];
 
6779
      var $377 = ($376 | 0) == 0;
 
6780
      $_$110 : do {
 
6781
        if ($377) {
 
6782
          var $v_2_i = 0;
 
6783
          var $rsize_2_i = $346;
 
6784
          var $t_1_i = 0;
 
6785
        } else {
 
6786
          var $379 = ($idx_0_i | 0) == 31;
 
6787
          if ($379) {
 
6788
            var $384 = 0;
 
6789
          } else {
 
6790
            var $381 = $idx_0_i >>> 1;
 
6791
            var $382 = 25 - $381 | 0;
 
6792
            var $384 = $382;
 
6793
          }
 
6794
          var $384;
 
6795
          var $385 = $342 << $384;
 
6796
          var $v_0_i15 = 0;
 
6797
          var $rsize_0_i14 = $346;
 
6798
          var $t_0_i13 = $376;
 
6799
          var $sizebits_0_i = $385;
 
6800
          var $rst_0_i = 0;
 
6801
          while (1) {
 
6802
            var $rst_0_i;
 
6803
            var $sizebits_0_i;
 
6804
            var $t_0_i13;
 
6805
            var $rsize_0_i14;
 
6806
            var $v_0_i15;
 
6807
            var $387 = $t_0_i13 + 4 | 0;
 
6808
            var $388 = HEAP32[$387 >> 2];
 
6809
            var $389 = $388 & -8;
 
6810
            var $390 = $389 - $342 | 0;
 
6811
            var $391 = $390 >>> 0 < $rsize_0_i14 >>> 0;
 
6812
            if ($391) {
 
6813
              var $393 = ($389 | 0) == ($342 | 0);
 
6814
              if ($393) {
 
6815
                var $v_2_i = $t_0_i13;
 
6816
                var $rsize_2_i = $390;
 
6817
                var $t_1_i = $t_0_i13;
 
6818
                break $_$110;
 
6819
              }
 
6820
              var $v_1_i = $t_0_i13;
 
6821
              var $rsize_1_i = $390;
 
6822
            } else {
 
6823
              var $v_1_i = $v_0_i15;
 
6824
              var $rsize_1_i = $rsize_0_i14;
 
6825
            }
 
6826
            var $rsize_1_i;
 
6827
            var $v_1_i;
 
6828
            var $395 = $t_0_i13 + 20 | 0;
 
6829
            var $396 = HEAP32[$395 >> 2];
 
6830
            var $397 = $sizebits_0_i >>> 31;
 
6831
            var $398 = $t_0_i13 + 16 + ($397 << 2) | 0;
 
6832
            var $399 = HEAP32[$398 >> 2];
 
6833
            var $400 = ($396 | 0) == 0;
 
6834
            var $401 = ($396 | 0) == ($399 | 0);
 
6835
            var $or_cond_i = $400 | $401;
 
6836
            var $rst_1_i = $or_cond_i ? $rst_0_i : $396;
 
6837
            var $402 = ($399 | 0) == 0;
 
6838
            var $403 = $sizebits_0_i << 1;
 
6839
            if ($402) {
 
6840
              var $v_2_i = $v_1_i;
 
6841
              var $rsize_2_i = $rsize_1_i;
 
6842
              var $t_1_i = $rst_1_i;
 
6843
              break $_$110;
 
6844
            }
 
6845
            var $v_0_i15 = $v_1_i;
 
6846
            var $rsize_0_i14 = $rsize_1_i;
 
6847
            var $t_0_i13 = $399;
 
6848
            var $sizebits_0_i = $403;
 
6849
            var $rst_0_i = $rst_1_i;
 
6850
          }
 
6851
        }
 
6852
      } while (0);
 
6853
      var $t_1_i;
 
6854
      var $rsize_2_i;
 
6855
      var $v_2_i;
 
6856
      var $404 = ($t_1_i | 0) == 0;
 
6857
      var $405 = ($v_2_i | 0) == 0;
 
6858
      var $or_cond19_i = $404 & $405;
 
6859
      if ($or_cond19_i) {
 
6860
        var $407 = 2 << $idx_0_i;
 
6861
        var $408 = -$407 | 0;
 
6862
        var $409 = $407 | $408;
 
6863
        var $410 = $343 & $409;
 
6864
        var $411 = ($410 | 0) == 0;
 
6865
        if ($411) {
 
6866
          var $nb_0 = $342;
 
6867
          __label__ = 155;
 
6868
          break;
 
6869
        }
 
6870
        var $413 = -$410 | 0;
 
6871
        var $414 = $410 & $413;
 
6872
        var $415 = $414 - 1 | 0;
 
6873
        var $416 = $415 >>> 12;
 
6874
        var $417 = $416 & 16;
 
6875
        var $418 = $415 >>> ($417 >>> 0);
 
6876
        var $419 = $418 >>> 5;
 
6877
        var $420 = $419 & 8;
 
6878
        var $421 = $418 >>> ($420 >>> 0);
 
6879
        var $422 = $421 >>> 2;
 
6880
        var $423 = $422 & 4;
 
6881
        var $424 = $421 >>> ($423 >>> 0);
 
6882
        var $425 = $424 >>> 1;
 
6883
        var $426 = $425 & 2;
 
6884
        var $427 = $424 >>> ($426 >>> 0);
 
6885
        var $428 = $427 >>> 1;
 
6886
        var $429 = $428 & 1;
 
6887
        var $430 = $420 | $417;
 
6888
        var $431 = $430 | $423;
 
6889
        var $432 = $431 | $426;
 
6890
        var $433 = $432 | $429;
 
6891
        var $434 = $427 >>> ($429 >>> 0);
 
6892
        var $435 = $433 + $434 | 0;
 
6893
        var $436 = __gm_ + 304 + ($435 << 2) | 0;
 
6894
        var $437 = HEAP32[$436 >> 2];
 
6895
        var $t_2_ph_i = $437;
 
6896
      } else {
 
6897
        var $t_2_ph_i = $t_1_i;
 
6898
      }
 
6899
      var $t_2_ph_i;
 
6900
      var $438 = ($t_2_ph_i | 0) == 0;
 
6901
      $_$125 : do {
 
6902
        if ($438) {
 
6903
          var $rsize_3_lcssa_i = $rsize_2_i;
 
6904
          var $v_3_lcssa_i = $v_2_i;
 
6905
        } else {
 
6906
          var $t_224_i = $t_2_ph_i;
 
6907
          var $rsize_325_i = $rsize_2_i;
 
6908
          var $v_326_i = $v_2_i;
 
6909
          while (1) {
 
6910
            var $v_326_i;
 
6911
            var $rsize_325_i;
 
6912
            var $t_224_i;
 
6913
            var $439 = $t_224_i + 4 | 0;
 
6914
            var $440 = HEAP32[$439 >> 2];
 
6915
            var $441 = $440 & -8;
 
6916
            var $442 = $441 - $342 | 0;
 
6917
            var $443 = $442 >>> 0 < $rsize_325_i >>> 0;
 
6918
            var $_rsize_3_i = $443 ? $442 : $rsize_325_i;
 
6919
            var $t_2_v_3_i = $443 ? $t_224_i : $v_326_i;
 
6920
            var $444 = $t_224_i + 16 | 0;
 
6921
            var $445 = HEAP32[$444 >> 2];
 
6922
            var $446 = ($445 | 0) == 0;
 
6923
            if (!$446) {
 
6924
              var $t_224_i = $445;
 
6925
              var $rsize_325_i = $_rsize_3_i;
 
6926
              var $v_326_i = $t_2_v_3_i;
 
6927
              continue;
 
6928
            }
 
6929
            var $447 = $t_224_i + 20 | 0;
 
6930
            var $448 = HEAP32[$447 >> 2];
 
6931
            var $449 = ($448 | 0) == 0;
 
6932
            if ($449) {
 
6933
              var $rsize_3_lcssa_i = $_rsize_3_i;
 
6934
              var $v_3_lcssa_i = $t_2_v_3_i;
 
6935
              break $_$125;
 
6936
            }
 
6937
            var $t_224_i = $448;
 
6938
            var $rsize_325_i = $_rsize_3_i;
 
6939
            var $v_326_i = $t_2_v_3_i;
 
6940
          }
 
6941
        }
 
6942
      } while (0);
 
6943
      var $v_3_lcssa_i;
 
6944
      var $rsize_3_lcssa_i;
 
6945
      var $450 = ($v_3_lcssa_i | 0) == 0;
 
6946
      if ($450) {
 
6947
        var $nb_0 = $342;
 
6948
        __label__ = 155;
 
6949
        break;
 
6950
      }
 
6951
      var $452 = HEAP32[(__gm_ + 8 | 0) >> 2];
 
6952
      var $453 = $452 - $342 | 0;
 
6953
      var $454 = $rsize_3_lcssa_i >>> 0 < $453 >>> 0;
 
6954
      if (!$454) {
 
6955
        var $nb_0 = $342;
 
6956
        __label__ = 155;
 
6957
        break;
 
6958
      }
 
6959
      var $456 = $v_3_lcssa_i;
 
6960
      var $457 = HEAP32[(__gm_ + 16 | 0) >> 2];
 
6961
      var $458 = $456 >>> 0 < $457 >>> 0;
 
6962
      do {
 
6963
        if (!$458) {
 
6964
          var $460 = $456 + $342 | 0;
 
6965
          var $461 = $460;
 
6966
          var $462 = $456 >>> 0 < $460 >>> 0;
 
6967
          if (!$462) {
 
6968
            break;
 
6969
          }
 
6970
          var $464 = $v_3_lcssa_i + 24 | 0;
 
6971
          var $465 = HEAP32[$464 >> 2];
 
6972
          var $466 = $v_3_lcssa_i + 12 | 0;
 
6973
          var $467 = HEAP32[$466 >> 2];
 
6974
          var $468 = ($467 | 0) == ($v_3_lcssa_i | 0);
 
6975
          do {
 
6976
            if ($468) {
 
6977
              var $479 = $v_3_lcssa_i + 20 | 0;
 
6978
              var $480 = HEAP32[$479 >> 2];
 
6979
              var $481 = ($480 | 0) == 0;
 
6980
              if ($481) {
 
6981
                var $483 = $v_3_lcssa_i + 16 | 0;
 
6982
                var $484 = HEAP32[$483 >> 2];
 
6983
                var $485 = ($484 | 0) == 0;
 
6984
                if ($485) {
 
6985
                  var $R_1_i19 = 0;
 
6986
                  break;
 
6987
                }
 
6988
                var $RP_0_i17 = $483;
 
6989
                var $R_0_i16 = $484;
 
6990
              } else {
 
6991
                var $RP_0_i17 = $479;
 
6992
                var $R_0_i16 = $480;
 
6993
                __label__ = 103;
 
6994
              }
 
6995
              while (1) {
 
6996
                var $R_0_i16;
 
6997
                var $RP_0_i17;
 
6998
                var $486 = $R_0_i16 + 20 | 0;
 
6999
                var $487 = HEAP32[$486 >> 2];
 
7000
                var $488 = ($487 | 0) == 0;
 
7001
                if (!$488) {
 
7002
                  var $RP_0_i17 = $486;
 
7003
                  var $R_0_i16 = $487;
 
7004
                  continue;
 
7005
                }
 
7006
                var $490 = $R_0_i16 + 16 | 0;
 
7007
                var $491 = HEAP32[$490 >> 2];
 
7008
                var $492 = ($491 | 0) == 0;
 
7009
                if ($492) {
 
7010
                  break;
 
7011
                }
 
7012
                var $RP_0_i17 = $490;
 
7013
                var $R_0_i16 = $491;
 
7014
              }
 
7015
              var $494 = $RP_0_i17;
 
7016
              var $495 = $494 >>> 0 < $457 >>> 0;
 
7017
              if ($495) {
 
7018
                _abort();
 
7019
              } else {
 
7020
                HEAP32[$RP_0_i17 >> 2] = 0;
 
7021
                var $R_1_i19 = $R_0_i16;
 
7022
              }
 
7023
            } else {
 
7024
              var $470 = $v_3_lcssa_i + 8 | 0;
 
7025
              var $471 = HEAP32[$470 >> 2];
 
7026
              var $472 = $471;
 
7027
              var $473 = $472 >>> 0 < $457 >>> 0;
 
7028
              if ($473) {
 
7029
                _abort();
 
7030
              } else {
 
7031
                var $475 = $471 + 12 | 0;
 
7032
                HEAP32[$475 >> 2] = $467;
 
7033
                var $476 = $467 + 8 | 0;
 
7034
                HEAP32[$476 >> 2] = $471;
 
7035
                var $R_1_i19 = $467;
 
7036
              }
 
7037
            }
 
7038
          } while (0);
 
7039
          var $R_1_i19;
 
7040
          var $499 = ($465 | 0) == 0;
 
7041
          $_$151 : do {
 
7042
            if (!$499) {
 
7043
              var $501 = $v_3_lcssa_i + 28 | 0;
 
7044
              var $502 = HEAP32[$501 >> 2];
 
7045
              var $503 = __gm_ + 304 + ($502 << 2) | 0;
 
7046
              var $504 = HEAP32[$503 >> 2];
 
7047
              var $505 = ($v_3_lcssa_i | 0) == ($504 | 0);
 
7048
              do {
 
7049
                if ($505) {
 
7050
                  HEAP32[$503 >> 2] = $R_1_i19;
 
7051
                  var $cond_i20 = ($R_1_i19 | 0) == 0;
 
7052
                  if (!$cond_i20) {
 
7053
                    break;
 
7054
                  }
 
7055
                  var $507 = HEAP32[$501 >> 2];
 
7056
                  var $508 = 1 << $507;
 
7057
                  var $509 = $508 ^ -1;
 
7058
                  var $510 = HEAP32[(__gm_ + 4 | 0) >> 2];
 
7059
                  var $511 = $510 & $509;
 
7060
                  HEAP32[(__gm_ + 4 | 0) >> 2] = $511;
 
7061
                  break $_$151;
 
7062
                }
 
7063
                var $513 = $465;
 
7064
                var $514 = HEAP32[(__gm_ + 16 | 0) >> 2];
 
7065
                var $515 = $513 >>> 0 < $514 >>> 0;
 
7066
                if ($515) {
 
7067
                  _abort();
 
7068
                } else {
 
7069
                  var $517 = $465 + 16 | 0;
 
7070
                  var $518 = HEAP32[$517 >> 2];
 
7071
                  var $519 = ($518 | 0) == ($v_3_lcssa_i | 0);
 
7072
                  if ($519) {
 
7073
                    HEAP32[$517 >> 2] = $R_1_i19;
 
7074
                  } else {
 
7075
                    var $522 = $465 + 20 | 0;
 
7076
                    HEAP32[$522 >> 2] = $R_1_i19;
 
7077
                  }
 
7078
                  var $525 = ($R_1_i19 | 0) == 0;
 
7079
                  if ($525) {
 
7080
                    break $_$151;
 
7081
                  }
 
7082
                }
 
7083
              } while (0);
 
7084
              var $527 = $R_1_i19;
 
7085
              var $528 = HEAP32[(__gm_ + 16 | 0) >> 2];
 
7086
              var $529 = $527 >>> 0 < $528 >>> 0;
 
7087
              if ($529) {
 
7088
                _abort();
 
7089
              } else {
 
7090
                var $531 = $R_1_i19 + 24 | 0;
 
7091
                HEAP32[$531 >> 2] = $465;
 
7092
                var $532 = $v_3_lcssa_i + 16 | 0;
 
7093
                var $533 = HEAP32[$532 >> 2];
 
7094
                var $534 = ($533 | 0) == 0;
 
7095
                if (!$534) {
 
7096
                  var $536 = $533;
 
7097
                  var $537 = HEAP32[(__gm_ + 16 | 0) >> 2];
 
7098
                  var $538 = $536 >>> 0 < $537 >>> 0;
 
7099
                  if ($538) {
 
7100
                    _abort();
 
7101
                  } else {
 
7102
                    var $540 = $R_1_i19 + 16 | 0;
 
7103
                    HEAP32[$540 >> 2] = $533;
 
7104
                    var $541 = $533 + 24 | 0;
 
7105
                    HEAP32[$541 >> 2] = $R_1_i19;
 
7106
                  }
 
7107
                }
 
7108
                var $544 = $v_3_lcssa_i + 20 | 0;
 
7109
                var $545 = HEAP32[$544 >> 2];
 
7110
                var $546 = ($545 | 0) == 0;
 
7111
                if ($546) {
 
7112
                  break;
 
7113
                }
 
7114
                var $548 = $545;
 
7115
                var $549 = HEAP32[(__gm_ + 16 | 0) >> 2];
 
7116
                var $550 = $548 >>> 0 < $549 >>> 0;
 
7117
                if ($550) {
 
7118
                  _abort();
 
7119
                } else {
 
7120
                  var $552 = $R_1_i19 + 20 | 0;
 
7121
                  HEAP32[$552 >> 2] = $545;
 
7122
                  var $553 = $545 + 24 | 0;
 
7123
                  HEAP32[$553 >> 2] = $R_1_i19;
 
7124
                }
 
7125
              }
 
7126
            }
 
7127
          } while (0);
 
7128
          var $557 = $rsize_3_lcssa_i >>> 0 < 16;
 
7129
          $_$179 : do {
 
7130
            if ($557) {
 
7131
              var $559 = $rsize_3_lcssa_i + $342 | 0;
 
7132
              var $560 = $559 | 3;
 
7133
              var $561 = $v_3_lcssa_i + 4 | 0;
 
7134
              HEAP32[$561 >> 2] = $560;
 
7135
              var $_sum18_i = $559 + 4 | 0;
 
7136
              var $562 = $456 + $_sum18_i | 0;
 
7137
              var $563 = $562;
 
7138
              var $564 = HEAP32[$563 >> 2];
 
7139
              var $565 = $564 | 1;
 
7140
              HEAP32[$563 >> 2] = $565;
 
7141
            } else {
 
7142
              var $567 = $342 | 3;
 
7143
              var $568 = $v_3_lcssa_i + 4 | 0;
 
7144
              HEAP32[$568 >> 2] = $567;
 
7145
              var $569 = $rsize_3_lcssa_i | 1;
 
7146
              var $_sum_i2232 = $342 | 4;
 
7147
              var $570 = $456 + $_sum_i2232 | 0;
 
7148
              var $571 = $570;
 
7149
              HEAP32[$571 >> 2] = $569;
 
7150
              var $_sum1_i23 = $rsize_3_lcssa_i + $342 | 0;
 
7151
              var $572 = $456 + $_sum1_i23 | 0;
 
7152
              var $573 = $572;
 
7153
              HEAP32[$573 >> 2] = $rsize_3_lcssa_i;
 
7154
              var $574 = $rsize_3_lcssa_i >>> 0 < 256;
 
7155
              if ($574) {
 
7156
                var $576 = $rsize_3_lcssa_i >>> 3;
 
7157
                var $577 = $rsize_3_lcssa_i >>> 2;
 
7158
                var $578 = $577 & 1073741822;
 
7159
                var $579 = __gm_ + 40 + ($578 << 2) | 0;
 
7160
                var $580 = $579;
 
7161
                var $581 = HEAP32[(__gm_ | 0) >> 2];
 
7162
                var $582 = 1 << $576;
 
7163
                var $583 = $581 & $582;
 
7164
                var $584 = ($583 | 0) == 0;
 
7165
                do {
 
7166
                  if ($584) {
 
7167
                    var $586 = $581 | $582;
 
7168
                    HEAP32[(__gm_ | 0) >> 2] = $586;
 
7169
                    var $_sum14_pre_i = $578 + 2 | 0;
 
7170
                    var $_pre_i24 = __gm_ + 40 + ($_sum14_pre_i << 2) | 0;
 
7171
                    var $F5_0_i = $580;
 
7172
                    var $_pre_phi_i25 = $_pre_i24;
 
7173
                  } else {
 
7174
                    var $_sum17_i = $578 + 2 | 0;
 
7175
                    var $588 = __gm_ + 40 + ($_sum17_i << 2) | 0;
 
7176
                    var $589 = HEAP32[$588 >> 2];
 
7177
                    var $590 = $589;
 
7178
                    var $591 = HEAP32[(__gm_ + 16 | 0) >> 2];
 
7179
                    var $592 = $590 >>> 0 < $591 >>> 0;
 
7180
                    if (!$592) {
 
7181
                      var $F5_0_i = $589;
 
7182
                      var $_pre_phi_i25 = $588;
 
7183
                      break;
 
7184
                    }
 
7185
                    _abort();
 
7186
                  }
 
7187
                } while (0);
 
7188
                var $_pre_phi_i25;
 
7189
                var $F5_0_i;
 
7190
                HEAP32[$_pre_phi_i25 >> 2] = $461;
 
7191
                var $595 = $F5_0_i + 12 | 0;
 
7192
                HEAP32[$595 >> 2] = $461;
 
7193
                var $_sum15_i = $342 + 8 | 0;
 
7194
                var $596 = $456 + $_sum15_i | 0;
 
7195
                var $597 = $596;
 
7196
                HEAP32[$597 >> 2] = $F5_0_i;
 
7197
                var $_sum16_i = $342 + 12 | 0;
 
7198
                var $598 = $456 + $_sum16_i | 0;
 
7199
                var $599 = $598;
 
7200
                HEAP32[$599 >> 2] = $580;
 
7201
              } else {
 
7202
                var $601 = $460;
 
7203
                var $602 = $rsize_3_lcssa_i >>> 8;
 
7204
                var $603 = ($602 | 0) == 0;
 
7205
                do {
 
7206
                  if ($603) {
 
7207
                    var $I7_0_i = 0;
 
7208
                  } else {
 
7209
                    var $605 = $rsize_3_lcssa_i >>> 0 > 16777215;
 
7210
                    if ($605) {
 
7211
                      var $I7_0_i = 31;
 
7212
                      break;
 
7213
                    }
 
7214
                    var $607 = $602 + 1048320 | 0;
 
7215
                    var $608 = $607 >>> 16;
 
7216
                    var $609 = $608 & 8;
 
7217
                    var $610 = $602 << $609;
 
7218
                    var $611 = $610 + 520192 | 0;
 
7219
                    var $612 = $611 >>> 16;
 
7220
                    var $613 = $612 & 4;
 
7221
                    var $614 = $610 << $613;
 
7222
                    var $615 = $614 + 245760 | 0;
 
7223
                    var $616 = $615 >>> 16;
 
7224
                    var $617 = $616 & 2;
 
7225
                    var $618 = $613 | $609;
 
7226
                    var $619 = $618 | $617;
 
7227
                    var $620 = 14 - $619 | 0;
 
7228
                    var $621 = $614 << $617;
 
7229
                    var $622 = $621 >>> 15;
 
7230
                    var $623 = $620 + $622 | 0;
 
7231
                    var $624 = $623 << 1;
 
7232
                    var $625 = $623 + 7 | 0;
 
7233
                    var $626 = $rsize_3_lcssa_i >>> ($625 >>> 0);
 
7234
                    var $627 = $626 & 1;
 
7235
                    var $628 = $627 | $624;
 
7236
                    var $I7_0_i = $628;
 
7237
                  }
 
7238
                } while (0);
 
7239
                var $I7_0_i;
 
7240
                var $630 = __gm_ + 304 + ($I7_0_i << 2) | 0;
 
7241
                var $_sum2_i = $342 + 28 | 0;
 
7242
                var $631 = $456 + $_sum2_i | 0;
 
7243
                var $632 = $631;
 
7244
                HEAP32[$632 >> 2] = $I7_0_i;
 
7245
                var $_sum3_i26 = $342 + 16 | 0;
 
7246
                var $633 = $456 + $_sum3_i26 | 0;
 
7247
                var $_sum4_i27 = $342 + 20 | 0;
 
7248
                var $634 = $456 + $_sum4_i27 | 0;
 
7249
                var $635 = $634;
 
7250
                HEAP32[$635 >> 2] = 0;
 
7251
                var $636 = $633;
 
7252
                HEAP32[$636 >> 2] = 0;
 
7253
                var $637 = HEAP32[(__gm_ + 4 | 0) >> 2];
 
7254
                var $638 = 1 << $I7_0_i;
 
7255
                var $639 = $637 & $638;
 
7256
                var $640 = ($639 | 0) == 0;
 
7257
                if ($640) {
 
7258
                  var $642 = $637 | $638;
 
7259
                  HEAP32[(__gm_ + 4 | 0) >> 2] = $642;
 
7260
                  HEAP32[$630 >> 2] = $601;
 
7261
                  var $643 = $630;
 
7262
                  var $_sum5_i = $342 + 24 | 0;
 
7263
                  var $644 = $456 + $_sum5_i | 0;
 
7264
                  var $645 = $644;
 
7265
                  HEAP32[$645 >> 2] = $643;
 
7266
                  var $_sum6_i = $342 + 12 | 0;
 
7267
                  var $646 = $456 + $_sum6_i | 0;
 
7268
                  var $647 = $646;
 
7269
                  HEAP32[$647 >> 2] = $601;
 
7270
                  var $_sum7_i = $342 + 8 | 0;
 
7271
                  var $648 = $456 + $_sum7_i | 0;
 
7272
                  var $649 = $648;
 
7273
                  HEAP32[$649 >> 2] = $601;
 
7274
                } else {
 
7275
                  var $651 = HEAP32[$630 >> 2];
 
7276
                  var $652 = ($I7_0_i | 0) == 31;
 
7277
                  if ($652) {
 
7278
                    var $657 = 0;
 
7279
                  } else {
 
7280
                    var $654 = $I7_0_i >>> 1;
 
7281
                    var $655 = 25 - $654 | 0;
 
7282
                    var $657 = $655;
 
7283
                  }
 
7284
                  var $657;
 
7285
                  var $658 = $rsize_3_lcssa_i << $657;
 
7286
                  var $K12_0_i = $658;
 
7287
                  var $T_0_i = $651;
 
7288
                  while (1) {
 
7289
                    var $T_0_i;
 
7290
                    var $K12_0_i;
 
7291
                    var $660 = $T_0_i + 4 | 0;
 
7292
                    var $661 = HEAP32[$660 >> 2];
 
7293
                    var $662 = $661 & -8;
 
7294
                    var $663 = ($662 | 0) == ($rsize_3_lcssa_i | 0);
 
7295
                    if ($663) {
 
7296
                      var $683 = $T_0_i + 8 | 0;
 
7297
                      var $684 = HEAP32[$683 >> 2];
 
7298
                      var $685 = $T_0_i;
 
7299
                      var $686 = HEAP32[(__gm_ + 16 | 0) >> 2];
 
7300
                      var $687 = $685 >>> 0 < $686 >>> 0;
 
7301
                      do {
 
7302
                        if (!$687) {
 
7303
                          var $689 = $684;
 
7304
                          var $690 = $689 >>> 0 < $686 >>> 0;
 
7305
                          if ($690) {
 
7306
                            break;
 
7307
                          }
 
7308
                          var $692 = $684 + 12 | 0;
 
7309
                          HEAP32[$692 >> 2] = $601;
 
7310
                          HEAP32[$683 >> 2] = $601;
 
7311
                          var $_sum8_i = $342 + 8 | 0;
 
7312
                          var $693 = $456 + $_sum8_i | 0;
 
7313
                          var $694 = $693;
 
7314
                          HEAP32[$694 >> 2] = $684;
 
7315
                          var $_sum9_i = $342 + 12 | 0;
 
7316
                          var $695 = $456 + $_sum9_i | 0;
 
7317
                          var $696 = $695;
 
7318
                          HEAP32[$696 >> 2] = $T_0_i;
 
7319
                          var $_sum10_i = $342 + 24 | 0;
 
7320
                          var $697 = $456 + $_sum10_i | 0;
 
7321
                          var $698 = $697;
 
7322
                          HEAP32[$698 >> 2] = 0;
 
7323
                          break $_$179;
 
7324
                        }
 
7325
                      } while (0);
 
7326
                      _abort();
 
7327
                    } else {
 
7328
                      var $665 = $K12_0_i >>> 31;
 
7329
                      var $666 = $T_0_i + 16 + ($665 << 2) | 0;
 
7330
                      var $667 = HEAP32[$666 >> 2];
 
7331
                      var $668 = ($667 | 0) == 0;
 
7332
                      var $669 = $K12_0_i << 1;
 
7333
                      if (!$668) {
 
7334
                        var $K12_0_i = $669;
 
7335
                        var $T_0_i = $667;
 
7336
                        continue;
 
7337
                      }
 
7338
                      var $671 = $666;
 
7339
                      var $672 = HEAP32[(__gm_ + 16 | 0) >> 2];
 
7340
                      var $673 = $671 >>> 0 < $672 >>> 0;
 
7341
                      if (!$673) {
 
7342
                        HEAP32[$666 >> 2] = $601;
 
7343
                        var $_sum11_i = $342 + 24 | 0;
 
7344
                        var $675 = $456 + $_sum11_i | 0;
 
7345
                        var $676 = $675;
 
7346
                        HEAP32[$676 >> 2] = $T_0_i;
 
7347
                        var $_sum12_i = $342 + 12 | 0;
 
7348
                        var $677 = $456 + $_sum12_i | 0;
 
7349
                        var $678 = $677;
 
7350
                        HEAP32[$678 >> 2] = $601;
 
7351
                        var $_sum13_i = $342 + 8 | 0;
 
7352
                        var $679 = $456 + $_sum13_i | 0;
 
7353
                        var $680 = $679;
 
7354
                        HEAP32[$680 >> 2] = $601;
 
7355
                        break $_$179;
 
7356
                      }
 
7357
                      _abort();
 
7358
                    }
 
7359
                  }
 
7360
                }
 
7361
              }
 
7362
            }
 
7363
          } while (0);
 
7364
          var $700 = $v_3_lcssa_i + 8 | 0;
 
7365
          var $701 = $700;
 
7366
          var $702 = ($700 | 0) == 0;
 
7367
          if ($702) {
 
7368
            var $nb_0 = $342;
 
7369
            __label__ = 155;
 
7370
            break $_$2;
 
7371
          }
 
7372
          var $mem_0 = $701;
 
7373
          __label__ = 331;
 
7374
          break $_$2;
 
7375
        }
 
7376
      } while (0);
 
7377
      _abort();
 
7378
    }
 
7379
  } while (0);
 
7380
  $_$215 : do {
 
7381
    if (__label__ == 155) {
 
7382
      var $nb_0;
 
7383
      var $703 = HEAP32[(__gm_ + 8 | 0) >> 2];
 
7384
      var $704 = $nb_0 >>> 0 > $703 >>> 0;
 
7385
      if ($704) {
 
7386
        var $732 = HEAP32[(__gm_ + 12 | 0) >> 2];
 
7387
        var $733 = $nb_0 >>> 0 < $732 >>> 0;
 
7388
        if ($733) {
 
7389
          var $735 = $732 - $nb_0 | 0;
 
7390
          HEAP32[(__gm_ + 12 | 0) >> 2] = $735;
 
7391
          var $736 = HEAP32[(__gm_ + 24 | 0) >> 2];
 
7392
          var $737 = $736;
 
7393
          var $738 = $737 + $nb_0 | 0;
 
7394
          var $739 = $738;
 
7395
          HEAP32[(__gm_ + 24 | 0) >> 2] = $739;
 
7396
          var $740 = $735 | 1;
 
7397
          var $_sum = $nb_0 + 4 | 0;
 
7398
          var $741 = $737 + $_sum | 0;
 
7399
          var $742 = $741;
 
7400
          HEAP32[$742 >> 2] = $740;
 
7401
          var $743 = $nb_0 | 3;
 
7402
          var $744 = $736 + 4 | 0;
 
7403
          HEAP32[$744 >> 2] = $743;
 
7404
          var $745 = $736 + 8 | 0;
 
7405
          var $746 = $745;
 
7406
          var $mem_0 = $746;
 
7407
        } else {
 
7408
          var $748 = HEAP32[(_mparams | 0) >> 2];
 
7409
          var $749 = ($748 | 0) == 0;
 
7410
          do {
 
7411
            if ($749) {
 
7412
              var $751 = HEAP32[(_mparams | 0) >> 2];
 
7413
              var $752 = ($751 | 0) == 0;
 
7414
              if (!$752) {
 
7415
                break;
 
7416
              }
 
7417
              var $754 = _sysconf(8);
 
7418
              var $755 = $754 - 1 | 0;
 
7419
              var $756 = $755 & $754;
 
7420
              var $757 = ($756 | 0) == 0;
 
7421
              if ($757) {
 
7422
                HEAP32[(_mparams + 8 | 0) >> 2] = $754;
 
7423
                HEAP32[(_mparams + 4 | 0) >> 2] = $754;
 
7424
                HEAP32[(_mparams + 12 | 0) >> 2] = -1;
 
7425
                HEAP32[(_mparams + 16 | 0) >> 2] = 2097152;
 
7426
                HEAP32[(_mparams + 20 | 0) >> 2] = 0;
 
7427
                HEAP32[(__gm_ + 440 | 0) >> 2] = 0;
 
7428
                var $760 = _time(0);
 
7429
                var $761 = $760 & -16;
 
7430
                var $762 = $761 ^ 1431655768;
 
7431
                HEAP32[(_mparams | 0) >> 2] = $762;
 
7432
              } else {
 
7433
                _abort();
 
7434
              }
 
7435
            }
 
7436
          } while (0);
 
7437
          var $763 = HEAP32[(__gm_ + 440 | 0) >> 2];
 
7438
          var $764 = $763 & 4;
 
7439
          var $765 = ($764 | 0) == 0;
 
7440
          $_$234 : do {
 
7441
            if ($765) {
 
7442
              var $767 = HEAP32[(__gm_ + 24 | 0) >> 2];
 
7443
              var $768 = ($767 | 0) == 0;
 
7444
              $_$236 : do {
 
7445
                if (!$768) {
 
7446
                  var $770 = $767;
 
7447
                  var $sp_0_i_i = __gm_ + 444 | 0;
 
7448
                  while (1) {
 
7449
                    var $sp_0_i_i;
 
7450
                    var $772 = $sp_0_i_i | 0;
 
7451
                    var $773 = HEAP32[$772 >> 2];
 
7452
                    var $774 = $773 >>> 0 > $770 >>> 0;
 
7453
                    if (!$774) {
 
7454
                      var $776 = $sp_0_i_i + 4 | 0;
 
7455
                      var $777 = HEAP32[$776 >> 2];
 
7456
                      var $778 = $773 + $777 | 0;
 
7457
                      var $779 = $778 >>> 0 > $770 >>> 0;
 
7458
                      if ($779) {
 
7459
                        break;
 
7460
                      }
 
7461
                    }
 
7462
                    var $781 = $sp_0_i_i + 8 | 0;
 
7463
                    var $782 = HEAP32[$781 >> 2];
 
7464
                    var $783 = ($782 | 0) == 0;
 
7465
                    if ($783) {
 
7466
                      __label__ = 174;
 
7467
                      break $_$236;
 
7468
                    }
 
7469
                    var $sp_0_i_i = $782;
 
7470
                  }
 
7471
                  var $784 = ($sp_0_i_i | 0) == 0;
 
7472
                  if ($784) {
 
7473
                    __label__ = 174;
 
7474
                    break;
 
7475
                  }
 
7476
                  var $810 = HEAP32[(__gm_ + 12 | 0) >> 2];
 
7477
                  var $811 = HEAP32[(_mparams + 8 | 0) >> 2];
 
7478
                  var $812 = $nb_0 + 47 | 0;
 
7479
                  var $813 = $812 - $810 | 0;
 
7480
                  var $814 = $813 + $811 | 0;
 
7481
                  var $815 = -$811 | 0;
 
7482
                  var $816 = $814 & $815;
 
7483
                  var $817 = $816 >>> 0 < 2147483647;
 
7484
                  if (!$817) {
 
7485
                    var $tsize_0242932_ph_i = 0;
 
7486
                    __label__ = 189;
 
7487
                    break;
 
7488
                  }
 
7489
                  var $819 = _sbrk($816);
 
7490
                  var $820 = HEAP32[$772 >> 2];
 
7491
                  var $821 = HEAP32[$776 >> 2];
 
7492
                  var $822 = $820 + $821 | 0;
 
7493
                  var $823 = ($819 | 0) == ($822 | 0);
 
7494
                  var $_1_i = $823 ? $816 : 0;
 
7495
                  var $_2_i = $823 ? $819 : -1;
 
7496
                  var $tbase_0_i = $_2_i;
 
7497
                  var $tsize_0_i = $_1_i;
 
7498
                  var $asize_1_i = $816;
 
7499
                  var $br_0_i = $819;
 
7500
                  __label__ = 181;
 
7501
                  break;
 
7502
                }
 
7503
                __label__ = 174;
 
7504
              } while (0);
 
7505
              do {
 
7506
                if (__label__ == 174) {
 
7507
                  var $785 = _sbrk(0);
 
7508
                  var $786 = ($785 | 0) == -1;
 
7509
                  if ($786) {
 
7510
                    var $tsize_0242932_ph_i = 0;
 
7511
                    __label__ = 189;
 
7512
                    break;
 
7513
                  }
 
7514
                  var $788 = HEAP32[(_mparams + 8 | 0) >> 2];
 
7515
                  var $789 = $nb_0 + 47 | 0;
 
7516
                  var $790 = $789 + $788 | 0;
 
7517
                  var $791 = -$788 | 0;
 
7518
                  var $792 = $790 & $791;
 
7519
                  var $793 = $785;
 
7520
                  var $794 = HEAP32[(_mparams + 4 | 0) >> 2];
 
7521
                  var $795 = $794 - 1 | 0;
 
7522
                  var $796 = $795 & $793;
 
7523
                  var $797 = ($796 | 0) == 0;
 
7524
                  if ($797) {
 
7525
                    var $asize_0_i = $792;
 
7526
                  } else {
 
7527
                    var $799 = $795 + $793 | 0;
 
7528
                    var $800 = -$794 | 0;
 
7529
                    var $801 = $799 & $800;
 
7530
                    var $802 = $792 - $793 | 0;
 
7531
                    var $803 = $802 + $801 | 0;
 
7532
                    var $asize_0_i = $803;
 
7533
                  }
 
7534
                  var $asize_0_i;
 
7535
                  var $805 = $asize_0_i >>> 0 < 2147483647;
 
7536
                  if (!$805) {
 
7537
                    var $tsize_0242932_ph_i = 0;
 
7538
                    __label__ = 189;
 
7539
                    break;
 
7540
                  }
 
7541
                  var $807 = _sbrk($asize_0_i);
 
7542
                  var $808 = ($807 | 0) == ($785 | 0);
 
7543
                  var $asize_0__i = $808 ? $asize_0_i : 0;
 
7544
                  var $__i = $808 ? $785 : -1;
 
7545
                  var $tbase_0_i = $__i;
 
7546
                  var $tsize_0_i = $asize_0__i;
 
7547
                  var $asize_1_i = $asize_0_i;
 
7548
                  var $br_0_i = $807;
 
7549
                  __label__ = 181;
 
7550
                  break;
 
7551
                }
 
7552
              } while (0);
 
7553
              $_$253 : do {
 
7554
                if (__label__ == 181) {
 
7555
                  var $br_0_i;
 
7556
                  var $asize_1_i;
 
7557
                  var $tsize_0_i;
 
7558
                  var $tbase_0_i;
 
7559
                  var $825 = -$asize_1_i | 0;
 
7560
                  var $826 = ($tbase_0_i | 0) == -1;
 
7561
                  if (!$826) {
 
7562
                    var $tsize_242_i = $tsize_0_i;
 
7563
                    var $tbase_243_i = $tbase_0_i;
 
7564
                    __label__ = 194;
 
7565
                    break $_$234;
 
7566
                  }
 
7567
                  var $828 = ($br_0_i | 0) != -1;
 
7568
                  var $829 = $asize_1_i >>> 0 < 2147483647;
 
7569
                  var $or_cond_i28 = $828 & $829;
 
7570
                  do {
 
7571
                    if ($or_cond_i28) {
 
7572
                      var $831 = $nb_0 + 48 | 0;
 
7573
                      var $832 = $asize_1_i >>> 0 < $831 >>> 0;
 
7574
                      if (!$832) {
 
7575
                        var $asize_2_i = $asize_1_i;
 
7576
                        break;
 
7577
                      }
 
7578
                      var $834 = HEAP32[(_mparams + 8 | 0) >> 2];
 
7579
                      var $835 = $nb_0 + 47 | 0;
 
7580
                      var $836 = $835 - $asize_1_i | 0;
 
7581
                      var $837 = $836 + $834 | 0;
 
7582
                      var $838 = -$834 | 0;
 
7583
                      var $839 = $837 & $838;
 
7584
                      var $840 = $839 >>> 0 < 2147483647;
 
7585
                      if (!$840) {
 
7586
                        var $asize_2_i = $asize_1_i;
 
7587
                        break;
 
7588
                      }
 
7589
                      var $842 = _sbrk($839);
 
7590
                      var $843 = ($842 | 0) == -1;
 
7591
                      if ($843) {
 
7592
                        var $847 = _sbrk($825);
 
7593
                        var $tsize_0242932_ph_i = $tsize_0_i;
 
7594
                        break $_$253;
 
7595
                      }
 
7596
                      var $845 = $839 + $asize_1_i | 0;
 
7597
                      var $asize_2_i = $845;
 
7598
                    } else {
 
7599
                      var $asize_2_i = $asize_1_i;
 
7600
                    }
 
7601
                  } while (0);
 
7602
                  var $asize_2_i;
 
7603
                  var $849 = ($br_0_i | 0) == -1;
 
7604
                  if (!$849) {
 
7605
                    var $tsize_242_i = $asize_2_i;
 
7606
                    var $tbase_243_i = $br_0_i;
 
7607
                    __label__ = 194;
 
7608
                    break $_$234;
 
7609
                  }
 
7610
                  var $852 = HEAP32[(__gm_ + 440 | 0) >> 2];
 
7611
                  var $853 = $852 | 4;
 
7612
                  HEAP32[(__gm_ + 440 | 0) >> 2] = $853;
 
7613
                  var $tsize_137_i = $tsize_0_i;
 
7614
                  __label__ = 191;
 
7615
                  break $_$234;
 
7616
                }
 
7617
              } while (0);
 
7618
              var $tsize_0242932_ph_i;
 
7619
              var $850 = HEAP32[(__gm_ + 440 | 0) >> 2];
 
7620
              var $851 = $850 | 4;
 
7621
              HEAP32[(__gm_ + 440 | 0) >> 2] = $851;
 
7622
              var $tsize_137_i = $tsize_0242932_ph_i;
 
7623
              __label__ = 191;
 
7624
              break;
 
7625
            }
 
7626
            var $tsize_137_i = 0;
 
7627
            __label__ = 191;
 
7628
          } while (0);
 
7629
          do {
 
7630
            if (__label__ == 191) {
 
7631
              var $tsize_137_i;
 
7632
              var $854 = HEAP32[(_mparams + 8 | 0) >> 2];
 
7633
              var $855 = $nb_0 + 47 | 0;
 
7634
              var $856 = $855 + $854 | 0;
 
7635
              var $857 = -$854 | 0;
 
7636
              var $858 = $856 & $857;
 
7637
              var $859 = $858 >>> 0 < 2147483647;
 
7638
              if (!$859) {
 
7639
                __label__ = 330;
 
7640
                break;
 
7641
              }
 
7642
              var $861 = _sbrk($858);
 
7643
              var $862 = _sbrk(0);
 
7644
              var $notlhs_i = ($861 | 0) != -1;
 
7645
              var $notrhs_i = ($862 | 0) != -1;
 
7646
              var $or_cond3_not_i = $notrhs_i & $notlhs_i;
 
7647
              var $863 = $861 >>> 0 < $862 >>> 0;
 
7648
              var $or_cond4_i = $or_cond3_not_i & $863;
 
7649
              if (!$or_cond4_i) {
 
7650
                __label__ = 330;
 
7651
                break;
 
7652
              }
 
7653
              var $864 = $862;
 
7654
              var $865 = $861;
 
7655
              var $866 = $864 - $865 | 0;
 
7656
              var $867 = $nb_0 + 40 | 0;
 
7657
              var $868 = $866 >>> 0 > $867 >>> 0;
 
7658
              var $_tsize_1_i = $868 ? $866 : $tsize_137_i;
 
7659
              var $_tbase_1_i = $868 ? $861 : -1;
 
7660
              var $869 = ($_tbase_1_i | 0) == -1;
 
7661
              if ($869) {
 
7662
                __label__ = 330;
 
7663
                break;
 
7664
              }
 
7665
              var $tsize_242_i = $_tsize_1_i;
 
7666
              var $tbase_243_i = $_tbase_1_i;
 
7667
              __label__ = 194;
 
7668
              break;
 
7669
            }
 
7670
          } while (0);
 
7671
          do {
 
7672
            if (__label__ == 194) {
 
7673
              var $tbase_243_i;
 
7674
              var $tsize_242_i;
 
7675
              var $870 = HEAP32[(__gm_ + 432 | 0) >> 2];
 
7676
              var $871 = $870 + $tsize_242_i | 0;
 
7677
              HEAP32[(__gm_ + 432 | 0) >> 2] = $871;
 
7678
              var $872 = HEAP32[(__gm_ + 436 | 0) >> 2];
 
7679
              var $873 = $871 >>> 0 > $872 >>> 0;
 
7680
              if ($873) {
 
7681
                HEAP32[(__gm_ + 436 | 0) >> 2] = $871;
 
7682
              }
 
7683
              var $876 = HEAP32[(__gm_ + 24 | 0) >> 2];
 
7684
              var $877 = ($876 | 0) == 0;
 
7685
              $_$275 : do {
 
7686
                if ($877) {
 
7687
                  var $879 = HEAP32[(__gm_ + 16 | 0) >> 2];
 
7688
                  var $880 = ($879 | 0) == 0;
 
7689
                  var $881 = $tbase_243_i >>> 0 < $879 >>> 0;
 
7690
                  var $or_cond5_i = $880 | $881;
 
7691
                  if ($or_cond5_i) {
 
7692
                    HEAP32[(__gm_ + 16 | 0) >> 2] = $tbase_243_i;
 
7693
                  }
 
7694
                  HEAP32[(__gm_ + 444 | 0) >> 2] = $tbase_243_i;
 
7695
                  HEAP32[(__gm_ + 448 | 0) >> 2] = $tsize_242_i;
 
7696
                  HEAP32[(__gm_ + 456 | 0) >> 2] = 0;
 
7697
                  var $884 = HEAP32[(_mparams | 0) >> 2];
 
7698
                  HEAP32[(__gm_ + 36 | 0) >> 2] = $884;
 
7699
                  HEAP32[(__gm_ + 32 | 0) >> 2] = -1;
 
7700
                  var $i_02_i_i = 0;
 
7701
                  while (1) {
 
7702
                    var $i_02_i_i;
 
7703
                    var $886 = $i_02_i_i << 1;
 
7704
                    var $887 = __gm_ + 40 + ($886 << 2) | 0;
 
7705
                    var $888 = $887;
 
7706
                    var $_sum_i_i = $886 + 3 | 0;
 
7707
                    var $889 = __gm_ + 40 + ($_sum_i_i << 2) | 0;
 
7708
                    HEAP32[$889 >> 2] = $888;
 
7709
                    var $_sum1_i_i = $886 + 2 | 0;
 
7710
                    var $890 = __gm_ + 40 + ($_sum1_i_i << 2) | 0;
 
7711
                    HEAP32[$890 >> 2] = $888;
 
7712
                    var $891 = $i_02_i_i + 1 | 0;
 
7713
                    var $exitcond_i_i = ($891 | 0) == 32;
 
7714
                    if ($exitcond_i_i) {
 
7715
                      break;
 
7716
                    }
 
7717
                    var $i_02_i_i = $891;
 
7718
                  }
 
7719
                  var $892 = $tbase_243_i + 8 | 0;
 
7720
                  var $893 = $892;
 
7721
                  var $894 = $893 & 7;
 
7722
                  var $895 = ($894 | 0) == 0;
 
7723
                  if ($895) {
 
7724
                    var $899 = 0;
 
7725
                  } else {
 
7726
                    var $897 = -$893 | 0;
 
7727
                    var $898 = $897 & 7;
 
7728
                    var $899 = $898;
 
7729
                  }
 
7730
                  var $899;
 
7731
                  var $900 = $tbase_243_i + $899 | 0;
 
7732
                  var $901 = $900;
 
7733
                  var $902 = $tsize_242_i - 40 | 0;
 
7734
                  var $903 = $902 - $899 | 0;
 
7735
                  HEAP32[(__gm_ + 24 | 0) >> 2] = $901;
 
7736
                  HEAP32[(__gm_ + 12 | 0) >> 2] = $903;
 
7737
                  var $904 = $903 | 1;
 
7738
                  var $_sum_i9_i = $899 + 4 | 0;
 
7739
                  var $905 = $tbase_243_i + $_sum_i9_i | 0;
 
7740
                  var $906 = $905;
 
7741
                  HEAP32[$906 >> 2] = $904;
 
7742
                  var $_sum2_i_i = $tsize_242_i - 36 | 0;
 
7743
                  var $907 = $tbase_243_i + $_sum2_i_i | 0;
 
7744
                  var $908 = $907;
 
7745
                  HEAP32[$908 >> 2] = 40;
 
7746
                  var $909 = HEAP32[(_mparams + 16 | 0) >> 2];
 
7747
                  HEAP32[(__gm_ + 28 | 0) >> 2] = $909;
 
7748
                } else {
 
7749
                  var $sp_0_i = __gm_ + 444 | 0;
 
7750
                  while (1) {
 
7751
                    var $sp_0_i;
 
7752
                    var $910 = ($sp_0_i | 0) == 0;
 
7753
                    if ($910) {
 
7754
                      break;
 
7755
                    }
 
7756
                    var $912 = $sp_0_i | 0;
 
7757
                    var $913 = HEAP32[$912 >> 2];
 
7758
                    var $914 = $sp_0_i + 4 | 0;
 
7759
                    var $915 = HEAP32[$914 >> 2];
 
7760
                    var $916 = $913 + $915 | 0;
 
7761
                    var $917 = ($tbase_243_i | 0) == ($916 | 0);
 
7762
                    if ($917) {
 
7763
                      var $921 = $sp_0_i + 12 | 0;
 
7764
                      var $922 = HEAP32[$921 >> 2];
 
7765
                      var $923 = $922 & 8;
 
7766
                      var $924 = ($923 | 0) == 0;
 
7767
                      if (!$924) {
 
7768
                        break;
 
7769
                      }
 
7770
                      var $926 = $876;
 
7771
                      var $927 = $926 >>> 0 >= $913 >>> 0;
 
7772
                      var $928 = $926 >>> 0 < $tbase_243_i >>> 0;
 
7773
                      var $or_cond44_i = $927 & $928;
 
7774
                      if (!$or_cond44_i) {
 
7775
                        break;
 
7776
                      }
 
7777
                      var $930 = $915 + $tsize_242_i | 0;
 
7778
                      HEAP32[$914 >> 2] = $930;
 
7779
                      var $931 = HEAP32[(__gm_ + 24 | 0) >> 2];
 
7780
                      var $932 = HEAP32[(__gm_ + 12 | 0) >> 2];
 
7781
                      var $933 = $932 + $tsize_242_i | 0;
 
7782
                      var $934 = $931;
 
7783
                      var $935 = $931 + 8 | 0;
 
7784
                      var $936 = $935;
 
7785
                      var $937 = $936 & 7;
 
7786
                      var $938 = ($937 | 0) == 0;
 
7787
                      if ($938) {
 
7788
                        var $942 = 0;
 
7789
                      } else {
 
7790
                        var $940 = -$936 | 0;
 
7791
                        var $941 = $940 & 7;
 
7792
                        var $942 = $941;
 
7793
                      }
 
7794
                      var $942;
 
7795
                      var $943 = $934 + $942 | 0;
 
7796
                      var $944 = $943;
 
7797
                      var $945 = $933 - $942 | 0;
 
7798
                      HEAP32[(__gm_ + 24 | 0) >> 2] = $944;
 
7799
                      HEAP32[(__gm_ + 12 | 0) >> 2] = $945;
 
7800
                      var $946 = $945 | 1;
 
7801
                      var $_sum_i13_i = $942 + 4 | 0;
 
7802
                      var $947 = $934 + $_sum_i13_i | 0;
 
7803
                      var $948 = $947;
 
7804
                      HEAP32[$948 >> 2] = $946;
 
7805
                      var $_sum2_i14_i = $933 + 4 | 0;
 
7806
                      var $949 = $934 + $_sum2_i14_i | 0;
 
7807
                      var $950 = $949;
 
7808
                      HEAP32[$950 >> 2] = 40;
 
7809
                      var $951 = HEAP32[(_mparams + 16 | 0) >> 2];
 
7810
                      HEAP32[(__gm_ + 28 | 0) >> 2] = $951;
 
7811
                      break $_$275;
 
7812
                    }
 
7813
                    var $919 = $sp_0_i + 8 | 0;
 
7814
                    var $920 = HEAP32[$919 >> 2];
 
7815
                    var $sp_0_i = $920;
 
7816
                  }
 
7817
                  var $952 = HEAP32[(__gm_ + 16 | 0) >> 2];
 
7818
                  var $953 = $tbase_243_i >>> 0 < $952 >>> 0;
 
7819
                  if ($953) {
 
7820
                    HEAP32[(__gm_ + 16 | 0) >> 2] = $tbase_243_i;
 
7821
                  }
 
7822
                  var $955 = $tbase_243_i + $tsize_242_i | 0;
 
7823
                  var $sp_1_i = __gm_ + 444 | 0;
 
7824
                  while (1) {
 
7825
                    var $sp_1_i;
 
7826
                    var $957 = ($sp_1_i | 0) == 0;
 
7827
                    if ($957) {
 
7828
                      __label__ = 293;
 
7829
                      break;
 
7830
                    }
 
7831
                    var $959 = $sp_1_i | 0;
 
7832
                    var $960 = HEAP32[$959 >> 2];
 
7833
                    var $961 = ($960 | 0) == ($955 | 0);
 
7834
                    if ($961) {
 
7835
                      __label__ = 218;
 
7836
                      break;
 
7837
                    }
 
7838
                    var $963 = $sp_1_i + 8 | 0;
 
7839
                    var $964 = HEAP32[$963 >> 2];
 
7840
                    var $sp_1_i = $964;
 
7841
                  }
 
7842
                  do {
 
7843
                    if (__label__ == 218) {
 
7844
                      var $965 = $sp_1_i + 12 | 0;
 
7845
                      var $966 = HEAP32[$965 >> 2];
 
7846
                      var $967 = $966 & 8;
 
7847
                      var $968 = ($967 | 0) == 0;
 
7848
                      if (!$968) {
 
7849
                        break;
 
7850
                      }
 
7851
                      HEAP32[$959 >> 2] = $tbase_243_i;
 
7852
                      var $970 = $sp_1_i + 4 | 0;
 
7853
                      var $971 = HEAP32[$970 >> 2];
 
7854
                      var $972 = $971 + $tsize_242_i | 0;
 
7855
                      HEAP32[$970 >> 2] = $972;
 
7856
                      var $973 = $tbase_243_i + 8 | 0;
 
7857
                      var $974 = $973;
 
7858
                      var $975 = $974 & 7;
 
7859
                      var $976 = ($975 | 0) == 0;
 
7860
                      if ($976) {
 
7861
                        var $981 = 0;
 
7862
                      } else {
 
7863
                        var $978 = -$974 | 0;
 
7864
                        var $979 = $978 & 7;
 
7865
                        var $981 = $979;
 
7866
                      }
 
7867
                      var $981;
 
7868
                      var $982 = $tbase_243_i + $981 | 0;
 
7869
                      var $_sum79_i = $tsize_242_i + 8 | 0;
 
7870
                      var $983 = $tbase_243_i + $_sum79_i | 0;
 
7871
                      var $984 = $983;
 
7872
                      var $985 = $984 & 7;
 
7873
                      var $986 = ($985 | 0) == 0;
 
7874
                      if ($986) {
 
7875
                        var $991 = 0;
 
7876
                      } else {
 
7877
                        var $988 = -$984 | 0;
 
7878
                        var $989 = $988 & 7;
 
7879
                        var $991 = $989;
 
7880
                      }
 
7881
                      var $991;
 
7882
                      var $_sum80_i = $991 + $tsize_242_i | 0;
 
7883
                      var $992 = $tbase_243_i + $_sum80_i | 0;
 
7884
                      var $993 = $992;
 
7885
                      var $994 = $992;
 
7886
                      var $995 = $982;
 
7887
                      var $996 = $994 - $995 | 0;
 
7888
                      var $_sum_i16_i = $981 + $nb_0 | 0;
 
7889
                      var $997 = $tbase_243_i + $_sum_i16_i | 0;
 
7890
                      var $998 = $997;
 
7891
                      var $999 = $996 - $nb_0 | 0;
 
7892
                      var $1000 = $nb_0 | 3;
 
7893
                      var $_sum1_i17_i = $981 + 4 | 0;
 
7894
                      var $1001 = $tbase_243_i + $_sum1_i17_i | 0;
 
7895
                      var $1002 = $1001;
 
7896
                      HEAP32[$1002 >> 2] = $1000;
 
7897
                      var $1003 = HEAP32[(__gm_ + 24 | 0) >> 2];
 
7898
                      var $1004 = ($993 | 0) == ($1003 | 0);
 
7899
                      $_$314 : do {
 
7900
                        if ($1004) {
 
7901
                          var $1006 = HEAP32[(__gm_ + 12 | 0) >> 2];
 
7902
                          var $1007 = $1006 + $999 | 0;
 
7903
                          HEAP32[(__gm_ + 12 | 0) >> 2] = $1007;
 
7904
                          HEAP32[(__gm_ + 24 | 0) >> 2] = $998;
 
7905
                          var $1008 = $1007 | 1;
 
7906
                          var $_sum42_i_i = $_sum_i16_i + 4 | 0;
 
7907
                          var $1009 = $tbase_243_i + $_sum42_i_i | 0;
 
7908
                          var $1010 = $1009;
 
7909
                          HEAP32[$1010 >> 2] = $1008;
 
7910
                        } else {
 
7911
                          var $1012 = HEAP32[(__gm_ + 20 | 0) >> 2];
 
7912
                          var $1013 = ($993 | 0) == ($1012 | 0);
 
7913
                          if ($1013) {
 
7914
                            var $1015 = HEAP32[(__gm_ + 8 | 0) >> 2];
 
7915
                            var $1016 = $1015 + $999 | 0;
 
7916
                            HEAP32[(__gm_ + 8 | 0) >> 2] = $1016;
 
7917
                            HEAP32[(__gm_ + 20 | 0) >> 2] = $998;
 
7918
                            var $1017 = $1016 | 1;
 
7919
                            var $_sum40_i_i = $_sum_i16_i + 4 | 0;
 
7920
                            var $1018 = $tbase_243_i + $_sum40_i_i | 0;
 
7921
                            var $1019 = $1018;
 
7922
                            HEAP32[$1019 >> 2] = $1017;
 
7923
                            var $_sum41_i_i = $1016 + $_sum_i16_i | 0;
 
7924
                            var $1020 = $tbase_243_i + $_sum41_i_i | 0;
 
7925
                            var $1021 = $1020;
 
7926
                            HEAP32[$1021 >> 2] = $1016;
 
7927
                          } else {
 
7928
                            var $_sum2_i18_i = $tsize_242_i + 4 | 0;
 
7929
                            var $_sum81_i = $_sum2_i18_i + $991 | 0;
 
7930
                            var $1023 = $tbase_243_i + $_sum81_i | 0;
 
7931
                            var $1024 = $1023;
 
7932
                            var $1025 = HEAP32[$1024 >> 2];
 
7933
                            var $1026 = $1025 & 3;
 
7934
                            var $1027 = ($1026 | 0) == 1;
 
7935
                            if ($1027) {
 
7936
                              var $1029 = $1025 & -8;
 
7937
                              var $1030 = $1025 >>> 3;
 
7938
                              var $1031 = $1025 >>> 0 < 256;
 
7939
                              $_$322 : do {
 
7940
                                if ($1031) {
 
7941
                                  var $_sum3738_i_i = $991 | 8;
 
7942
                                  var $_sum91_i = $_sum3738_i_i + $tsize_242_i | 0;
 
7943
                                  var $1033 = $tbase_243_i + $_sum91_i | 0;
 
7944
                                  var $1034 = $1033;
 
7945
                                  var $1035 = HEAP32[$1034 >> 2];
 
7946
                                  var $_sum39_i_i = $tsize_242_i + 12 | 0;
 
7947
                                  var $_sum92_i = $_sum39_i_i + $991 | 0;
 
7948
                                  var $1036 = $tbase_243_i + $_sum92_i | 0;
 
7949
                                  var $1037 = $1036;
 
7950
                                  var $1038 = HEAP32[$1037 >> 2];
 
7951
                                  var $1039 = ($1035 | 0) == ($1038 | 0);
 
7952
                                  if ($1039) {
 
7953
                                    var $1041 = 1 << $1030;
 
7954
                                    var $1042 = $1041 ^ -1;
 
7955
                                    var $1043 = HEAP32[(__gm_ | 0) >> 2];
 
7956
                                    var $1044 = $1043 & $1042;
 
7957
                                    HEAP32[(__gm_ | 0) >> 2] = $1044;
 
7958
                                  } else {
 
7959
                                    var $1046 = $1025 >>> 2;
 
7960
                                    var $1047 = $1046 & 1073741822;
 
7961
                                    var $1048 = __gm_ + 40 + ($1047 << 2) | 0;
 
7962
                                    var $1049 = $1048;
 
7963
                                    var $1050 = ($1035 | 0) == ($1049 | 0);
 
7964
                                    do {
 
7965
                                      if ($1050) {
 
7966
                                        __label__ = 233;
 
7967
                                      } else {
 
7968
                                        var $1052 = $1035;
 
7969
                                        var $1053 = HEAP32[(__gm_ + 16 | 0) >> 2];
 
7970
                                        var $1054 = $1052 >>> 0 < $1053 >>> 0;
 
7971
                                        if ($1054) {
 
7972
                                          __label__ = 236;
 
7973
                                          break;
 
7974
                                        }
 
7975
                                        __label__ = 233;
 
7976
                                        break;
 
7977
                                      }
 
7978
                                    } while (0);
 
7979
                                    do {
 
7980
                                      if (__label__ == 233) {
 
7981
                                        var $1056 = ($1038 | 0) == ($1049 | 0);
 
7982
                                        if (!$1056) {
 
7983
                                          var $1058 = $1038;
 
7984
                                          var $1059 = HEAP32[(__gm_ + 16 | 0) >> 2];
 
7985
                                          var $1060 = $1058 >>> 0 < $1059 >>> 0;
 
7986
                                          if ($1060) {
 
7987
                                            break;
 
7988
                                          }
 
7989
                                        }
 
7990
                                        var $1061 = $1035 + 12 | 0;
 
7991
                                        HEAP32[$1061 >> 2] = $1038;
 
7992
                                        var $1062 = $1038 + 8 | 0;
 
7993
                                        HEAP32[$1062 >> 2] = $1035;
 
7994
                                        break $_$322;
 
7995
                                      }
 
7996
                                    } while (0);
 
7997
                                    _abort();
 
7998
                                  }
 
7999
                                } else {
 
8000
                                  var $1064 = $992;
 
8001
                                  var $_sum34_i_i = $991 | 24;
 
8002
                                  var $_sum82_i = $_sum34_i_i + $tsize_242_i | 0;
 
8003
                                  var $1065 = $tbase_243_i + $_sum82_i | 0;
 
8004
                                  var $1066 = $1065;
 
8005
                                  var $1067 = HEAP32[$1066 >> 2];
 
8006
                                  var $_sum5_i_i = $tsize_242_i + 12 | 0;
 
8007
                                  var $_sum83_i = $_sum5_i_i + $991 | 0;
 
8008
                                  var $1068 = $tbase_243_i + $_sum83_i | 0;
 
8009
                                  var $1069 = $1068;
 
8010
                                  var $1070 = HEAP32[$1069 >> 2];
 
8011
                                  var $1071 = ($1070 | 0) == ($1064 | 0);
 
8012
                                  do {
 
8013
                                    if ($1071) {
 
8014
                                      var $_sum67_i_i = $991 | 16;
 
8015
                                      var $_sum89_i = $_sum2_i18_i + $_sum67_i_i | 0;
 
8016
                                      var $1084 = $tbase_243_i + $_sum89_i | 0;
 
8017
                                      var $1085 = $1084;
 
8018
                                      var $1086 = HEAP32[$1085 >> 2];
 
8019
                                      var $1087 = ($1086 | 0) == 0;
 
8020
                                      if ($1087) {
 
8021
                                        var $_sum90_i = $_sum67_i_i + $tsize_242_i | 0;
 
8022
                                        var $1089 = $tbase_243_i + $_sum90_i | 0;
 
8023
                                        var $1090 = $1089;
 
8024
                                        var $1091 = HEAP32[$1090 >> 2];
 
8025
                                        var $1092 = ($1091 | 0) == 0;
 
8026
                                        if ($1092) {
 
8027
                                          var $R_1_i_i = 0;
 
8028
                                          break;
 
8029
                                        }
 
8030
                                        var $RP_0_i_i = $1090;
 
8031
                                        var $R_0_i_i = $1091;
 
8032
                                      } else {
 
8033
                                        var $RP_0_i_i = $1085;
 
8034
                                        var $R_0_i_i = $1086;
 
8035
                                        __label__ = 243;
 
8036
                                      }
 
8037
                                      while (1) {
 
8038
                                        var $R_0_i_i;
 
8039
                                        var $RP_0_i_i;
 
8040
                                        var $1093 = $R_0_i_i + 20 | 0;
 
8041
                                        var $1094 = HEAP32[$1093 >> 2];
 
8042
                                        var $1095 = ($1094 | 0) == 0;
 
8043
                                        if (!$1095) {
 
8044
                                          var $RP_0_i_i = $1093;
 
8045
                                          var $R_0_i_i = $1094;
 
8046
                                          continue;
 
8047
                                        }
 
8048
                                        var $1097 = $R_0_i_i + 16 | 0;
 
8049
                                        var $1098 = HEAP32[$1097 >> 2];
 
8050
                                        var $1099 = ($1098 | 0) == 0;
 
8051
                                        if ($1099) {
 
8052
                                          break;
 
8053
                                        }
 
8054
                                        var $RP_0_i_i = $1097;
 
8055
                                        var $R_0_i_i = $1098;
 
8056
                                      }
 
8057
                                      var $1101 = $RP_0_i_i;
 
8058
                                      var $1102 = HEAP32[(__gm_ + 16 | 0) >> 2];
 
8059
                                      var $1103 = $1101 >>> 0 < $1102 >>> 0;
 
8060
                                      if ($1103) {
 
8061
                                        _abort();
 
8062
                                      } else {
 
8063
                                        HEAP32[$RP_0_i_i >> 2] = 0;
 
8064
                                        var $R_1_i_i = $R_0_i_i;
 
8065
                                      }
 
8066
                                    } else {
 
8067
                                      var $_sum3536_i_i = $991 | 8;
 
8068
                                      var $_sum84_i = $_sum3536_i_i + $tsize_242_i | 0;
 
8069
                                      var $1073 = $tbase_243_i + $_sum84_i | 0;
 
8070
                                      var $1074 = $1073;
 
8071
                                      var $1075 = HEAP32[$1074 >> 2];
 
8072
                                      var $1076 = $1075;
 
8073
                                      var $1077 = HEAP32[(__gm_ + 16 | 0) >> 2];
 
8074
                                      var $1078 = $1076 >>> 0 < $1077 >>> 0;
 
8075
                                      if ($1078) {
 
8076
                                        _abort();
 
8077
                                      } else {
 
8078
                                        var $1080 = $1075 + 12 | 0;
 
8079
                                        HEAP32[$1080 >> 2] = $1070;
 
8080
                                        var $1081 = $1070 + 8 | 0;
 
8081
                                        HEAP32[$1081 >> 2] = $1075;
 
8082
                                        var $R_1_i_i = $1070;
 
8083
                                      }
 
8084
                                    }
 
8085
                                  } while (0);
 
8086
                                  var $R_1_i_i;
 
8087
                                  var $1107 = ($1067 | 0) == 0;
 
8088
                                  if ($1107) {
 
8089
                                    break;
 
8090
                                  }
 
8091
                                  var $_sum30_i_i = $tsize_242_i + 28 | 0;
 
8092
                                  var $_sum85_i = $_sum30_i_i + $991 | 0;
 
8093
                                  var $1109 = $tbase_243_i + $_sum85_i | 0;
 
8094
                                  var $1110 = $1109;
 
8095
                                  var $1111 = HEAP32[$1110 >> 2];
 
8096
                                  var $1112 = __gm_ + 304 + ($1111 << 2) | 0;
 
8097
                                  var $1113 = HEAP32[$1112 >> 2];
 
8098
                                  var $1114 = ($1064 | 0) == ($1113 | 0);
 
8099
                                  do {
 
8100
                                    if ($1114) {
 
8101
                                      HEAP32[$1112 >> 2] = $R_1_i_i;
 
8102
                                      var $cond_i_i = ($R_1_i_i | 0) == 0;
 
8103
                                      if (!$cond_i_i) {
 
8104
                                        break;
 
8105
                                      }
 
8106
                                      var $1116 = HEAP32[$1110 >> 2];
 
8107
                                      var $1117 = 1 << $1116;
 
8108
                                      var $1118 = $1117 ^ -1;
 
8109
                                      var $1119 = HEAP32[(__gm_ + 4 | 0) >> 2];
 
8110
                                      var $1120 = $1119 & $1118;
 
8111
                                      HEAP32[(__gm_ + 4 | 0) >> 2] = $1120;
 
8112
                                      break $_$322;
 
8113
                                    }
 
8114
                                    var $1122 = $1067;
 
8115
                                    var $1123 = HEAP32[(__gm_ + 16 | 0) >> 2];
 
8116
                                    var $1124 = $1122 >>> 0 < $1123 >>> 0;
 
8117
                                    if ($1124) {
 
8118
                                      _abort();
 
8119
                                    } else {
 
8120
                                      var $1126 = $1067 + 16 | 0;
 
8121
                                      var $1127 = HEAP32[$1126 >> 2];
 
8122
                                      var $1128 = ($1127 | 0) == ($1064 | 0);
 
8123
                                      if ($1128) {
 
8124
                                        HEAP32[$1126 >> 2] = $R_1_i_i;
 
8125
                                      } else {
 
8126
                                        var $1131 = $1067 + 20 | 0;
 
8127
                                        HEAP32[$1131 >> 2] = $R_1_i_i;
 
8128
                                      }
 
8129
                                      var $1134 = ($R_1_i_i | 0) == 0;
 
8130
                                      if ($1134) {
 
8131
                                        break $_$322;
 
8132
                                      }
 
8133
                                    }
 
8134
                                  } while (0);
 
8135
                                  var $1136 = $R_1_i_i;
 
8136
                                  var $1137 = HEAP32[(__gm_ + 16 | 0) >> 2];
 
8137
                                  var $1138 = $1136 >>> 0 < $1137 >>> 0;
 
8138
                                  if ($1138) {
 
8139
                                    _abort();
 
8140
                                  } else {
 
8141
                                    var $1140 = $R_1_i_i + 24 | 0;
 
8142
                                    HEAP32[$1140 >> 2] = $1067;
 
8143
                                    var $_sum3132_i_i = $991 | 16;
 
8144
                                    var $_sum86_i = $_sum3132_i_i + $tsize_242_i | 0;
 
8145
                                    var $1141 = $tbase_243_i + $_sum86_i | 0;
 
8146
                                    var $1142 = $1141;
 
8147
                                    var $1143 = HEAP32[$1142 >> 2];
 
8148
                                    var $1144 = ($1143 | 0) == 0;
 
8149
                                    if (!$1144) {
 
8150
                                      var $1146 = $1143;
 
8151
                                      var $1147 = HEAP32[(__gm_ + 16 | 0) >> 2];
 
8152
                                      var $1148 = $1146 >>> 0 < $1147 >>> 0;
 
8153
                                      if ($1148) {
 
8154
                                        _abort();
 
8155
                                      } else {
 
8156
                                        var $1150 = $R_1_i_i + 16 | 0;
 
8157
                                        HEAP32[$1150 >> 2] = $1143;
 
8158
                                        var $1151 = $1143 + 24 | 0;
 
8159
                                        HEAP32[$1151 >> 2] = $R_1_i_i;
 
8160
                                      }
 
8161
                                    }
 
8162
                                    var $_sum87_i = $_sum2_i18_i + $_sum3132_i_i | 0;
 
8163
                                    var $1154 = $tbase_243_i + $_sum87_i | 0;
 
8164
                                    var $1155 = $1154;
 
8165
                                    var $1156 = HEAP32[$1155 >> 2];
 
8166
                                    var $1157 = ($1156 | 0) == 0;
 
8167
                                    if ($1157) {
 
8168
                                      break;
 
8169
                                    }
 
8170
                                    var $1159 = $1156;
 
8171
                                    var $1160 = HEAP32[(__gm_ + 16 | 0) >> 2];
 
8172
                                    var $1161 = $1159 >>> 0 < $1160 >>> 0;
 
8173
                                    if ($1161) {
 
8174
                                      _abort();
 
8175
                                    } else {
 
8176
                                      var $1163 = $R_1_i_i + 20 | 0;
 
8177
                                      HEAP32[$1163 >> 2] = $1156;
 
8178
                                      var $1164 = $1156 + 24 | 0;
 
8179
                                      HEAP32[$1164 >> 2] = $R_1_i_i;
 
8180
                                    }
 
8181
                                  }
 
8182
                                }
 
8183
                              } while (0);
 
8184
                              var $_sum9_i_i = $1029 | $991;
 
8185
                              var $_sum88_i = $_sum9_i_i + $tsize_242_i | 0;
 
8186
                              var $1168 = $tbase_243_i + $_sum88_i | 0;
 
8187
                              var $1169 = $1168;
 
8188
                              var $1170 = $1029 + $999 | 0;
 
8189
                              var $oldfirst_0_i_i = $1169;
 
8190
                              var $qsize_0_i_i = $1170;
 
8191
                            } else {
 
8192
                              var $oldfirst_0_i_i = $993;
 
8193
                              var $qsize_0_i_i = $999;
 
8194
                            }
 
8195
                            var $qsize_0_i_i;
 
8196
                            var $oldfirst_0_i_i;
 
8197
                            var $1172 = $oldfirst_0_i_i + 4 | 0;
 
8198
                            var $1173 = HEAP32[$1172 >> 2];
 
8199
                            var $1174 = $1173 & -2;
 
8200
                            HEAP32[$1172 >> 2] = $1174;
 
8201
                            var $1175 = $qsize_0_i_i | 1;
 
8202
                            var $_sum10_i_i = $_sum_i16_i + 4 | 0;
 
8203
                            var $1176 = $tbase_243_i + $_sum10_i_i | 0;
 
8204
                            var $1177 = $1176;
 
8205
                            HEAP32[$1177 >> 2] = $1175;
 
8206
                            var $_sum11_i19_i = $qsize_0_i_i + $_sum_i16_i | 0;
 
8207
                            var $1178 = $tbase_243_i + $_sum11_i19_i | 0;
 
8208
                            var $1179 = $1178;
 
8209
                            HEAP32[$1179 >> 2] = $qsize_0_i_i;
 
8210
                            var $1180 = $qsize_0_i_i >>> 0 < 256;
 
8211
                            if ($1180) {
 
8212
                              var $1182 = $qsize_0_i_i >>> 3;
 
8213
                              var $1183 = $qsize_0_i_i >>> 2;
 
8214
                              var $1184 = $1183 & 1073741822;
 
8215
                              var $1185 = __gm_ + 40 + ($1184 << 2) | 0;
 
8216
                              var $1186 = $1185;
 
8217
                              var $1187 = HEAP32[(__gm_ | 0) >> 2];
 
8218
                              var $1188 = 1 << $1182;
 
8219
                              var $1189 = $1187 & $1188;
 
8220
                              var $1190 = ($1189 | 0) == 0;
 
8221
                              do {
 
8222
                                if ($1190) {
 
8223
                                  var $1192 = $1187 | $1188;
 
8224
                                  HEAP32[(__gm_ | 0) >> 2] = $1192;
 
8225
                                  var $_sum26_pre_i_i = $1184 + 2 | 0;
 
8226
                                  var $_pre_i_i = __gm_ + 40 + ($_sum26_pre_i_i << 2) | 0;
 
8227
                                  var $F4_0_i_i = $1186;
 
8228
                                  var $_pre_phi_i20_i = $_pre_i_i;
 
8229
                                } else {
 
8230
                                  var $_sum29_i_i = $1184 + 2 | 0;
 
8231
                                  var $1194 = __gm_ + 40 + ($_sum29_i_i << 2) | 0;
 
8232
                                  var $1195 = HEAP32[$1194 >> 2];
 
8233
                                  var $1196 = $1195;
 
8234
                                  var $1197 = HEAP32[(__gm_ + 16 | 0) >> 2];
 
8235
                                  var $1198 = $1196 >>> 0 < $1197 >>> 0;
 
8236
                                  if (!$1198) {
 
8237
                                    var $F4_0_i_i = $1195;
 
8238
                                    var $_pre_phi_i20_i = $1194;
 
8239
                                    break;
 
8240
                                  }
 
8241
                                  _abort();
 
8242
                                }
 
8243
                              } while (0);
 
8244
                              var $_pre_phi_i20_i;
 
8245
                              var $F4_0_i_i;
 
8246
                              HEAP32[$_pre_phi_i20_i >> 2] = $998;
 
8247
                              var $1201 = $F4_0_i_i + 12 | 0;
 
8248
                              HEAP32[$1201 >> 2] = $998;
 
8249
                              var $_sum27_i_i = $_sum_i16_i + 8 | 0;
 
8250
                              var $1202 = $tbase_243_i + $_sum27_i_i | 0;
 
8251
                              var $1203 = $1202;
 
8252
                              HEAP32[$1203 >> 2] = $F4_0_i_i;
 
8253
                              var $_sum28_i_i = $_sum_i16_i + 12 | 0;
 
8254
                              var $1204 = $tbase_243_i + $_sum28_i_i | 0;
 
8255
                              var $1205 = $1204;
 
8256
                              HEAP32[$1205 >> 2] = $1186;
 
8257
                            } else {
 
8258
                              var $1207 = $997;
 
8259
                              var $1208 = $qsize_0_i_i >>> 8;
 
8260
                              var $1209 = ($1208 | 0) == 0;
 
8261
                              do {
 
8262
                                if ($1209) {
 
8263
                                  var $I7_0_i_i = 0;
 
8264
                                } else {
 
8265
                                  var $1211 = $qsize_0_i_i >>> 0 > 16777215;
 
8266
                                  if ($1211) {
 
8267
                                    var $I7_0_i_i = 31;
 
8268
                                    break;
 
8269
                                  }
 
8270
                                  var $1213 = $1208 + 1048320 | 0;
 
8271
                                  var $1214 = $1213 >>> 16;
 
8272
                                  var $1215 = $1214 & 8;
 
8273
                                  var $1216 = $1208 << $1215;
 
8274
                                  var $1217 = $1216 + 520192 | 0;
 
8275
                                  var $1218 = $1217 >>> 16;
 
8276
                                  var $1219 = $1218 & 4;
 
8277
                                  var $1220 = $1216 << $1219;
 
8278
                                  var $1221 = $1220 + 245760 | 0;
 
8279
                                  var $1222 = $1221 >>> 16;
 
8280
                                  var $1223 = $1222 & 2;
 
8281
                                  var $1224 = $1219 | $1215;
 
8282
                                  var $1225 = $1224 | $1223;
 
8283
                                  var $1226 = 14 - $1225 | 0;
 
8284
                                  var $1227 = $1220 << $1223;
 
8285
                                  var $1228 = $1227 >>> 15;
 
8286
                                  var $1229 = $1226 + $1228 | 0;
 
8287
                                  var $1230 = $1229 << 1;
 
8288
                                  var $1231 = $1229 + 7 | 0;
 
8289
                                  var $1232 = $qsize_0_i_i >>> ($1231 >>> 0);
 
8290
                                  var $1233 = $1232 & 1;
 
8291
                                  var $1234 = $1233 | $1230;
 
8292
                                  var $I7_0_i_i = $1234;
 
8293
                                }
 
8294
                              } while (0);
 
8295
                              var $I7_0_i_i;
 
8296
                              var $1236 = __gm_ + 304 + ($I7_0_i_i << 2) | 0;
 
8297
                              var $_sum12_i_i = $_sum_i16_i + 28 | 0;
 
8298
                              var $1237 = $tbase_243_i + $_sum12_i_i | 0;
 
8299
                              var $1238 = $1237;
 
8300
                              HEAP32[$1238 >> 2] = $I7_0_i_i;
 
8301
                              var $_sum13_i_i = $_sum_i16_i + 16 | 0;
 
8302
                              var $1239 = $tbase_243_i + $_sum13_i_i | 0;
 
8303
                              var $_sum14_i_i = $_sum_i16_i + 20 | 0;
 
8304
                              var $1240 = $tbase_243_i + $_sum14_i_i | 0;
 
8305
                              var $1241 = $1240;
 
8306
                              HEAP32[$1241 >> 2] = 0;
 
8307
                              var $1242 = $1239;
 
8308
                              HEAP32[$1242 >> 2] = 0;
 
8309
                              var $1243 = HEAP32[(__gm_ + 4 | 0) >> 2];
 
8310
                              var $1244 = 1 << $I7_0_i_i;
 
8311
                              var $1245 = $1243 & $1244;
 
8312
                              var $1246 = ($1245 | 0) == 0;
 
8313
                              if ($1246) {
 
8314
                                var $1248 = $1243 | $1244;
 
8315
                                HEAP32[(__gm_ + 4 | 0) >> 2] = $1248;
 
8316
                                HEAP32[$1236 >> 2] = $1207;
 
8317
                                var $1249 = $1236;
 
8318
                                var $_sum15_i_i = $_sum_i16_i + 24 | 0;
 
8319
                                var $1250 = $tbase_243_i + $_sum15_i_i | 0;
 
8320
                                var $1251 = $1250;
 
8321
                                HEAP32[$1251 >> 2] = $1249;
 
8322
                                var $_sum16_i_i = $_sum_i16_i + 12 | 0;
 
8323
                                var $1252 = $tbase_243_i + $_sum16_i_i | 0;
 
8324
                                var $1253 = $1252;
 
8325
                                HEAP32[$1253 >> 2] = $1207;
 
8326
                                var $_sum17_i_i = $_sum_i16_i + 8 | 0;
 
8327
                                var $1254 = $tbase_243_i + $_sum17_i_i | 0;
 
8328
                                var $1255 = $1254;
 
8329
                                HEAP32[$1255 >> 2] = $1207;
 
8330
                              } else {
 
8331
                                var $1257 = HEAP32[$1236 >> 2];
 
8332
                                var $1258 = ($I7_0_i_i | 0) == 31;
 
8333
                                if ($1258) {
 
8334
                                  var $1263 = 0;
 
8335
                                } else {
 
8336
                                  var $1260 = $I7_0_i_i >>> 1;
 
8337
                                  var $1261 = 25 - $1260 | 0;
 
8338
                                  var $1263 = $1261;
 
8339
                                }
 
8340
                                var $1263;
 
8341
                                var $1264 = $qsize_0_i_i << $1263;
 
8342
                                var $K8_0_i_i = $1264;
 
8343
                                var $T_0_i21_i = $1257;
 
8344
                                while (1) {
 
8345
                                  var $T_0_i21_i;
 
8346
                                  var $K8_0_i_i;
 
8347
                                  var $1266 = $T_0_i21_i + 4 | 0;
 
8348
                                  var $1267 = HEAP32[$1266 >> 2];
 
8349
                                  var $1268 = $1267 & -8;
 
8350
                                  var $1269 = ($1268 | 0) == ($qsize_0_i_i | 0);
 
8351
                                  if ($1269) {
 
8352
                                    var $1289 = $T_0_i21_i + 8 | 0;
 
8353
                                    var $1290 = HEAP32[$1289 >> 2];
 
8354
                                    var $1291 = $T_0_i21_i;
 
8355
                                    var $1292 = HEAP32[(__gm_ + 16 | 0) >> 2];
 
8356
                                    var $1293 = $1291 >>> 0 < $1292 >>> 0;
 
8357
                                    do {
 
8358
                                      if (!$1293) {
 
8359
                                        var $1295 = $1290;
 
8360
                                        var $1296 = $1295 >>> 0 < $1292 >>> 0;
 
8361
                                        if ($1296) {
 
8362
                                          break;
 
8363
                                        }
 
8364
                                        var $1298 = $1290 + 12 | 0;
 
8365
                                        HEAP32[$1298 >> 2] = $1207;
 
8366
                                        HEAP32[$1289 >> 2] = $1207;
 
8367
                                        var $_sum20_i_i = $_sum_i16_i + 8 | 0;
 
8368
                                        var $1299 = $tbase_243_i + $_sum20_i_i | 0;
 
8369
                                        var $1300 = $1299;
 
8370
                                        HEAP32[$1300 >> 2] = $1290;
 
8371
                                        var $_sum21_i_i = $_sum_i16_i + 12 | 0;
 
8372
                                        var $1301 = $tbase_243_i + $_sum21_i_i | 0;
 
8373
                                        var $1302 = $1301;
 
8374
                                        HEAP32[$1302 >> 2] = $T_0_i21_i;
 
8375
                                        var $_sum22_i_i = $_sum_i16_i + 24 | 0;
 
8376
                                        var $1303 = $tbase_243_i + $_sum22_i_i | 0;
 
8377
                                        var $1304 = $1303;
 
8378
                                        HEAP32[$1304 >> 2] = 0;
 
8379
                                        break $_$314;
 
8380
                                      }
 
8381
                                    } while (0);
 
8382
                                    _abort();
 
8383
                                  } else {
 
8384
                                    var $1271 = $K8_0_i_i >>> 31;
 
8385
                                    var $1272 = $T_0_i21_i + 16 + ($1271 << 2) | 0;
 
8386
                                    var $1273 = HEAP32[$1272 >> 2];
 
8387
                                    var $1274 = ($1273 | 0) == 0;
 
8388
                                    var $1275 = $K8_0_i_i << 1;
 
8389
                                    if (!$1274) {
 
8390
                                      var $K8_0_i_i = $1275;
 
8391
                                      var $T_0_i21_i = $1273;
 
8392
                                      continue;
 
8393
                                    }
 
8394
                                    var $1277 = $1272;
 
8395
                                    var $1278 = HEAP32[(__gm_ + 16 | 0) >> 2];
 
8396
                                    var $1279 = $1277 >>> 0 < $1278 >>> 0;
 
8397
                                    if (!$1279) {
 
8398
                                      HEAP32[$1272 >> 2] = $1207;
 
8399
                                      var $_sum23_i_i = $_sum_i16_i + 24 | 0;
 
8400
                                      var $1281 = $tbase_243_i + $_sum23_i_i | 0;
 
8401
                                      var $1282 = $1281;
 
8402
                                      HEAP32[$1282 >> 2] = $T_0_i21_i;
 
8403
                                      var $_sum24_i_i = $_sum_i16_i + 12 | 0;
 
8404
                                      var $1283 = $tbase_243_i + $_sum24_i_i | 0;
 
8405
                                      var $1284 = $1283;
 
8406
                                      HEAP32[$1284 >> 2] = $1207;
 
8407
                                      var $_sum25_i_i = $_sum_i16_i + 8 | 0;
 
8408
                                      var $1285 = $tbase_243_i + $_sum25_i_i | 0;
 
8409
                                      var $1286 = $1285;
 
8410
                                      HEAP32[$1286 >> 2] = $1207;
 
8411
                                      break $_$314;
 
8412
                                    }
 
8413
                                    _abort();
 
8414
                                  }
 
8415
                                }
 
8416
                              }
 
8417
                            }
 
8418
                          }
 
8419
                        }
 
8420
                      } while (0);
 
8421
                      var $_sum1819_i_i = $981 | 8;
 
8422
                      var $1305 = $tbase_243_i + $_sum1819_i_i | 0;
 
8423
                      var $mem_0 = $1305;
 
8424
                      break $_$215;
 
8425
                    }
 
8426
                  } while (0);
 
8427
                  var $1306 = $876;
 
8428
                  var $sp_0_i_i_i = __gm_ + 444 | 0;
 
8429
                  while (1) {
 
8430
                    var $sp_0_i_i_i;
 
8431
                    var $1308 = $sp_0_i_i_i | 0;
 
8432
                    var $1309 = HEAP32[$1308 >> 2];
 
8433
                    var $1310 = $1309 >>> 0 > $1306 >>> 0;
 
8434
                    if (!$1310) {
 
8435
                      var $1312 = $sp_0_i_i_i + 4 | 0;
 
8436
                      var $1313 = HEAP32[$1312 >> 2];
 
8437
                      var $1314 = $1309 + $1313 | 0;
 
8438
                      var $1315 = $1314 >>> 0 > $1306 >>> 0;
 
8439
                      if ($1315) {
 
8440
                        var $1321 = $1309;
 
8441
                        var $1320 = $1313;
 
8442
                        break;
 
8443
                      }
 
8444
                    }
 
8445
                    var $1317 = $sp_0_i_i_i + 8 | 0;
 
8446
                    var $1318 = HEAP32[$1317 >> 2];
 
8447
                    var $1319 = ($1318 | 0) == 0;
 
8448
                    if (!$1319) {
 
8449
                      var $sp_0_i_i_i = $1318;
 
8450
                      continue;
 
8451
                    }
 
8452
                    var $_pre14_i_i = 4;
 
8453
                    var $1321 = 0;
 
8454
                    var $1320 = $_pre14_i_i;
 
8455
                    break;
 
8456
                  }
 
8457
                  var $1320;
 
8458
                  var $1321;
 
8459
                  var $1322 = $1321 + $1320 | 0;
 
8460
                  var $_sum1_i10_i = $1320 - 39 | 0;
 
8461
                  var $1323 = $1321 + $_sum1_i10_i | 0;
 
8462
                  var $1324 = $1323;
 
8463
                  var $1325 = $1324 & 7;
 
8464
                  var $1326 = ($1325 | 0) == 0;
 
8465
                  if ($1326) {
 
8466
                    var $1331 = 0;
 
8467
                  } else {
 
8468
                    var $1328 = -$1324 | 0;
 
8469
                    var $1329 = $1328 & 7;
 
8470
                    var $1331 = $1329;
 
8471
                  }
 
8472
                  var $1331;
 
8473
                  var $_sum_i11_i = $1320 - 47 | 0;
 
8474
                  var $_sum2_i12_i = $_sum_i11_i + $1331 | 0;
 
8475
                  var $1332 = $1321 + $_sum2_i12_i | 0;
 
8476
                  var $1333 = $876 + 16 | 0;
 
8477
                  var $1334 = $1333;
 
8478
                  var $1335 = $1332 >>> 0 < $1334 >>> 0;
 
8479
                  var $1336 = $1335 ? $1306 : $1332;
 
8480
                  var $1337 = $1336 + 8 | 0;
 
8481
                  var $1338 = $1337;
 
8482
                  var $1339 = $tbase_243_i + 8 | 0;
 
8483
                  var $1340 = $1339;
 
8484
                  var $1341 = $1340 & 7;
 
8485
                  var $1342 = ($1341 | 0) == 0;
 
8486
                  if ($1342) {
 
8487
                    var $1346 = 0;
 
8488
                  } else {
 
8489
                    var $1344 = -$1340 | 0;
 
8490
                    var $1345 = $1344 & 7;
 
8491
                    var $1346 = $1345;
 
8492
                  }
 
8493
                  var $1346;
 
8494
                  var $1347 = $tbase_243_i + $1346 | 0;
 
8495
                  var $1348 = $1347;
 
8496
                  var $1349 = $tsize_242_i - 40 | 0;
 
8497
                  var $1350 = $1349 - $1346 | 0;
 
8498
                  HEAP32[(__gm_ + 24 | 0) >> 2] = $1348;
 
8499
                  HEAP32[(__gm_ + 12 | 0) >> 2] = $1350;
 
8500
                  var $1351 = $1350 | 1;
 
8501
                  var $_sum_i_i_i = $1346 + 4 | 0;
 
8502
                  var $1352 = $tbase_243_i + $_sum_i_i_i | 0;
 
8503
                  var $1353 = $1352;
 
8504
                  HEAP32[$1353 >> 2] = $1351;
 
8505
                  var $_sum2_i_i_i = $tsize_242_i - 36 | 0;
 
8506
                  var $1354 = $tbase_243_i + $_sum2_i_i_i | 0;
 
8507
                  var $1355 = $1354;
 
8508
                  HEAP32[$1355 >> 2] = 40;
 
8509
                  var $1356 = HEAP32[(_mparams + 16 | 0) >> 2];
 
8510
                  HEAP32[(__gm_ + 28 | 0) >> 2] = $1356;
 
8511
                  var $1357 = $1336 + 4 | 0;
 
8512
                  var $1358 = $1357;
 
8513
                  HEAP32[$1358 >> 2] = 27;
 
8514
                  HEAP32[$1337 >> 2] = HEAP32[(__gm_ + 444 | 0) >> 2];
 
8515
                  HEAP32[$1337 + 4 >> 2] = HEAP32[(__gm_ + 444 | 0) + 4 >> 2];
 
8516
                  HEAP32[$1337 + 8 >> 2] = HEAP32[(__gm_ + 444 | 0) + 8 >> 2];
 
8517
                  HEAP32[$1337 + 12 >> 2] = HEAP32[(__gm_ + 444 | 0) + 12 >> 2];
 
8518
                  HEAP32[(__gm_ + 444 | 0) >> 2] = $tbase_243_i;
 
8519
                  HEAP32[(__gm_ + 448 | 0) >> 2] = $tsize_242_i;
 
8520
                  HEAP32[(__gm_ + 456 | 0) >> 2] = 0;
 
8521
                  HEAP32[(__gm_ + 452 | 0) >> 2] = $1338;
 
8522
                  var $1359 = $1336 + 28 | 0;
 
8523
                  var $1360 = $1359;
 
8524
                  HEAP32[$1360 >> 2] = 7;
 
8525
                  var $1361 = $1336 + 32 | 0;
 
8526
                  var $1362 = $1361 >>> 0 < $1322 >>> 0;
 
8527
                  $_$426 : do {
 
8528
                    if ($1362) {
 
8529
                      var $1363 = $1360;
 
8530
                      while (1) {
 
8531
                        var $1363;
 
8532
                        var $1364 = $1363 + 4 | 0;
 
8533
                        HEAP32[$1364 >> 2] = 7;
 
8534
                        var $1365 = $1363 + 8 | 0;
 
8535
                        var $1366 = $1365;
 
8536
                        var $1367 = $1366 >>> 0 < $1322 >>> 0;
 
8537
                        if (!$1367) {
 
8538
                          break $_$426;
 
8539
                        }
 
8540
                        var $1363 = $1364;
 
8541
                      }
 
8542
                    }
 
8543
                  } while (0);
 
8544
                  var $1368 = ($1336 | 0) == ($1306 | 0);
 
8545
                  if ($1368) {
 
8546
                    break;
 
8547
                  }
 
8548
                  var $1370 = $1336;
 
8549
                  var $1371 = $876;
 
8550
                  var $1372 = $1370 - $1371 | 0;
 
8551
                  var $1373 = $1306 + $1372 | 0;
 
8552
                  var $_sum3_i_i = $1372 + 4 | 0;
 
8553
                  var $1374 = $1306 + $_sum3_i_i | 0;
 
8554
                  var $1375 = $1374;
 
8555
                  var $1376 = HEAP32[$1375 >> 2];
 
8556
                  var $1377 = $1376 & -2;
 
8557
                  HEAP32[$1375 >> 2] = $1377;
 
8558
                  var $1378 = $1372 | 1;
 
8559
                  var $1379 = $876 + 4 | 0;
 
8560
                  HEAP32[$1379 >> 2] = $1378;
 
8561
                  var $1380 = $1373;
 
8562
                  HEAP32[$1380 >> 2] = $1372;
 
8563
                  var $1381 = $1372 >>> 0 < 256;
 
8564
                  if ($1381) {
 
8565
                    var $1383 = $1372 >>> 3;
 
8566
                    var $1384 = $1372 >>> 2;
 
8567
                    var $1385 = $1384 & 1073741822;
 
8568
                    var $1386 = __gm_ + 40 + ($1385 << 2) | 0;
 
8569
                    var $1387 = $1386;
 
8570
                    var $1388 = HEAP32[(__gm_ | 0) >> 2];
 
8571
                    var $1389 = 1 << $1383;
 
8572
                    var $1390 = $1388 & $1389;
 
8573
                    var $1391 = ($1390 | 0) == 0;
 
8574
                    do {
 
8575
                      if ($1391) {
 
8576
                        var $1393 = $1388 | $1389;
 
8577
                        HEAP32[(__gm_ | 0) >> 2] = $1393;
 
8578
                        var $_sum10_pre_i_i = $1385 + 2 | 0;
 
8579
                        var $_pre15_i_i = __gm_ + 40 + ($_sum10_pre_i_i << 2) | 0;
 
8580
                        var $F_0_i_i = $1387;
 
8581
                        var $_pre_phi_i_i = $_pre15_i_i;
 
8582
                      } else {
 
8583
                        var $_sum11_i_i = $1385 + 2 | 0;
 
8584
                        var $1395 = __gm_ + 40 + ($_sum11_i_i << 2) | 0;
 
8585
                        var $1396 = HEAP32[$1395 >> 2];
 
8586
                        var $1397 = $1396;
 
8587
                        var $1398 = HEAP32[(__gm_ + 16 | 0) >> 2];
 
8588
                        var $1399 = $1397 >>> 0 < $1398 >>> 0;
 
8589
                        if (!$1399) {
 
8590
                          var $F_0_i_i = $1396;
 
8591
                          var $_pre_phi_i_i = $1395;
 
8592
                          break;
 
8593
                        }
 
8594
                        _abort();
 
8595
                      }
 
8596
                    } while (0);
 
8597
                    var $_pre_phi_i_i;
 
8598
                    var $F_0_i_i;
 
8599
                    HEAP32[$_pre_phi_i_i >> 2] = $876;
 
8600
                    var $1402 = $F_0_i_i + 12 | 0;
 
8601
                    HEAP32[$1402 >> 2] = $876;
 
8602
                    var $1403 = $876 + 8 | 0;
 
8603
                    HEAP32[$1403 >> 2] = $F_0_i_i;
 
8604
                    var $1404 = $876 + 12 | 0;
 
8605
                    HEAP32[$1404 >> 2] = $1387;
 
8606
                  } else {
 
8607
                    var $1406 = $876;
 
8608
                    var $1407 = $1372 >>> 8;
 
8609
                    var $1408 = ($1407 | 0) == 0;
 
8610
                    do {
 
8611
                      if ($1408) {
 
8612
                        var $I1_0_i_i = 0;
 
8613
                      } else {
 
8614
                        var $1410 = $1372 >>> 0 > 16777215;
 
8615
                        if ($1410) {
 
8616
                          var $I1_0_i_i = 31;
 
8617
                          break;
 
8618
                        }
 
8619
                        var $1412 = $1407 + 1048320 | 0;
 
8620
                        var $1413 = $1412 >>> 16;
 
8621
                        var $1414 = $1413 & 8;
 
8622
                        var $1415 = $1407 << $1414;
 
8623
                        var $1416 = $1415 + 520192 | 0;
 
8624
                        var $1417 = $1416 >>> 16;
 
8625
                        var $1418 = $1417 & 4;
 
8626
                        var $1419 = $1415 << $1418;
 
8627
                        var $1420 = $1419 + 245760 | 0;
 
8628
                        var $1421 = $1420 >>> 16;
 
8629
                        var $1422 = $1421 & 2;
 
8630
                        var $1423 = $1418 | $1414;
 
8631
                        var $1424 = $1423 | $1422;
 
8632
                        var $1425 = 14 - $1424 | 0;
 
8633
                        var $1426 = $1419 << $1422;
 
8634
                        var $1427 = $1426 >>> 15;
 
8635
                        var $1428 = $1425 + $1427 | 0;
 
8636
                        var $1429 = $1428 << 1;
 
8637
                        var $1430 = $1428 + 7 | 0;
 
8638
                        var $1431 = $1372 >>> ($1430 >>> 0);
 
8639
                        var $1432 = $1431 & 1;
 
8640
                        var $1433 = $1432 | $1429;
 
8641
                        var $I1_0_i_i = $1433;
 
8642
                      }
 
8643
                    } while (0);
 
8644
                    var $I1_0_i_i;
 
8645
                    var $1435 = __gm_ + 304 + ($I1_0_i_i << 2) | 0;
 
8646
                    var $1436 = $876 + 28 | 0;
 
8647
                    var $I1_0_c_i_i = $I1_0_i_i;
 
8648
                    HEAP32[$1436 >> 2] = $I1_0_c_i_i;
 
8649
                    var $1437 = $876 + 20 | 0;
 
8650
                    HEAP32[$1437 >> 2] = 0;
 
8651
                    var $1438 = $876 + 16 | 0;
 
8652
                    HEAP32[$1438 >> 2] = 0;
 
8653
                    var $1439 = HEAP32[(__gm_ + 4 | 0) >> 2];
 
8654
                    var $1440 = 1 << $I1_0_i_i;
 
8655
                    var $1441 = $1439 & $1440;
 
8656
                    var $1442 = ($1441 | 0) == 0;
 
8657
                    if ($1442) {
 
8658
                      var $1444 = $1439 | $1440;
 
8659
                      HEAP32[(__gm_ + 4 | 0) >> 2] = $1444;
 
8660
                      HEAP32[$1435 >> 2] = $1406;
 
8661
                      var $1445 = $876 + 24 | 0;
 
8662
                      var $_c_i_i = $1435;
 
8663
                      HEAP32[$1445 >> 2] = $_c_i_i;
 
8664
                      var $1446 = $876 + 12 | 0;
 
8665
                      HEAP32[$1446 >> 2] = $876;
 
8666
                      var $1447 = $876 + 8 | 0;
 
8667
                      HEAP32[$1447 >> 2] = $876;
 
8668
                    } else {
 
8669
                      var $1449 = HEAP32[$1435 >> 2];
 
8670
                      var $1450 = ($I1_0_i_i | 0) == 31;
 
8671
                      if ($1450) {
 
8672
                        var $1455 = 0;
 
8673
                      } else {
 
8674
                        var $1452 = $I1_0_i_i >>> 1;
 
8675
                        var $1453 = 25 - $1452 | 0;
 
8676
                        var $1455 = $1453;
 
8677
                      }
 
8678
                      var $1455;
 
8679
                      var $1456 = $1372 << $1455;
 
8680
                      var $K2_0_i_i = $1456;
 
8681
                      var $T_0_i_i = $1449;
 
8682
                      while (1) {
 
8683
                        var $T_0_i_i;
 
8684
                        var $K2_0_i_i;
 
8685
                        var $1458 = $T_0_i_i + 4 | 0;
 
8686
                        var $1459 = HEAP32[$1458 >> 2];
 
8687
                        var $1460 = $1459 & -8;
 
8688
                        var $1461 = ($1460 | 0) == ($1372 | 0);
 
8689
                        if ($1461) {
 
8690
                          var $1478 = $T_0_i_i + 8 | 0;
 
8691
                          var $1479 = HEAP32[$1478 >> 2];
 
8692
                          var $1480 = $T_0_i_i;
 
8693
                          var $1481 = HEAP32[(__gm_ + 16 | 0) >> 2];
 
8694
                          var $1482 = $1480 >>> 0 < $1481 >>> 0;
 
8695
                          do {
 
8696
                            if (!$1482) {
 
8697
                              var $1484 = $1479;
 
8698
                              var $1485 = $1484 >>> 0 < $1481 >>> 0;
 
8699
                              if ($1485) {
 
8700
                                break;
 
8701
                              }
 
8702
                              var $1487 = $1479 + 12 | 0;
 
8703
                              HEAP32[$1487 >> 2] = $1406;
 
8704
                              HEAP32[$1478 >> 2] = $1406;
 
8705
                              var $1488 = $876 + 8 | 0;
 
8706
                              var $_c6_i_i = $1479;
 
8707
                              HEAP32[$1488 >> 2] = $_c6_i_i;
 
8708
                              var $1489 = $876 + 12 | 0;
 
8709
                              var $T_0_c_i_i = $T_0_i_i;
 
8710
                              HEAP32[$1489 >> 2] = $T_0_c_i_i;
 
8711
                              var $1490 = $876 + 24 | 0;
 
8712
                              HEAP32[$1490 >> 2] = 0;
 
8713
                              break $_$275;
 
8714
                            }
 
8715
                          } while (0);
 
8716
                          _abort();
 
8717
                        } else {
 
8718
                          var $1463 = $K2_0_i_i >>> 31;
 
8719
                          var $1464 = $T_0_i_i + 16 + ($1463 << 2) | 0;
 
8720
                          var $1465 = HEAP32[$1464 >> 2];
 
8721
                          var $1466 = ($1465 | 0) == 0;
 
8722
                          var $1467 = $K2_0_i_i << 1;
 
8723
                          if (!$1466) {
 
8724
                            var $K2_0_i_i = $1467;
 
8725
                            var $T_0_i_i = $1465;
 
8726
                            continue;
 
8727
                          }
 
8728
                          var $1469 = $1464;
 
8729
                          var $1470 = HEAP32[(__gm_ + 16 | 0) >> 2];
 
8730
                          var $1471 = $1469 >>> 0 < $1470 >>> 0;
 
8731
                          if (!$1471) {
 
8732
                            HEAP32[$1464 >> 2] = $1406;
 
8733
                            var $1473 = $876 + 24 | 0;
 
8734
                            var $T_0_c7_i_i = $T_0_i_i;
 
8735
                            HEAP32[$1473 >> 2] = $T_0_c7_i_i;
 
8736
                            var $1474 = $876 + 12 | 0;
 
8737
                            HEAP32[$1474 >> 2] = $876;
 
8738
                            var $1475 = $876 + 8 | 0;
 
8739
                            HEAP32[$1475 >> 2] = $876;
 
8740
                            break $_$275;
 
8741
                          }
 
8742
                          _abort();
 
8743
                        }
 
8744
                      }
 
8745
                    }
 
8746
                  }
 
8747
                }
 
8748
              } while (0);
 
8749
              var $1491 = HEAP32[(__gm_ + 12 | 0) >> 2];
 
8750
              var $1492 = $1491 >>> 0 > $nb_0 >>> 0;
 
8751
              if (!$1492) {
 
8752
                break;
 
8753
              }
 
8754
              var $1494 = $1491 - $nb_0 | 0;
 
8755
              HEAP32[(__gm_ + 12 | 0) >> 2] = $1494;
 
8756
              var $1495 = HEAP32[(__gm_ + 24 | 0) >> 2];
 
8757
              var $1496 = $1495;
 
8758
              var $1497 = $1496 + $nb_0 | 0;
 
8759
              var $1498 = $1497;
 
8760
              HEAP32[(__gm_ + 24 | 0) >> 2] = $1498;
 
8761
              var $1499 = $1494 | 1;
 
8762
              var $_sum_i30 = $nb_0 + 4 | 0;
 
8763
              var $1500 = $1496 + $_sum_i30 | 0;
 
8764
              var $1501 = $1500;
 
8765
              HEAP32[$1501 >> 2] = $1499;
 
8766
              var $1502 = $nb_0 | 3;
 
8767
              var $1503 = $1495 + 4 | 0;
 
8768
              HEAP32[$1503 >> 2] = $1502;
 
8769
              var $1504 = $1495 + 8 | 0;
 
8770
              var $1505 = $1504;
 
8771
              var $mem_0 = $1505;
 
8772
              break $_$215;
 
8773
            }
 
8774
          } while (0);
 
8775
          var $1506 = ___errno();
 
8776
          HEAP32[$1506 >> 2] = 12;
 
8777
          var $mem_0 = 0;
 
8778
        }
 
8779
      } else {
 
8780
        var $706 = $703 - $nb_0 | 0;
 
8781
        var $707 = HEAP32[(__gm_ + 20 | 0) >> 2];
 
8782
        var $708 = $706 >>> 0 > 15;
 
8783
        if ($708) {
 
8784
          var $710 = $707;
 
8785
          var $711 = $710 + $nb_0 | 0;
 
8786
          var $712 = $711;
 
8787
          HEAP32[(__gm_ + 20 | 0) >> 2] = $712;
 
8788
          HEAP32[(__gm_ + 8 | 0) >> 2] = $706;
 
8789
          var $713 = $706 | 1;
 
8790
          var $_sum2 = $nb_0 + 4 | 0;
 
8791
          var $714 = $710 + $_sum2 | 0;
 
8792
          var $715 = $714;
 
8793
          HEAP32[$715 >> 2] = $713;
 
8794
          var $716 = $710 + $703 | 0;
 
8795
          var $717 = $716;
 
8796
          HEAP32[$717 >> 2] = $706;
 
8797
          var $718 = $nb_0 | 3;
 
8798
          var $719 = $707 + 4 | 0;
 
8799
          HEAP32[$719 >> 2] = $718;
 
8800
        } else {
 
8801
          HEAP32[(__gm_ + 8 | 0) >> 2] = 0;
 
8802
          HEAP32[(__gm_ + 20 | 0) >> 2] = 0;
 
8803
          var $721 = $703 | 3;
 
8804
          var $722 = $707 + 4 | 0;
 
8805
          HEAP32[$722 >> 2] = $721;
 
8806
          var $723 = $707;
 
8807
          var $_sum1 = $703 + 4 | 0;
 
8808
          var $724 = $723 + $_sum1 | 0;
 
8809
          var $725 = $724;
 
8810
          var $726 = HEAP32[$725 >> 2];
 
8811
          var $727 = $726 | 1;
 
8812
          HEAP32[$725 >> 2] = $727;
 
8813
        }
 
8814
        var $729 = $707 + 8 | 0;
 
8815
        var $730 = $729;
 
8816
        var $mem_0 = $730;
 
8817
      }
 
8818
    }
 
8819
  } while (0);
 
8820
  var $mem_0;
 
8821
  return $mem_0;
 
8822
  return null;
 
8823
}
 
8824
function asm(x, y) { // asm-style code, without special asm requested so will not be fully optimized
 
8825
  x = +x;
 
8826
  y = y|0;
 
8827
  var a = 0, b = +0, c = 0;
 
8828
  var label = 0;
 
8829
  a = cheez((y+~~x)|0)|0;
 
8830
  b = a*a;
 
8831
  fleefl(b|0, a|0);
 
8832
}
 
8833
function phi() {
 
8834
  if (wat()) {
 
8835
    var $10 = 1;
 
8836
  } else {
 
8837
    var $7=_init_mparams();
 
8838
    var $8=(($7)|0)!=0;
 
8839
    var $10 = $8;
 
8840
  }
 
8841
  var $10;
 
8842
}
 
8843
function intoCond() {
 
8844
  var $115 = 22;
 
8845
  var $499 = __ZN4llvm15BitstreamCursor4ReadEj($117, 32);
 
8846
  var $NumWords = $499;
 
8847
  var $500 = $115;
 
8848
  var $501 = ($500 | 0) != 0;
 
8849
  if ($501) {
 
8850
    var $503 = $NumWords;
 
8851
    var $504 = $115;
 
8852
    HEAP32[$504 >> 2] = $503;
 
8853
  }
 
8854
}
 
8855
// EMSCRIPTEN_GENERATED_FUNCTIONS: ["a", "b", "c", "f", "g", "h", "py", "r", "t", "f2", "f3", "llvm3_1", "_inflate", "_malloc", "_mallocNoU", "asm", "phi", "intoCond"]
 
8856