remove var x; of completely unused vars, and restore previous test cases

3 files changed, 10561 insertions, 3 deletions

diff --git a/tools/eliminator/eliminator-test-output.js b/tools/eliminator/eliminator-test-output.js
index 9ffe5062..992c0045 100644
--- a/tools/eliminator/eliminator-test-output.js
+++ b/tools/eliminator/eliminator-test-output.js
@@ -56,4 +56,4491 @@ function a() {
   chak();
   tor(HEAP[9]);
 }
-// EMSCRIPTEN_GENERATED_FUNCTIONS: ["f", "g", "h", "py", "r", "t", "f2", "f3", "llvm3_1", "_inflate", "_malloc", "a"]
+function f() {
+  HEAP[123] = (GLOB[1] + 1) / 2;
+}
+function g(a1, a2) {
+  var a = 1;
+  var c = a * 2 - 1;
+  a = c;
+  foo(c);
+  foo(2);
+  for (var i = 0; i < 5; i++) {
+    var q = {
+      a: 1
+    } + [ 2, 3 ];
+  }
+  for (var iterator in SOME_GLOBAL) {
+    quux(iterator);
+  }
+  MAYBE_HEAP[myglobal] = 123;
+  if (HEAP[5] < 0) {
+    __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;
+  }
+  if (1) {
+    otherGlob = glob;
+    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;
+  }
+}
+function py() {
+  HEAP[HEAP[HEAP[__PyThreadState_Current] + 12] + 1 + 12] = 99;
+}
+function otherPy() {
+  var $4 = HEAP[__PyThreadState_Current];
+  var $5 = $4 + 12;
+  var $7 = HEAP[$5] + 1;
+  var $8 = $4 + 12;
+  HEAP[$8] = $7;
+}
+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;
+});
+function r($0) {
+  HEAP[$0 + 7] = 107;
+}
+function t() {
+  if ($10 < $11) {
+    __label__ = 3;
+  }
+  if (!($12 < $13)) {
+    __label__ = 4;
+  }
+}
+function f2() {
+  var $_pre = HEAPU32[($vla + ($storemerge312 << 2) | 0) >> 2];
+  var $storemerge312 = $storemerge312 + 1 | 0;
+  var $8 = $_pre;
+  c($8);
+}
+function f3($s, $tree, $k) {
+  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()) {
+    if ($curri_01 % $zj_0 == 0) {
+      break;
+    }
+    var $j_0 = $aj_0 + 1;
+    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 $retval_0 = -2;
+    } else {
+      var $0 = HEAPU32[($strm + 28 | 0) >> 2];
+      if (($0 | 0) == 0) {
+        var $retval_0 = -2;
+        break;
+      }
+      var $next_out = $strm + 12 | 0;
+      var $1 = HEAP32[$next_out >> 2];
+      if (($1 | 0) == 0) {
+        var $retval_0 = -2;
+        break;
+      }
+      var $next_in = $strm | 0;
+      var $2 = HEAP32[$next_in >> 2];
+      if (($2 | 0) == 0) {
+        if (!((HEAP32[($strm + 4 | 0) >> 2] | 0) == 0)) {
+          var $retval_0 = -2;
+          break;
+        }
+      }
+      var $4 = $0;
+      var $mode = $0 | 0;
+      var $5 = HEAP32[$mode >> 2];
+      if (($5 | 0) == 11) {
+        HEAP32[$mode >> 2] = 12;
+        var $8 = HEAP32[$next_out >> 2];
+        var $7 = HEAP32[$next_in >> 2];
+        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 $13 = $0 + 60 | 0;
+      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 $18 = $0 + 32 | 0;
+      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 $23 = ($flush - 5 | 0) >>> 0 < 2;
+      var $24 = $0 + 4 | 0;
+      var $cmp660 = ($flush | 0) == 6;
+      var $25 = $0 + 7108 | 0;
+      var $26 = $0 + 84 | 0;
+      var $27 = $0 + 76 | 0;
+      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 $34 = $0 + 52 | 0;
+      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 $next861 = $0 + 108 | 0;
+      var $42 = $next861;
+      var $43 = $next861 | 0;
+      var $arraydecay860_c = $0 + 1328 | 0;
+      var $44 = $0 + 76 | 0;
+      var $arraydecay864 = $lens;
+      var $arraydecay867 = $0 + 752 | 0;
+      var $45 = $0 + 624 | 0;
+      var $46 = $0 + 80 | 0;
+      var $47 = $0 + 88 | 0;
+      var $48 = $0 + 80 | 0;
+      var $ret_0 = 0;
+      var $next_0 = $7;
+      var $put_0 = $8;
+      var $have_0 = $10;
+      var $left_0 = $9;
+      var $hold_0 = HEAP32[$11 >> 2];
+      var $bits_0 = HEAP32[$13 >> 2];
+      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];
+            if (($50 | 0) == 0) {
+              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;
+              if (!($bits_1 >>> 0 < 16)) {
+                break;
+              }
+              if (($have_1 | 0) == 0) {
+                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;
+              }
+              var $add = ((HEAPU8[$next_1] & 255) << $bits_1) + $hold_1 | 0;
+              var $next_1 = $next_1 + 1 | 0;
+              var $have_1 = $have_1 - 1 | 0;
+              var $hold_1 = $add;
+              var $bits_1 = $bits_1 + 8 | 0;
+            }
+            if (($50 & 2 | 0) != 0 & ($hold_1 | 0) == 35615) {
+              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];
+            if (($53 | 0) == 0) {
+              var $54 = $50;
+            } else {
+              HEAP32[($53 + 48 | 0) >> 2] = -1;
+              var $54 = HEAP32[$15 >> 2];
+            }
+            var $54;
+            var $tobool56 = ($54 & 1 | 0) == 0;
+            do {
+              if (!$tobool56) {
+                if (!((((($hold_1 << 8 & 65280) + ($hold_1 >>> 8) | 0) >>> 0) % 31 | 0) == 0)) {
+                  break;
+                }
+                if (($hold_1 & 15 | 0) == 8) {
+                  var $shr74 = $hold_1 >>> 4;
+                  var $sub = $bits_1 - 4 | 0;
+                  var $add77 = ($shr74 & 15) + 8 | 0;
+                  var $55 = HEAPU32[$19 >> 2];
+                  var $cmp78 = ($55 | 0) == 0;
+                  do {
+                    if (!$cmp78) {
+                      if (!($add77 >>> 0 > $55 >>> 0)) {
+                        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);
+                  HEAP32[$20 >> 2] = 1 << $add77;
+                  var $call91 = _adler32(0, 0, 0);
+                  HEAP32[$16 >> 2] = $call91;
+                  HEAP32[$adler >> 2] = $call91;
+                  HEAP32[$mode >> 2] = $hold_1 >>> 12 & 2 ^ 11;
+                  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;
+              if (!($bits_2 >>> 0 < 16)) {
+                break;
+              }
+              if (($have_2 | 0) == 0) {
+                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 $add113 = ((HEAPU8[$next_2] & 255) << $bits_2) + $hold_2 | 0;
+              var $next_2 = $next_2 + 1 | 0;
+              var $have_2 = $have_2 - 1 | 0;
+              var $hold_2 = $add113;
+              var $bits_2 = $bits_2 + 8 | 0;
+            }
+            HEAP32[$17 >> 2] = $hold_2;
+            if (!(($hold_2 & 255 | 0) == 8)) {
+              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;
+            }
+            if (($hold_2 & 57344 | 0) == 0) {
+              var $59 = HEAPU32[$18 >> 2];
+              if (($59 | 0) == 0) {
+                var $60 = $hold_2;
+              } else {
+                HEAP32[($59 | 0) >> 2] = $hold_2 >>> 8 & 1;
+                var $60 = HEAP32[$17 >> 2];
+              }
+              var $60;
+              if (!(($60 & 512 | 0) == 0)) {
+                HEAP8[$arrayidx] = $hold_2 & 255;
+                HEAP8[$arrayidx40] = $hold_2 >>> 8 & 255;
+                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 $next_11 = $next_0;
+            var $have_11 = $have_0;
+            var $hold_9 = $hold_0;
+            var $bits_9 = $bits_0;
+            var $89 = HEAP32[$17 >> 2];
+            __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;
+              if (!($bits_14 >>> 0 < 32)) {
+                break;
+              }
+              if (($have_18 | 0) == 0) {
+                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 $add564 = ((HEAPU8[$next_18] & 255) << $bits_14) + $hold_14 | 0;
+              var $next_18 = $next_18 + 1 | 0;
+              var $have_18 = $have_18 - 1 | 0;
+              var $hold_14 = $add564;
+              var $bits_14 = $bits_14 + 8 | 0;
+            }
+            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 $next_23 = $next_0;
+            var $have_23 = $have_0;
+            var $hold_19 = $hold_0 >>> ($and681 >>> 0);
+            var $bits_19 = $bits_0 - $and681 | 0;
+            while (1) {
+              var $bits_19;
+              var $hold_19;
+              var $have_23;
+              var $next_23;
+              if (!($bits_19 >>> 0 < 32)) {
+                break;
+              }
+              if (($have_23 | 0) == 0) {
+                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 $add701 = ((HEAPU8[$next_23] & 255) << $bits_19) + $hold_19 | 0;
+              var $next_23 = $next_23 + 1 | 0;
+              var $have_23 = $have_23 - 1 | 0;
+              var $hold_19 = $add701;
+              var $bits_19 = $bits_19 + 8 | 0;
+            }
+            var $and708 = $hold_19 & 65535;
+            if (!(($and708 | 0) == ($hold_19 >>> 16 ^ 65535 | 0))) {
+              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;
+              if (!($bits_22 >>> 0 < 14)) {
+                break;
+              }
+              if (($have_26 | 0) == 0) {
+                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 $add767 = ((HEAPU8[$next_26] & 255) << $bits_22) + $hold_22 | 0;
+              var $next_26 = $next_26 + 1 | 0;
+              var $have_26 = $have_26 - 1 | 0;
+              var $hold_22 = $add767;
+              var $bits_22 = $bits_22 + 8 | 0;
+            }
+            var $add775 = ($hold_22 & 31) + 257 | 0;
+            HEAP32[$37 >> 2] = $add775;
+            var $add782 = ($hold_22 >>> 5 & 31) + 1 | 0;
+            HEAP32[$38 >> 2] = $add782;
+            HEAP32[$39 >> 2] = ($hold_22 >>> 10 & 15) + 4 | 0;
+            var $shr791 = $hold_22 >>> 14;
+            var $sub792 = $bits_22 - 14 | 0;
+            if ($add775 >>> 0 > 286 | $add782 >>> 0 > 30) {
+              HEAP32[$msg >> 2] = STRING_TABLE.__str8105 | 0;
+              HEAP32[$mode >> 2] = 29;
+              var $ret_0_be = $ret_0;
+              var $next_0_be = $next_26;
+              var $put_0_be = $put_0;
+              var $have_0_be = $have_26;
+              var $left_0_be = $left_0;
+              var $hold_0_be = $shr791;
+              var $bits_0_be = $sub792;
+              var $out_0_be = $out_0;
+              __label__ = 268;
+              break;
+            }
+            HEAP32[$40 >> 2] = 0;
+            HEAP32[$mode >> 2] = 17;
+            var $next_27 = $next_26;
+            var $have_27 = $have_26;
+            var $hold_23 = $shr791;
+            var $bits_23 = $sub792;
+            __label__ = 154;
+            break;
+          } else if (($49 | 0) == 17) {
+            var $next_27 = $next_0;
+            var $have_27 = $have_0;
+            var $hold_23 = $hold_0;
+            var $bits_23 = $bits_0;
+            __label__ = 154;
+          } else if (($49 | 0) == 18) {
+            var $ret_1_ph = $ret_0;
+            var $next_29_ph = $next_0;
+            var $have_29_ph = $have_0;
+            var $hold_25_ph = $hold_0;
+            var $bits_25_ph = $bits_0;
+            __label__ = 164;
+          } else if (($49 | 0) == 19) {
+            var $ret_2 = $ret_0;
+            var $next_37 = $next_0;
+            var $have_37 = $have_0;
+            var $hold_33 = $hold_0;
+            var $bits_33 = $bits_0;
+            __label__ = 205;
+          } else if (($49 | 0) == 20) {
+            var $ret_3 = $ret_0;
+            var $next_38 = $next_0;
+            var $have_38 = $have_0;
+            var $hold_34 = $hold_0;
+            var $bits_34 = $bits_0;
+            __label__ = 206;
+          } else if (($49 | 0) == 21) {
+            var $ret_4 = $ret_0;
+            var $next_42 = $next_0;
+            var $have_42 = $have_0;
+            var $hold_38 = $hold_0;
+            var $bits_38 = $bits_0;
+            var $156 = HEAP32[$28 >> 2];
+            __label__ = 227;
+            break;
+          } else if (($49 | 0) == 22) {
+            var $ret_5_ph = $ret_0;
+            var $next_45_ph = $next_0;
+            var $have_45_ph = $have_0;
+            var $hold_41_ph = $hold_0;
+            var $bits_41_ph = $bits_0;
+            __label__ = 234;
+          } else if (($49 | 0) == 23) {
+            var $ret_6 = $ret_0;
+            var $next_48 = $next_0;
+            var $have_48 = $have_0;
+            var $hold_44 = $hold_0;
+            var $bits_44 = $bits_0;
+            var $167 = HEAP32[$28 >> 2];
+            __label__ = 248;
+            break;
+          } else if (($49 | 0) == 24) {
+            var $ret_7 = $ret_0;
+            var $next_51 = $next_0;
+            var $have_51 = $have_0;
+            var $hold_47 = $hold_0;
+            var $bits_47 = $bits_0;
+            __label__ = 254;
+          } else if (($49 | 0) == 25) {
+            if (($left_0 | 0) == 0) {
+              var $ret_8 = $ret_0;
+              var $next_58 = $next_0;
+              var $have_58 = $have_0;
+              var $hold_54 = $hold_0;
+              var $bits_54 = $bits_0;
+              var $out_4 = $out_0;
+              break $_$12;
+            }
+            HEAP8[$put_0] = HEAP32[$21 >> 2] & 255;
+            HEAP32[$mode >> 2] = 20;
+            var $ret_0_be = $ret_0;
+            var $next_0_be = $next_0;
+            var $put_0_be = $put_0 + 1 | 0;
+            var $have_0_be = $have_0;
+            var $left_0_be = $left_0 - 1 | 0;
+            var $hold_0_be = $hold_0;
+            var $bits_0_be = $bits_0;
+            var $out_0_be = $out_0;
+            __label__ = 268;
+            break;
+          } else if (($49 | 0) == 26) {
+            var $tobool1626 = (HEAP32[$15 >> 2] | 0) == 0;
+            do {
+              if (!$tobool1626) {
+                var $next_52 = $next_0;
+                var $have_52 = $have_0;
+                var $hold_48 = $hold_0;
+                var $bits_48 = $bits_0;
+                while (1) {
+                  var $bits_48;
+                  var $hold_48;
+                  var $have_52;
+                  var $next_52;
+                  if (!($bits_48 >>> 0 < 32)) {
+                    break;
+                  }
+                  if (($have_52 | 0) == 0) {
+                    var $ret_8 = $ret_0;
+                    var $next_58 = $next_52;
+                    var $have_58 = 0;
+                    var $hold_54 = $hold_48;
+                    var $bits_54 = $bits_48;
+                    var $out_4 = $out_0;
+                    break $_$12;
+                  }
+                  var $add1642 = ((HEAPU8[$next_52] & 255) << $bits_48) + $hold_48 | 0;
+                  var $next_52 = $next_52 + 1 | 0;
+                  var $have_52 = $have_52 - 1 | 0;
+                  var $hold_48 = $add1642;
+                  var $bits_48 = $bits_48 + 8 | 0;
+                }
+                var $sub1649 = $out_0 - $left_0 | 0;
+                HEAP32[$total_out >> 2] = HEAP32[$total_out >> 2] + $sub1649 | 0;
+                HEAP32[$36 >> 2] = HEAP32[$36 >> 2] + $sub1649 | 0;
+                if (!(($out_0 | 0) == ($left_0 | 0))) {
+                  var $192 = HEAP32[$16 >> 2];
+                  var $add_ptr1659 = $put_0 + (-$sub1649 | 0) | 0;
+                  if ((HEAP32[$17 >> 2] | 0) == 0) {
+                    var $call1665 = _adler32($192, $add_ptr1659, $sub1649);
+                    var $cond1667 = $call1665;
+                  } else {
+                    var $call1660 = _crc32($192, $add_ptr1659, $sub1649);
+                    var $cond1667 = $call1660;
+                  }
+                  var $cond1667;
+                  HEAP32[$16 >> 2] = $cond1667;
+                  HEAP32[$adler >> 2] = $cond1667;
+                }
+                if ((HEAP32[$17 >> 2] | 0) == 0) {
+                  var $add1685 = _llvm_bswap_i32($hold_48);
+                  var $cond1687 = $add1685;
+                } else {
+                  var $cond1687 = $hold_48;
+                }
+                var $cond1687;
+                if (($cond1687 | 0) == (HEAP32[$16 >> 2] | 0)) {
+                  var $next_53 = $next_52;
+                  var $have_53 = $have_52;
+                  var $hold_49 = 0;
+                  var $bits_49 = 0;
+                  var $out_1 = $left_0;
+                  break;
+                }
+                HEAP32[$msg >> 2] = STRING_TABLE.__str17114 | 0;
+                HEAP32[$mode >> 2] = 29;
+                var $ret_0_be = $ret_0;
+                var $next_0_be = $next_52;
+                var $put_0_be = $put_0;
+                var $have_0_be = $have_52;
+                var $left_0_be = $left_0;
+                var $hold_0_be = $hold_48;
+                var $bits_0_be = $bits_48;
+                var $out_0_be = $left_0;
+                __label__ = 268;
+                break $_$14;
+              }
+              var $next_53 = $next_0;
+              var $have_53 = $have_0;
+              var $hold_49 = $hold_0;
+              var $bits_49 = $bits_0;
+              var $out_1 = $out_0;
+            } while (0);
+            var $out_1;
+            var $bits_49;
+            var $hold_49;
+            var $have_53;
+            var $next_53;
+            HEAP32[$mode >> 2] = 27;
+            var $next_54 = $next_53;
+            var $have_54 = $have_53;
+            var $hold_50 = $hold_49;
+            var $bits_50 = $bits_49;
+            var $out_2 = $out_1;
+            __label__ = 286;
+            break;
+          } else if (($49 | 0) == 27) {
+            var $next_54 = $next_0;
+            var $have_54 = $have_0;
+            var $hold_50 = $hold_0;
+            var $bits_50 = $bits_0;
+            var $out_2 = $out_0;
+            __label__ = 286;
+          } else if (($49 | 0) == 28) {
+            var $ret_8 = 1;
+            var $next_58 = $next_0;
+            var $have_58 = $have_0;
+            var $hold_54 = $hold_0;
+            var $bits_54 = $bits_0;
+            var $out_4 = $out_0;
+            break $_$12;
+          } else if (($49 | 0) == 29) {
+            var $ret_8 = -3;
+            var $next_58 = $next_0;
+            var $have_58 = $have_0;
+            var $hold_54 = $hold_0;
+            var $bits_54 = $bits_0;
+            var $out_4 = $out_0;
+            break $_$12;
+          } else if (($49 | 0) == 30) {
+            var $retval_0 = -4;
+            break $_$2;
+          } else {
+            var $retval_0 = -2;
+            break $_$2;
+          }
+        } while (0);
+        $_$106 : do {
+          if (__label__ == 44) {
+            while (1) {
+              var $bits_3;
+              var $hold_3;
+              var $have_3;
+              var $next_3;
+              if (!($bits_3 >>> 0 < 32)) {
+                break;
+              }
+              if (($have_3 | 0) == 0) {
+                var $ret_8 = $ret_0;
+                var $next_58 = $next_3;
+                var $have_58 = 0;
+                var $hold_54 = $hold_3;
+                var $bits_54 = $bits_3;
+                var $out_4 = $out_0;
+                break $_$12;
+              }
+              var $add176 = ((HEAPU8[$next_3] & 255) << $bits_3) + $hold_3 | 0;
+              var $next_3 = $next_3 + 1 | 0;
+              var $have_3 = $have_3 - 1 | 0;
+              var $hold_3 = $add176;
+              var $bits_3 = $bits_3 + 8 | 0;
+            }
+            var $63 = HEAP32[$18 >> 2];
+            if (!(($63 | 0) == 0)) {
+              HEAP32[($63 + 4 | 0) >> 2] = $hold_3;
+            }
+            if (!((HEAP32[$17 >> 2] & 512 | 0) == 0)) {
+              HEAP8[$arrayidx] = $hold_3 & 255;
+              HEAP8[$arrayidx40] = $hold_3 >>> 8 & 255;
+              HEAP8[$arrayidx199] = $hold_3 >>> 16 & 255;
+              HEAP8[$arrayidx202] = $hold_3 >>> 24 & 255;
+              var $65 = HEAP32[$16 >> 2];
+              var $call205 = _crc32($65, $arrayidx, 4);
+              HEAP32[$16 >> 2] = $call205;
+            }
+            HEAP32[$mode >> 2] = 3;
+            var $next_4 = $next_3;
+            var $have_4 = $have_3;
+            var $hold_4 = 0;
+            var $bits_4 = 0;
+            __label__ = 52;
+            break;
+          } else if (__label__ == 120) {
+            var $bits_15;
+            var $hold_15;
+            var $have_19;
+            var $next_19;
+            if ((HEAP32[$22 >> 2] | 0) == 0) {
+              HEAP32[$next_out >> 2] = $put_0;
+              HEAP32[$avail_out >> 2] = $left_0;
+              HEAP32[$next_in >> 2] = $next_19;
+              HEAP32[$avail_in15 >> 2] = $have_19;
+              HEAP32[$11 >> 2] = $hold_15;
+              HEAP32[$13 >> 2] = $bits_15;
+              var $retval_0 = 2;
+              break $_$2;
+            }
+            var $call602 = _adler32(0, 0, 0);
+            HEAP32[$16 >> 2] = $call602;
+            HEAP32[$adler >> 2] = $call602;
+            HEAP32[$mode >> 2] = 11;
+            var $next_20 = $next_19;
+            var $have_20 = $have_19;
+            var $hold_16 = $hold_15;
+            var $bits_16 = $bits_15;
+            __label__ = 123;
+            break;
+          } else if (__label__ == 143) {
+            var $bits_20;
+            var $hold_20;
+            var $have_24;
+            var $next_24;
+            HEAP32[$mode >> 2] = 15;
+            var $next_25 = $next_24;
+            var $have_25 = $have_24;
+            var $hold_21 = $hold_20;
+            var $bits_21 = $bits_20;
+            __label__ = 144;
+            break;
+          } else if (__label__ == 154) {
+            while (1) {
+              var $bits_23;
+              var $hold_23;
+              var $have_27;
+              var $next_27;
+              var $122 = HEAPU32[$40 >> 2];
+              if (!($122 >>> 0 < HEAPU32[$39 >> 2] >>> 0)) {
+                break;
+              }
+              var $next_28 = $next_27;
+              var $have_28 = $have_27;
+              var $hold_24 = $hold_23;
+              var $bits_24 = $bits_23;
+              while (1) {
+                var $bits_24;
+                var $hold_24;
+                var $have_28;
+                var $next_28;
+                if (!($bits_24 >>> 0 < 3)) {
+                  break;
+                }