update tests

1 files changed, 8629 insertions, 8629 deletions

diff --git a/tools/eliminator/eliminator-test.js b/tools/eliminator/eliminator-test.js
index 3edd61ac..ffad69ea 100644
--- a/tools/eliminator/eliminator-test.js
+++ b/tools/eliminator/eliminator-test.js
@@ -1,8856 +1,8856 @@
 function a($directory) {
-  var $1 = _strlen($directory);
-  var $p_0 = $directory + $1 | 0;
-  chak($p_0);
-  var $210 = HEAP32[100]; // heaps alias each other! so this cannot be eliminated
-  HEAP32[1e3] = HEAP32[5];
-  HEAP32[90] = $210;
-  chak();
-  var $210a = HEAP32[100]; // function calls can also modify memory
-  something();
-  HEAP32[90] = $210a;
-  chak();
-  var $a = $hack; // no mem use (just a global), so ok to eliminate
-  HEAP32[1e3] = HEAP32[5];
-  HEAP32[90] = $a;
-  chak();
-  var $bb = HEAP32[11]; // ok to eliminate
-  var $b = ($bb+7)|0; // ok to eliminate by itself, but not with inlined $bb which is mem-using!
-  HEAP32[1e3] = HEAP32[5];
-  HEAP32[90] = $b;
-  chak();
-  var $bb2 = HEAP32[11];
-  HEAP32[111] = 321;
-  var $b2 = ($bb2+7)|0;
-  HEAP32[1e3] = HEAP32[5];
-  HEAP32[90] = $b2;
-  chak();
-  var $d = HEAP32[100]; // alias on next line, but that is where we are consumed - so ok.
-  HEAP32[1e3] = $d;
-  chak();
-  var $e = func();
-  HEAP32[1e3] = $e;
-  chak();
-  var $e2 = func();
-  tor($e2);
-  chak();
-  var $e3 = HEAP[9];
-  tor($e3);
-  barrier(); // same stuff, but with a var on top and assigns as the first and only def
-  var $$210, $$210a, $$a, $$bb, $$b, $$bb2, $$b2, $$d, $$e, $$e2, $$e3;
-  $$210 = HEAP32[100]; // heaps alias each other! so this cannot be eliminated
-  HEAP32[1e3] = HEAP32[5];
-  HEAP32[90] = $$210;
-  chak();
-  $$210a = HEAP32[100]; // function calls can also modify memory
-  something();
-  HEAP32[90] = $$210a;
-  chak();
-  $$a = $$hack; // no mem use, so ok to eliminate
-  HEAP32[1e3] = HEAP32[5];
-  HEAP32[90] = $$a;
-  chak();
-  $$bb = HEAP32[11]; // ok to eliminate
-  $$b = ($$bb+7)|0; // ok to eliminate by itself, but not with inlined $$bb which is mem-using!
-  HEAP32[1e3] = HEAP32[5];
-  HEAP32[90] = $$b;
-  chak();
-  $$bb2 = HEAP32[11];
-  HEAP32[111] = 321;
-  $$b2 = ($$bb2+7)|0;
-  HEAP32[1e3] = HEAP32[5];
-  HEAP32[90] = $$b2;
-  chak();
-  $$d = HEAP32[100]; // alias on next line, but that is where we are consumed - so ok.
-  HEAP32[1e3] = $$d;
-  chak();
-  $$e = func();
-  HEAP32[1e3] = $$e;
-  chak();
-  $$e2 = func();
-  tor($$e2);
-  chak();
-  $$e3 = HEAP[9];
-  tor($$e3);
-  barrier();
-  var $65, $image, $51$s2, $71;
-  var $66 = HEAP32[$65 >> 2];
-  var $71 = $66 - _int_ceildiv(HEAP32[$image >> 2], HEAP32[$51$s2]) | 0;
-  HEAP32[$65 >> 2] = _int_ceildivpow2($71, HEAP32[$51$s2 + 10]);
-  barr();
-  var ONCE = sheep();
-  while (ONCE) {
-    work();
-  }
-  var ONCEb = 75;
-  while (ONCEb) {
-    work();
-  }
-  var $26 = __ZL3minIiET_S0_S0_12(4096, 4096 - $16 | 0); // cannot eliminate this because the call might modify FUNCTION_TABLE
-  var $27 = FUNCTION_TABLE[$22]($18, $this + ($16 + 27) | 0, $26);
-  print($27);
-  chak();
-  var zzz = 10;
-  do {
-    print(zzz);
-  } while (0);
-  var zzz1 = 10;
-  do {
-    print(zzz1);
-  } while (1); // cannot eliminate a do-while that is not one-time
+ var $1 = _strlen($directory);
+ var $p_0 = $directory + $1 | 0;
+ chak($p_0);
+ var $210 = HEAP32[100]; // heaps alias each other! so this cannot be eliminated
+ HEAP32[1e3] = HEAP32[5];
+ HEAP32[90] = $210;
+ chak();
+ var $210a = HEAP32[100]; // function calls can also modify memory
+ something();
+ HEAP32[90] = $210a;
+ chak();
+ var $a = $hack; // no mem use (just a global), so ok to eliminate
+ HEAP32[1e3] = HEAP32[5];
+ HEAP32[90] = $a;
+ chak();
+ var $bb = HEAP32[11]; // ok to eliminate
+ var $b = ($bb+7)|0; // ok to eliminate by itself, but not with inlined $bb which is mem-using!
+ HEAP32[1e3] = HEAP32[5];
+ HEAP32[90] = $b;
+ chak();
+ var $bb2 = HEAP32[11];
+ HEAP32[111] = 321;
+ var $b2 = ($bb2+7)|0;
+ HEAP32[1e3] = HEAP32[5];
+ HEAP32[90] = $b2;
+ chak();
+ var $d = HEAP32[100]; // alias on next line, but that is where we are consumed - so ok.
+ HEAP32[1e3] = $d;
+ chak();
+ var $e = func();
+ HEAP32[1e3] = $e;
+ chak();
+ var $e2 = func();
+ tor($e2);
+ chak();
+ var $e3 = HEAP[9];
+ tor($e3);
+ barrier(); // same stuff, but with a var on top and assigns as the first and only def
+ var $$210, $$210a, $$a, $$bb, $$b, $$bb2, $$b2, $$d, $$e, $$e2, $$e3;
+ $$210 = HEAP32[100]; // heaps alias each other! so this cannot be eliminated
+ HEAP32[1e3] = HEAP32[5];
+ HEAP32[90] = $$210;
+ chak();
+ $$210a = HEAP32[100]; // function calls can also modify memory
+ something();
+ HEAP32[90] = $$210a;
+ chak();
+ $$a = $$hack; // no mem use, so ok to eliminate
+ HEAP32[1e3] = HEAP32[5];
+ HEAP32[90] = $$a;
+ chak();
+ $$bb = HEAP32[11]; // ok to eliminate
+ $$b = ($$bb+7)|0; // ok to eliminate by itself, but not with inlined $$bb which is mem-using!
+ HEAP32[1e3] = HEAP32[5];
+ HEAP32[90] = $$b;
+ chak();
+ $$bb2 = HEAP32[11];
+ HEAP32[111] = 321;
+ $$b2 = ($$bb2+7)|0;
+ HEAP32[1e3] = HEAP32[5];
+ HEAP32[90] = $$b2;
+ chak();
+ $$d = HEAP32[100]; // alias on next line, but that is where we are consumed - so ok.
+ HEAP32[1e3] = $$d;
+ chak();
+ $$e = func();
+ HEAP32[1e3] = $$e;
+ chak();
+ $$e2 = func();
+ tor($$e2);
+ chak();
+ $$e3 = HEAP[9];
+ tor($$e3);
+ barrier();
+ var $65, $image, $51$s2, $71;
+ var $66 = HEAP32[$65 >> 2];
+ var $71 = $66 - _int_ceildiv(HEAP32[$image >> 2], HEAP32[$51$s2]) | 0;
+ HEAP32[$65 >> 2] = _int_ceildivpow2($71, HEAP32[$51$s2 + 10]);
+ barr();
+ var ONCE = sheep();
+ while (ONCE) {
+  work();
+ }
+ var ONCEb = 75;
+ while (ONCEb) {
+  work();
+ }
+ var $26 = __ZL3minIiET_S0_S0_12(4096, 4096 - $16 | 0); // cannot eliminate this because the call might modify FUNCTION_TABLE
+ var $27 = FUNCTION_TABLE[$22]($18, $this + ($16 + 27) | 0, $26);
+ print($27);
+ chak();
+ var zzz = 10;
+ do {
+  print(zzz);
+ } while (0);
+ var zzz1 = 10;
+ do {
+  print(zzz1);
+ } while (1); // cannot eliminate a do-while that is not one-time
 }
 function b() {
-  var $148 = _sqlite3Strlen30($147);
-  var $150 = HEAP32[$pExpr + 16 >> 2];
-  if (($150 | 0) == 0) {
-    var $156 = 0;
-  } else {
-    var $156 = HEAP32[$150 >> 2];
-  }
-  var $156;
-  HEAP32[$139 + ($136 << 4) + 4 >> 2] = _sqlite3FindFunction($145, $147, $148, $156, $135, 0);
-  farr();
-  var $a = f1();
-  var $b = f2() + $a; // this could be reordered to facilitate optimization
-  f3($b);
-  farr();
-  var finality = cheez();
-  return finality;
+ var $148 = _sqlite3Strlen30($147);
+ var $150 = HEAP32[$pExpr + 16 >> 2];
+ if (($150 | 0) == 0) {
+  var $156 = 0;
+ } else {
+  var $156 = HEAP32[$150 >> 2];
+ }
+ var $156;
+ HEAP32[$139 + ($136 << 4) + 4 >> 2] = _sqlite3FindFunction($145, $147, $148, $156, $135, 0);
+ farr();
+ var $a = f1();
+ var $b = f2() + $a; // this could be reordered to facilitate optimization
+ f3($b);
+ farr();
+ var finality = cheez();
+ return finality;
 }
 function c() {
-  var x = MEM[100], y = callMe(5), z = glob; // do not eliminate vars with multiple variables, if there is a call!
-  var w = x*2;
-  zoom(z);
-  hail(w);
-  sunk(y);
-  barrier();
-  var x2 = MEM[100], y2 = $callMe2, z2 = glob; // no call, so ok
-  var w2 = x2*2;
-  zoom(z2);
-  hail(w2);
-  sunk(y2);
-  var fly = you(fools);
-  var one, two = three(); // more than one var here, so cannot eliminate |two=|, oh well
-  var noneed;
-  noneed = fools(you);
-  var noneed2;
-  noneed2 += fools(you2);
-  return;
+ var x = MEM[100], y = callMe(5), z = glob; // do not eliminate vars with multiple variables, if there is a call!
+ var w = x*2;
+ zoom(z);
+ hail(w);
+ sunk(y);
+ barrier();
+ var x2 = MEM[100], y2 = $callMe2, z2 = glob; // no call, so ok
+ var w2 = x2*2;
+ zoom(z2);
+ hail(w2);
+ sunk(y2);
+ var fly = you(fools);
+ var one, two = three(); // more than one var here, so cannot eliminate |two=|, oh well
+ var noneed;
+ noneed = fools(you);
+ var noneed2;
+ noneed2 += fools(you2);
+ return;
 }
 function f() {
-  var unused;
-  var x = GLOB[1];
-  var y = x + 1;
-  var z = y / 2;
-  HEAP[123] = z;
+ var unused;
+ var x = GLOB[1];
+ var y = x + 1;
+ var z = y / 2;
+ HEAP[123] = z;
 }
 function g(a1, a2) {
-  var a = 1;
-  var b = a * 2;
-  var c = b - 1;
-  var qqq = "qwe";
-  a = c;
-  foo(c);
-  var ww = 1, www, zzz = 2;
-  foo(zzz);
-  for (var i = 0; i < 5; i++) {
-    var q = {
-      a: 1
-    } + [ 2, 3 ];
-  }
-  for (var iterator in SOME_GLOBAL) {
-    quux(iterator);
-  }
-  var $0 = HEAP[5];
-  MAYBE_HEAP[myglobal] = 123;
-  var $1 = $0 < 0;
-  if ($1) {
-    __label__ = 1;
-  } else {
-    __label__ = 2;
-  }
-  var sadijn = new asd;
-  sadijn2 = "qwe%sert";
-  this.Module || (this.Module = {});
-  var obj = {
-    'quoted': 1,
-    "doublequoted": 2,
-    unquoted: 3,
-    4: 5
-  };
+ var a = 1;
+ var b = a * 2;
+ var c = b - 1;
+ var qqq = "qwe";
+ a = c;
+ foo(c);
+ var ww = 1, www, zzz = 2;
+ foo(zzz);
+ for (var i = 0; i < 5; i++) {
+  var q = {
+   a: 1
+  } + [ 2, 3 ];
+ }
+ for (var iterator in SOME_GLOBAL) {
+  quux(iterator);
+ }
+ var $0 = HEAP[5];
+ MAYBE_HEAP[myglobal] = 123;
+ var $1 = $0 < 0;
+ if ($1) {
+  __label__ = 1;
+ } else {
+  __label__ = 2;
+ }
+ var sadijn = new asd;
+ sadijn2 = "qwe%sert";
+ this.Module || (this.Module = {});
+ var obj = {
+  'quoted': 1,
+  "doublequoted": 2,
+  unquoted: 3,
+  4: 5
+ };
 }
 function h() {
-  var out;
-  bar(hello);
-  var hello = 5;
-  if (0) {
-    var sb1 = 21;
-  }
-  out = sb1;
-  if (0) {
-    var sb2 = 23;
-  } else {
-    out = sb2;
-  }
-  if (0) {
-    out = sb3;
-  } else {
-    var sb3 = 23;
-  }
-  for (var it = 0; it < 5; it++) {
-    x = y ? x + 1 : 7;
-    var x = -5;
-  }
-  var oneUse = glob; // for now, cannot eliminate into body or else of if
-  if (1) {
-    otherGlob = oneUse;
-    breakMe();
-  }
-  var oneUse2 = glob2;
-  while (1) {
-    otherGlob2 = oneUse2;
-    breakMe();
-  }
-  return out;
+ var out;
+ bar(hello);
+ var hello = 5;
+ if (0) {
+  var sb1 = 21;
+ }
+ out = sb1;
+ if (0) {
+  var sb2 = 23;
+ } else {
+  out = sb2;
+ }
+ if (0) {
+  out = sb3;
+ } else {
+  var sb3 = 23;
+ }
+ for (var it = 0; it < 5; it++) {
+  x = y ? x + 1 : 7;
+  var x = -5;
+ }
+ var oneUse = glob; // for now, cannot eliminate into body or else of if
+ if (1) {
+  otherGlob = oneUse;
+  breakMe();
+ }
+ var oneUse2 = glob2;
+ while (1) {
+  otherGlob2 = oneUse2;
+  breakMe();
+ }
+ return out;
 }
 function strtok_part(b, j, f) {
-  var a;
-  for (;;) {
-    h = a == 13 ? h : 0;
-    a = HEAP[d + h];
-    if (a == g != 0) break;
-    var h = h + 1;
-    if (a != 0) a = 13;
-  }
+ var a;
+ for (;;) {
+  h = a == 13 ? h : 0;
+  a = HEAP[d + h];
+  if (a == g != 0) break;
+  var h = h + 1;
+  if (a != 0) a = 13;
+ }
 }
 function py() {
-  var $4 = HEAP[__PyThreadState_Current];
-  var $5 = $4 + 12;
-  var $7 = HEAP[$5] + 1;
-  var $8 = $7 + 12;
-  HEAP[$8] = 99;
+ var $4 = HEAP[__PyThreadState_Current];
+ var $5 = $4 + 12;
+ var $7 = HEAP[$5] + 1;
+ var $8 = $7 + 12;
+ HEAP[$8] = 99;
 }
 var anon = function(x) {
-  var $4 = HEAP[__PyThreadState_Current];
-  var $5 = $4 + 12;
-  var $7 = HEAP[$5] + 1;
-  var $8 = $4 + 12;
-  HEAP[$8] = $7;
+ var $4 = HEAP[__PyThreadState_Current];
+ var $5 = $4 + 12;
+ var $7 = HEAP[$5] + 1;
+ var $8 = $4 + 12;
+ HEAP[$8] = $7;
 }
 function r($0) {
-  HEAP[$0 + 5 + 2] = 99+5+2+1;
+ HEAP[$0 + 5 + 2] = 99+5+2+1;
 }
 function t() {
-  var $cmp2=($10) < ($11);
-  if ($cmp2) { __label__ = 3; }
-  var $cmp3=($12) < ($13);
-  if (!($cmp3)) { __label__ = 4; }
+ var $cmp2=($10) < ($11);
+ if ($cmp2) { __label__ = 3; }
+ var $cmp3=($12) < ($13);
+ if (!($cmp3)) { __label__ = 4; }
 }
 function f2() {
-  var $arrayidx64_phi_trans_insert = $vla + ($storemerge312 << 2) | 0;
-  var $_pre = HEAPU32[$arrayidx64_phi_trans_insert >> 2];
-  var $phitmp = $storemerge312 + 1 | 0;
-  var $storemerge312 = $phitmp;
-  var $8 = $_pre;
-  c($8);
+ var $arrayidx64_phi_trans_insert = $vla + ($storemerge312 << 2) | 0;
+ var $_pre = HEAPU32[$arrayidx64_phi_trans_insert >> 2];
+ var $phitmp = $storemerge312 + 1 | 0;
+ var $storemerge312 = $phitmp;
+ var $8 = $_pre;
+ c($8);
 }
 function f3($s, $tree, $k) {
-  // HEAP vars alias each other, and the loop can confuse us
-  var $0 = HEAPU32[($s + 2908 + ($k << 2) | 0) >> 2];
-  while (1) {
-    HEAP32[($s + 2908 + ($storemerge_in << 2) | 0) >> 2] = $9;
-  }
-  HEAP32[($s + 2908 + ($storemerge_in << 2) | 0) >> 2] = $0;
+ // HEAP vars alias each other, and the loop can confuse us
+ var $0 = HEAPU32[($s + 2908 + ($k << 2) | 0) >> 2];
+ while (1) {
+  HEAP32[($s + 2908 + ($storemerge_in << 2) | 0) >> 2] = $9;
+ }
+ HEAP32[($s + 2908 + ($storemerge_in << 2) | 0) >> 2] = $0;
 }
 function llvm3_1() {
-  while (check()) {
-    var $inc = $aj_0 + 1;
-    if ($curri_01 % $zj_0 == 0) {
-      break;
-    }
-    var $j_0 = $inc;
-    run($j_0 / 2);
+ while (check()) {
+  var $inc = $aj_0 + 1;
+  if ($curri_01 % $zj_0 == 0) {
+   break;
   }
+  var $j_0 = $inc;
+  run($j_0 / 2);
+ }
 }
 function _inflate($strm, $flush) {
-  var __stackBase__ = STACKTOP;
-  STACKTOP += 4;
-  var __label__;
-  var $hbuf = __stackBase__;
-  var $cmp = ($strm | 0) == 0;
-  $_$2 : do {
-    if ($cmp) {
+ var __stackBase__ = STACKTOP;
+ STACKTOP += 4;
+ var __label__;
+ var $hbuf = __stackBase__;
+ var $cmp = ($strm | 0) == 0;
+ $_$2 : do {
+  if ($cmp) {
+   var $retval_0 = -2;
+  } else {
+   var $state1 = $strm + 28 | 0;
+   var $0 = HEAPU32[$state1 >> 2];
+   var $cmp2 = ($0 | 0) == 0;
+   if ($cmp2) {
+    var $retval_0 = -2;
+    break;
+   }
+   var $next_out = $strm + 12 | 0;
+   var $1 = HEAP32[$next_out >> 2];
+   var $cmp4 = ($1 | 0) == 0;
+   if ($cmp4) {
+    var $retval_0 = -2;
+    break;
+   }
+   var $next_in = $strm | 0;
+   var $2 = HEAP32[$next_in >> 2];
+   var $cmp6 = ($2 | 0) == 0;
+   if ($cmp6) {
+    var $avail_in = $strm + 4 | 0;
+    var $3 = HEAP32[$avail_in >> 2];
+    var $cmp7 = ($3 | 0) == 0;
+    if (!$cmp7) {
+     var $retval_0 = -2;
+     break;
+    }
+   }
+   var $4 = $0;
+   var $mode = $0 | 0;
+   var $5 = HEAP32[$mode >> 2];
+   var $cmp9 = ($5 | 0) == 11;
+   if ($cmp9) {
+    HEAP32[$mode >> 2] = 12;
+    var $_pre = HEAP32[$next_out >> 2];
+    var $_pre882 = HEAP32[$next_in >> 2];
+    var $8 = $_pre;
+    var $7 = $_pre882;
+    var $6 = 12;
+   } else {
+    var $8 = $1;
+    var $7 = $2;
+    var $6 = $5;
+   }
+   var $6;
+   var $7;
+   var $8;
+   var $avail_out = $strm + 16 | 0;
+   var $9 = HEAP32[$avail_out >> 2];
+   var $avail_in15 = $strm + 4 | 0;
+   var $10 = HEAPU32[$avail_in15 >> 2];
+   var $11 = $0 + 56 | 0;
+   var $12 = HEAP32[$11 >> 2];
+   var $13 = $0 + 60 | 0;
+   var $14 = HEAP32[$13 >> 2];
+   var $15 = $0 + 8 | 0;
+   var $16 = $0 + 24 | 0;
+   var $arrayidx = $hbuf | 0;
+   var $arrayidx40 = $hbuf + 1 | 0;
+   var $17 = $0 + 16 | 0;
+   var $head = $0 + 32 | 0;
+   var $18 = $head;
+   var $msg = $strm + 24 | 0;
+   var $19 = $0 + 36 | 0;
+   var $20 = $0 + 20 | 0;
+   var $adler = $strm + 48 | 0;
+   var $21 = $0 + 64 | 0;
+   var $22 = $0 + 12 | 0;
+   var $flush_off = $flush - 5 | 0;
+   var $23 = $flush_off >>> 0 < 2;
+   var $24 = $0 + 4 | 0;
+   var $cmp660 = ($flush | 0) == 6;
+   var $25 = $0 + 7108 | 0;
+   var $26 = $0 + 84 | 0;
+   var $lencode1215 = $0 + 76 | 0;
+   var $27 = $lencode1215;
+   var $28 = $0 + 72 | 0;
+   var $29 = $0 + 7112 | 0;
+   var $30 = $0 + 68 | 0;
+   var $31 = $0 + 44 | 0;
+   var $32 = $0 + 7104 | 0;
+   var $33 = $0 + 48 | 0;
+   var $window = $0 + 52 | 0;
+   var $34 = $window;
+   var $35 = $0 + 40 | 0;
+   var $total_out = $strm + 20 | 0;
+   var $36 = $0 + 28 | 0;
+   var $arrayidx199 = $hbuf + 2 | 0;
+   var $arrayidx202 = $hbuf + 3 | 0;
+   var $37 = $0 + 96 | 0;
+   var $38 = $0 + 100 | 0;
+   var $39 = $0 + 92 | 0;
+   var $40 = $0 + 104 | 0;
+   var $lens = $0 + 112 | 0;
+   var $41 = $lens;
+   var $codes = $0 + 1328 | 0;
+   var $next861 = $0 + 108 | 0;
+   var $42 = $next861;
+   var $43 = $next861 | 0;
+   var $arraydecay860_c = $codes;
+   var $44 = $0 + 76 | 0;
+   var $arraydecay864 = $lens;
+   var $work = $0 + 752 | 0;
+   var $arraydecay867 = $work;
+   var $arrayidx1128 = $0 + 624 | 0;
+   var $45 = $arrayidx1128;
+   var $46 = $0 + 80 | 0;
+   var $47 = $0 + 88 | 0;
+   var $distcode1395 = $0 + 80 | 0;
+   var $48 = $distcode1395;
+   var $ret_0 = 0;
+   var $next_0 = $7;
+   var $put_0 = $8;
+   var $have_0 = $10;
+   var $left_0 = $9;
+   var $hold_0 = $12;
+   var $bits_0 = $14;
+   var $out_0 = $9;
+   var $49 = $6;
+   $_$12 : while (1) {
+    var $49;
+    var $out_0;
+    var $bits_0;
+    var $hold_0;
+    var $left_0;
+    var $have_0;
+    var $put_0;
+    var $next_0;
+    var $ret_0;
+    $_$14 : do {
+     if (($49 | 0) == 0) {
+      var $50 = HEAPU32[$15 >> 2];
+      var $cmp19 = ($50 | 0) == 0;
+      if ($cmp19) {
+       HEAP32[$mode >> 2] = 12;
+       var $ret_0_be = $ret_0;
+       var $next_0_be = $next_0;
+       var $put_0_be = $put_0;
+       var $have_0_be = $have_0;
+       var $left_0_be = $left_0;
+       var $hold_0_be = $hold_0;
+       var $bits_0_be = $bits_0;
+       var $out_0_be = $out_0;
+       __label__ = 268;
+       break;
+      }
+      var $next_1 = $next_0;
+      var $have_1 = $have_0;
+      var $hold_1 = $hold_0;
+      var $bits_1 = $bits_0;
+      while (1) {
+       var $bits_1;
+       var $hold_1;
+       var $have_1;
+       var $next_1;
+       var $cmp24 = $bits_1 >>> 0 < 16;
+       if (!$cmp24) {
+        break;
+       }
+       var $cmp26 = ($have_1 | 0) == 0;
+       if ($cmp26) {
+        var $ret_8 = $ret_0;
+        var $next_58 = $next_1;
+        var $have_58 = 0;
+        var $hold_54 = $hold_1;
+        var $bits_54 = $bits_1;
+        var $out_4 = $out_0;
+        break $_$12;
+       }
+       // XXX first chunk with a difference (no impact)
+       var $dec = $have_1 - 1 | 0;
+       var $incdec_ptr = $next_1 + 1 | 0;
+       var $51 = HEAPU8[$next_1];
+       var $conv = $51 & 255;
+       var $shl = $conv << $bits_1;
+       var $add = $shl + $hold_1 | 0;
+       var $add29 = $bits_1 + 8 | 0;
+       var $next_1 = $incdec_ptr;
+       var $have_1 = $dec;
+       var $hold_1 = $add;
+       var $bits_1 = $add29;
+      }
+      var $and = $50 & 2;
+      var $tobool = ($and | 0) != 0;
+      var $cmp34 = ($hold_1 | 0) == 35615;
+      var $or_cond = $tobool & $cmp34;
+      if ($or_cond) {
+       var $call = _crc32(0, 0, 0);
+       HEAP32[$16 >> 2] = $call;
+       HEAP8[$arrayidx] = 31;
+       HEAP8[$arrayidx40] = -117;
+       var $52 = HEAP32[$16 >> 2];
+       var $call42 = _crc32($52, $arrayidx, 2);
+       HEAP32[$16 >> 2] = $call42;
+       HEAP32[$mode >> 2] = 1;
+       var $ret_0_be = $ret_0;
+       var $next_0_be = $next_1;
+       var $put_0_be = $put_0;
+       var $have_0_be = $have_1;
+       var $left_0_be = $left_0;
+       var $hold_0_be = 0;
+       var $bits_0_be = 0;
+       var $out_0_be = $out_0;
+       __label__ = 268;
+       break;
+      }
+      HEAP32[$17 >> 2] = 0;
+      var $53 = HEAP32[$18 >> 2];
+      var $cmp49 = ($53 | 0) == 0;
+      if ($cmp49) {
+       var $54 = $50;
+      } else {
+       var $done = $53 + 48 | 0;
+       HEAP32[$done >> 2] = -1;
+       var $_pre884 = HEAP32[$15 >> 2];
+       var $54 = $_pre884;
+      }
+      var $54;
+      var $and55 = $54 & 1;
+      var $tobool56 = ($and55 | 0) == 0;
+      do {
+       if (!$tobool56) {
+        var $and58 = $hold_1 << 8;
+        var $shl59 = $and58 & 65280;
+        var $shr60 = $hold_1 >>> 8;
+        var $add61 = $shl59 + $shr60 | 0;
+        var $rem = ($add61 >>> 0) % 31;
+        var $tobool62 = ($rem | 0) == 0;
+        if (!$tobool62) {
+         break;
+        }
+        var $and66 = $hold_1 & 15;
+        var $cmp67 = ($and66 | 0) == 8;
+        if ($cmp67) {
+         var $shr74 = $hold_1 >>> 4;
+         var $sub = $bits_1 - 4 | 0;
+         var $and76 = $shr74 & 15;
+         var $add77 = $and76 + 8 | 0;
+         var $55 = HEAPU32[$19 >> 2];
+         var $cmp78 = ($55 | 0) == 0;
+         do {
+          if (!$cmp78) {
+           var $cmp83 = $add77 >>> 0 > $55 >>> 0;
+           if (!$cmp83) {
+            break;
+           }
+           HEAP32[$msg >> 2] = STRING_TABLE.__str3100 | 0;
+           HEAP32[$mode >> 2] = 29;
+           var $ret_0_be = $ret_0;
+           var $next_0_be = $next_1;
+           var $put_0_be = $put_0;
+           var $have_0_be = $have_1;
+           var $left_0_be = $left_0;
+           var $hold_0_be = $shr74;
+           var $bits_0_be = $sub;
+           var $out_0_be = $out_0;
+           __label__ = 268;
+           break $_$14;
+          }
+          HEAP32[$19 >> 2] = $add77;
+         } while (0);
+         var $shl90 = 1 << $add77;
+         HEAP32[$20 >> 2] = $shl90;
+         var $call91 = _adler32(0, 0, 0);
+         HEAP32[$16 >> 2] = $call91;
+         HEAP32[$adler >> 2] = $call91;
+         var $and93 = $hold_1 >>> 12;
+         var $56 = $and93 & 2;
+         var $57 = $56 ^ 11;
+         HEAP32[$mode >> 2] = $57;
+         var $ret_0_be = $ret_0;
+         var $next_0_be = $next_1;
+         var $put_0_be = $put_0;
+         var $have_0_be = $have_1;
+         var $left_0_be = $left_0;
+         var $hold_0_be = 0;
+         var $bits_0_be = 0;
+         var $out_0_be = $out_0;
+         __label__ = 268;
+         break $_$14;
+        }
+        HEAP32[$msg >> 2] = STRING_TABLE.__str299 | 0;
+        HEAP32[$mode >> 2] = 29;
+        var $ret_0_be = $ret_0;
+        var $next_0_be = $next_1;
+        var $put_0_be = $put_0;
+        var $have_0_be = $have_1;
+        var $left_0_be = $left_0;
+        var $hold_0_be = $hold_1;
+        var $bits_0_be = $bits_1;
+        var $out_0_be = $out_0;
+        __label__ = 268;
+        break $_$14;
+       }
+      } while (0);
+      HEAP32[$msg >> 2] = STRING_TABLE.__str198 | 0;
+      HEAP32[$mode >> 2] = 29;
+      var $ret_0_be = $ret_0;
+      var $next_0_be = $next_1;
+      var $put_0_be = $put_0;
+      var $have_0_be = $have_1;
+      var $left_0_be = $left_0;
+      var $hold_0_be = $hold_1;
+      var $bits_0_be = $bits_1;
+      var $out_0_be = $out_0;
+      __label__ = 268;
+      break;
+     } else if (($49 | 0) == 1) {
+      var $next_2 = $next_0;
+      var $have_2 = $have_0;
+      var $hold_2 = $hold_0;
+      var $bits_2 = $bits_0;
+      while (1) {
+       var $bits_2;
+       var $hold_2;
+       var $have_2;
+       var $next_2;
+       var $cmp101 = $bits_2 >>> 0 < 16;
+       if (!$cmp101) {
+        break;
+       }
+       var $cmp105 = ($have_2 | 0) == 0;
+       if ($cmp105) {
+        var $ret_8 = $ret_0;
+        var $next_58 = $next_2;
+        var $have_58 = 0;
+        var $hold_54 = $hold_2;
+        var $bits_54 = $bits_2;
+        var $out_4 = $out_0;
+        break $_$12;
+       }
+       var $dec109 = $have_2 - 1 | 0;
+       var $incdec_ptr110 = $next_2 + 1 | 0;
+       var $58 = HEAPU8[$next_2];
+       var $conv111 = $58 & 255;
+       var $shl112 = $conv111 << $bits_2;
+       var $add113 = $shl112 + $hold_2 | 0;
+       var $add114 = $bits_2 + 8 | 0;
+       var $next_2 = $incdec_ptr110;
+       var $have_2 = $dec109;
+       var $hold_2 = $add113;
+       var $bits_2 = $add114;
+      }
+      HEAP32[$17 >> 2] = $hold_2;
+      var $and120 = $hold_2 & 255;
+      var $cmp121 = ($and120 | 0) == 8;
+      if (!$cmp121) {
+       HEAP32[$msg >> 2] = STRING_TABLE.__str299 | 0;
+       HEAP32[$mode >> 2] = 29;
+       var $ret_0_be = $ret_0;
+       var $next_0_be = $next_2;
+       var $put_0_be = $put_0;
+       var $have_0_be = $have_2;
+       var $left_0_be = $left_0;
+       var $hold_0_be = $hold_2;
+       var $bits_0_be = $bits_2;
+       var $out_0_be = $out_0;
+       __label__ = 268;
+       break;
+      }
+      var $and128 = $hold_2 & 57344;
+      var $tobool129 = ($and128 | 0) == 0;
+      if ($tobool129) {
+       var $59 = HEAPU32[$18 >> 2];
+       var $cmp135 = ($59 | 0) == 0;
+       if ($cmp135) {
+        var $60 = $hold_2;
+       } else {
+        var $shr138 = $hold_2 >>> 8;
+        var $and139 = $shr138 & 1;
+        var $text = $59 | 0;
+        HEAP32[$text >> 2] = $and139;
+        var $_pre887 = HEAP32[$17 >> 2];
+        var $60 = $_pre887;
+       }
+       var $60;
+       var $and143 = $60 & 512;
+       var $tobool144 = ($and143 | 0) == 0;
+       if (!$tobool144) {
+        var $conv147 = $hold_2 & 255;
+        HEAP8[$arrayidx] = $conv147;
+        var $shr149 = $hold_2 >>> 8;
+        var $conv150 = $shr149 & 255;
+        HEAP8[$arrayidx40] = $conv150;
+        var $61 = HEAP32[$16 >> 2];
+        var $call154 = _crc32($61, $arrayidx, 2);
+        HEAP32[$16 >> 2] = $call154;
+       }
+       HEAP32[$mode >> 2] = 2;
+       var $next_3 = $next_2;
+       var $have_3 = $have_2;
+       var $hold_3 = 0;
+       var $bits_3 = 0;
+       __label__ = 44;
+       break;
+      }
+      HEAP32[$msg >> 2] = STRING_TABLE.__str4101 | 0;
+      HEAP32[$mode >> 2] = 29;
+      var $ret_0_be = $ret_0;
+      var $next_0_be = $next_2;
+      var $put_0_be = $put_0;
+      var $have_0_be = $have_2;
+      var $left_0_be = $left_0;
+      var $hold_0_be = $hold_2;
+      var $bits_0_be = $bits_2;
+      var $out_0_be = $out_0;
+      __label__ = 268;
+      break;
+     } else if (($49 | 0) == 2) {
+      var $next_3 = $next_0;
+      var $have_3 = $have_0;
+      var $hold_3 = $hold_0;
+      var $bits_3 = $bits_0;
+      __label__ = 44;
+     } else if (($49 | 0) == 3) {
+      var $next_4 = $next_0;
+      var $have_4 = $have_0;
+      var $hold_4 = $hold_0;
+      var $bits_4 = $bits_0;
+      __label__ = 52;
+     } else if (($49 | 0) == 4) {
+      var $next_5 = $next_0;
+      var $have_5 = $have_0;
+      var $hold_5 = $hold_0;
+      var $bits_5 = $bits_0;
+      __label__ = 60;
+     } else if (($49 | 0) == 5) {
+      var $next_8 = $next_0;
+      var $have_8 = $have_0;
+      var $hold_8 = $hold_0;
+      var $bits_8 = $bits_0;
+      __label__ = 71;
+     } else if (($49 | 0) == 6) {
+      var $_pre888 = HEAP32[$17 >> 2];
+      var $next_11 = $next_0;
+      var $have_11 = $have_0;
+      var $hold_9 = $hold_0;
+      var $bits_9 = $bits_0;
+      var $89 = $_pre888;
+      __label__ = 81;
+      break;
+     } else if (($49 | 0) == 7) {
+      var $next_13 = $next_0;
+      var $have_13 = $have_0;
+      var $hold_10 = $hold_0;
+      var $bits_10 = $bits_0;
+      __label__ = 94;
+     } else if (($49 | 0) == 8) {
+      var $next_15 = $next_0;
+      var $have_15 = $have_0;
+      var $hold_11 = $hold_0;
+      var $bits_11 = $bits_0;
+      __label__ = 107;
+     } else if (($49 | 0) == 9) {
+      var $next_18 = $next_0;
+      var $have_18 = $have_0;
+      var $hold_14 = $hold_0;
+      var $bits_14 = $bits_0;
+      while (1) {
+       var $bits_14;
+       var $hold_14;
+       var $have_18;
+       var $next_18;
+       var $cmp552 = $bits_14 >>> 0 < 32;
+       if (!$cmp552) {
+        break;
+       }
+       var $cmp556 = ($have_18 | 0) == 0;
+       if ($cmp556) {
+        var $ret_8 = $ret_0;
+        var $next_58 = $next_18;
+        var $have_58 = 0;
+        var $hold_54 = $hold_14;
+        var $bits_54 = $bits_14;
+        var $out_4 = $out_0;
+        break $_$12;
+       }
+       var $dec560 = $have_18 - 1 | 0;
+       var $incdec_ptr561 = $next_18 + 1 | 0;
+       var $114 = HEAPU8[$next_18];
+       var $conv562 = $114 & 255;
+       var $shl563 = $conv562 << $bits_14;
+       var $add564 = $shl563 + $hold_14 | 0;
+       var $add565 = $bits_14 + 8 | 0;
+       var $next_18 = $incdec_ptr561;
+       var $have_18 = $dec560;
+       var $hold_14 = $add564;
+       var $bits_14 = $add565;
+      }
+      var $add581 = _llvm_bswap_i32($hold_14);
+      HEAP32[$16 >> 2] = $add581;
+      HEAP32[$adler >> 2] = $add581;
+      HEAP32[$mode >> 2] = 10;
+      var $next_19 = $next_18;
+      var $have_19 = $have_18;
+      var $hold_15 = 0;
+      var $bits_15 = 0;
+      __label__ = 120;
+      break;
+     } else if (($49 | 0) == 10) {
+      var $next_19 = $next_0;
+      var $have_19 = $have_0;
+      var $hold_15 = $hold_0;
+      var $bits_15 = $bits_0;
+      __label__ = 120;
+     } else if (($49 | 0) == 11) {
+      var $next_20 = $next_0;
+      var $have_20 = $have_0;
+      var $hold_16 = $hold_0;
+      var $bits_16 = $bits_0;
+      __label__ = 123;
+     } else if (($49 | 0) == 12) {
+      var $next_21 = $next_0;
+      var $have_21 = $have_0;
+      var $hold_17 = $hold_0;
+      var $bits_17 = $bits_0;
+      __label__ = 124;
+     } else if (($49 | 0) == 13) {
+      var $and681 = $bits_0 & 7;
+      var $shr682 = $hold_0 >>> ($and681 >>> 0);
+      var $sub684 = $bits_0 - $and681 | 0;
+      var $next_23 = $next_0;
+      var $have_23 = $have_0;
+      var $hold_19 = $shr682;
+      var $bits_19 = $sub684;
+      while (1) {
+       var $bits_19;
+       var $hold_19;
+       var $have_23;
+       var $next_23;
+       var $cmp689 = $bits_19 >>> 0 < 32;
+       if (!$cmp689) {
+        break;
+       }
+       var $cmp693 = ($have_23 | 0) == 0;
+       if ($cmp693) {
+        var $ret_8 = $ret_0;
+        var $next_58 = $next_23;
+        var $have_58 = 0;
+        var $hold_54 = $hold_19;
+        var $bits_54 = $bits_19;
+        var $out_4 = $out_0;
+        break $_$12;
+       }
+       var $dec697 = $have_23 - 1 | 0;
+       var $incdec_ptr698 = $next_23 + 1 | 0;
+       var $118 = HEAPU8[$next_23];
+       var $conv699 = $118 & 255;
+       var $shl700 = $conv699 << $bits_19;
+       var $add701 = $shl700 + $hold_19 | 0;
+       var $add702 = $bits_19 + 8 | 0;
+       var $next_23 = $incdec_ptr698;
+       var $have_23 = $dec697;
+       var $hold_19 = $add701;
+       var $bits_19 = $add702;
+      }
+      var $and708 = $hold_19 & 65535;
+      var $shr709 = $hold_19 >>> 16;
+      var $xor = $shr709 ^ 65535;
+      var $cmp710 = ($and708 | 0) == ($xor | 0);
+      if (!$cmp710) {
+       HEAP32[$msg >> 2] = STRING_TABLE.__str7104 | 0;
+       HEAP32[$mode >> 2] = 29;
+       var $ret_0_be = $ret_0;
+       var $next_0_be = $next_23;
+       var $put_0_be = $put_0;
+       var $have_0_be = $have_23;
+       var $left_0_be = $left_0;
+       var $hold_0_be = $hold_19;
+       var $bits_0_be = $bits_19;
+       var $out_0_be = $out_0;
+       __label__ = 268;
+       break;
+      }
+      HEAP32[$21 >> 2] = $and708;
+      HEAP32[$mode >> 2] = 14;
+      if ($cmp660) {
+       var $ret_8 = $ret_0;
+       var $next_58 = $next_23;
+       var $have_58 = $have_23;
+       var $hold_54 = 0;
+       var $bits_54 = 0;
+       var $out_4 = $out_0;
+       break $_$12;
+      }
+      var $next_24 = $next_23;
+      var $have_24 = $have_23;
+      var $hold_20 = 0;
+      var $bits_20 = 0;
+      __label__ = 143;
+      break;
+     } else if (($49 | 0) == 14) {
+      var $next_24 = $next_0;
+      var $have_24 = $have_0;
+      var $hold_20 = $hold_0;
+      var $bits_20 = $bits_0;
+      __label__ = 143;
+     } else if (($49 | 0) == 15) {
+      var $next_25 = $next_0;
+      var $have_25 = $have_0;
+      var $hold_21 = $hold_0;
+      var $bits_21 = $bits_0;
+      __label__ = 144;
+     } else if (($49 | 0) == 16) {
+      var $next_26 = $next_0;
+      var $have_26 = $have_0;
+      var $hold_22 = $hold_0;
+      var $bits_22 = $bits_0;
+      while (1) {
+       var $bits_22;
+       var $hold_22;
+       var $have_26;
+       var $next_26;
+       var $cmp755 = $bits_22 >>> 0 < 14;
+       if (!$cmp755) {
+        break;
+       }
+       var $cmp759 = ($have_26 | 0) == 0;
+       if ($cmp759) {
+        var $ret_8 = $ret_0;
+        var $next_58 = $next_26;
+        var $have_58 = 0;
+        var $hold_54 = $hold_22;
+        var $bits_54 = $bits_22;
+        var $out_4 = $out_0;
+        break $_$12;
+       }
+       var $dec763 = $have_26 - 1 | 0;