// Module ID: 12656
// Function ID: 97971
// Name: zswap32
// Dependencies: [12646, 12657, 12653, 12658, 12652]

// Module 12656 (zswap32)
const require = arg1;
const dependencyMap = arg6;
function zswap32(buf8) {
  return (buf8 >>> 24 & 255) + (buf8 >>> 8 & 65280) + ((65280 & buf8) << 8) + ((255 & buf8) << 24);
}
function InflateState() {
  this.mode = 0;
  this.last = false;
  this.wrap = 0;
  this.havedict = false;
  this.flags = 0;
  this.dmax = 0;
  this.check = 0;
  this.total = 0;
  this.head = null;
  this.wbits = 0;
  this.wsize = 0;
  this.whave = 0;
  this.wnext = 0;
  this.window = null;
  this.hold = 0;
  this.bits = 0;
  this.length = 0;
  this.offset = 0;
  this.extra = 0;
  this.lencode = null;
  this.distcode = null;
  this.lenbits = 0;
  this.distbits = 0;
  this.ncode = 0;
  this.nlen = 0;
  this.ndist = 0;
  this.have = 0;
  this.next = null;
  const buf16 = new require(12646) /* _has */.Buf16(320);
  this.lens = buf16;
  const buf161 = new require(12646) /* _has */.Buf16(288);
  this.work = buf161;
  this.lendyn = null;
  this.distdyn = null;
  this.sane = 0;
  this.back = 0;
  this.was = 0;
}
function inflateResetKeep(state) {
  let num = -2;
  if (state) {
    num = -2;
    if (state.state) {
      state = state.state;
      state.total = 0;
      state.total_out = 0;
      state.total_in = 0;
      state.msg = "";
      if (state.wrap) {
        state.adler = 1 & state.wrap;
      }
      state.mode = 1;
      state.last = 0;
      state.havedict = 0;
      state.dmax = 32768;
      state.head = null;
      state.hold = 0;
      state.bits = 0;
      const Buf32 = require(12646) /* _has */.Buf32;
      const prototype = Buf32.prototype;
      const buf32 = new Buf32(852);
      state.lendyn = buf32;
      state.lencode = buf32;
      const Buf322 = require(12646) /* _has */.Buf32;
      const prototype2 = Buf322.prototype;
      const buf322 = new Buf322(592);
      state.distdyn = buf322;
      state.distcode = buf322;
      state.sane = 1;
      state.back = -1;
      num = 0;
    }
  }
  return num;
}
function inflateReset(state) {
  let num = -2;
  if (state) {
    num = -2;
    if (state.state) {
      state = state.state;
      state.wsize = 0;
      state.whave = 0;
      state.wnext = 0;
      num = inflateResetKeep(state);
    }
  }
  return num;
}
function inflateReset2(state, windowBits) {
  let num = -2;
  if (state) {
    num = -2;
    if (state.state) {
      state = state.state;
      if (windowBits < 0) {
        let tmp2 = -windowBits;
        let num6 = 0;
      } else {
        const sum = 1 + (windowBits >> 4);
        num6 = sum;
        tmp2 = windowBits;
        if (windowBits < 48) {
          tmp2 = windowBits & 15;
          num6 = sum;
        }
      }
      if (!tmp2) {
        if (tmp4) {
          state.window = null;
        }
        state.wrap = num6;
        state.wbits = tmp2;
        let num9 = inflateReset(state);
        tmp4 = null !== state.window && state.wbits !== tmp2;
      } else {
        num9 = -2;
        if (tmp2 >= 8) {
          num9 = -2;
        }
      }
      num = num9;
    }
  }
  return num;
}
function inflateInit2(strm, windowBits) {
  let num = -2;
  if (strm) {
    const prototype = InflateState.prototype;
    const tmp4 = new InflateState();
    strm.state = tmp4;
    tmp4.window = null;
    const tmp9 = inflateReset2(strm, windowBits);
    num = tmp9;
    if (0 !== tmp9) {
      strm.state = null;
      num = tmp9;
    }
  }
  return num;
}
function fixedtables(state) {
  let sum;
  if (c4) {
    const Buf32 = require(12646) /* _has */.Buf32;
    const prototype = Buf32.prototype;
    const buf32 = new Buf32(512);
    const Buf322 = require(12646) /* _has */.Buf32;
    const prototype2 = Buf322.prototype;
    const buf322 = new Buf322(32);
    let num7 = 0;
    do {
      let tmp11 = +num7;
      sum = tmp11 + 1;
      state.lens[tmp11] = 8;
      num7 = sum;
    } while (sum < 144);
    let sum1 = sum;
    let tmp14 = sum;
    if (sum < 256) {
      do {
        let tmp15 = +sum1;
        sum1 = tmp15 + 1;
        state.lens[tmp15] = 9;
        tmp14 = sum1;
      } while (sum1 < 256);
    }
    let sum2 = tmp14;
    let sum3 = tmp14;
    if (tmp14 < 280) {
      do {
        let tmp18 = +sum2;
        sum2 = tmp18 + 1;
        state.lens[tmp18] = 7;
        sum3 = sum2;
      } while (sum2 < 280);
    }
    if (sum3 < 288) {
      do {
        let tmp19 = +sum3;
        sum3 = tmp19 + 1;
        state.lens[tmp19] = 8;
      } while (sum3 < 288);
    }
    let obj = { bits: 9 };
    require(12657) /* inflate_table */(1, state.lens, 0, 288, buf32, 0, state.work, obj);
    let num19 = 0;
    do {
      let tmp25 = +num19;
      num19 = tmp25 + 1;
      state.lens[tmp25] = 5;
    } while (num19 < 32);
    obj = { bits: 5 };
    require(12657) /* inflate_table */(2, state.lens, 0, 32, buf322, 0, state.work, obj);
    c4 = false;
  }
  state.lencode = buf32;
  state.lenbits = 9;
  state.distcode = buf322;
  state.distbits = 5;
}
function updatewindow(state, output3, length, buf8) {
  state = state.state;
  if (null === state.window) {
    state.wsize = 1 << state.wbits;
    state.wnext = 0;
    state.whave = 0;
    const Buf8 = require(12646) /* _has */.Buf8;
    const prototype = Buf8.prototype;
    buf8 = new Buf8(state.wsize);
    state.window = buf8;
  }
  if (buf8 >= state.wsize) {
    const obj3 = require(12646) /* _has */;
    obj3.arraySet(state.window, output3, length - state.wsize, state.wsize, 0);
    state.wnext = 0;
    state.whave = state.wsize;
  } else {
    let diff = state.wsize - state.wnext;
    if (diff > buf8) {
      diff = buf8;
    }
    const obj = require(12646) /* _has */;
    obj.arraySet(state.window, output3, length - buf8, diff, state.wnext);
    const diff1 = buf8 - diff;
    if (diff1) {
      const obj2 = require(12646) /* _has */;
      obj2.arraySet(state.window, output3, length - diff1, diff1, 0);
      state.wnext = diff1;
      state.whave = state.wsize;
    } else {
      state.wnext = state.wnext + diff;
      if (state.wnext === state.wsize) {
        state.wnext = 0;
      }
      if (state.whave < state.wsize) {
        state.whave = state.whave + diff;
      }
    }
  }
  return 0;
}
let c4 = true;
arg5.inflateReset = inflateReset;
arg5.inflateReset2 = inflateReset2;
arg5.inflateResetKeep = inflateResetKeep;
arg5.inflateInit = function inflateInit(strm) {
  return inflateInit2(strm, 15);
};
arg5.inflateInit2 = inflateInit2;
arg5.inflate = function inflate(state) {
  let avail_in;
  let avail_in2;
  let avail_out;
  let avail_out2;
  let bits;
  let bits3;
  let hold;
  let hold2;
  let input;
  let input2;
  let mode;
  let next_in;
  let next_in2;
  let next_out;
  let next_out2;
  let output;
  let output2;
  let tmp24;
  let buf8 = new require(12646) /* _has */.Buf8(4);
  const items = [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15];
  if (state) {
    if (state.state) {
      if (state.output) {
        state = state.state;
        let num = 12;
        if (state.mode === 12) {
          state.mode = 13;
        }
        ({ next_out, output, avail_out, next_in, input, avail_in } = state);
        ({ hold, bits } = state);
        let diff2 = avail_in;
        let tmp6 = avail_out;
        let num50 = 0;
        while (true) {
          mode = state.mode;
          let tmp16 = input;
          let tmp17 = output;
          let tmp18 = next_in;
          let tmp19 = next_out;
          let tmp20 = diff2;
          let tmp21 = avail_out;
          let tmp22 = hold;
          let tmp23 = bits;
          tmp24 = tmp6;
          let tmp25 = tmp7;
          let tmp26 = tmp8;
          let tmp27 = tmp9;
          let tmp28 = tmp10;
          let tmp29 = tmp11;
          let tmp30 = tmp12;
          let tmp31 = tmp13;
          let tmp32 = tmp14;
          let tmp33 = num50;
          let tmp34 = tmp15;
          if (1 === mode) {
            if (0 === state.wrap) {
              state.mode = 13;
              continue;
            } else {
              buf8 = next_in;
              buf8 = diff2;
              buf8 = hold;
              buf8 = bits;
              buf8 = next_in;
              buf8 = diff2;
              buf8 = hold;
              buf8 = bits;
              if (bits >= 16) {
                if (2 & state.wrap) {
                  if (35615 === buf8) {
                    state.check = 0;
                    buf8[0] = 255 & buf8;
                    buf8[1] = buf8 >>> 8 & 255;
                    buf8 = require;
                    buf8 = dependencyMap;
                    buf8 = num58;
                    buf8 = num58;
                    let check11 = state.check;
                    buf8 = check11;
                    let num96 = 2;
                    num58 = 0;
                    let num97 = 0;
                    state.check = require(12653)(check11, tmp2, 2, 0);
                    state.mode = 2;
                    next_in = buf8;
                    diff2 = buf8;
                    hold = 0;
                    bits = 0;
                    continue;
                  }
                }
                state.flags = 0;
                if (state.head) {
                  state.head.done = false;
                }
                if (1 & state.wrap) {
                  if (!((((255 & buf8) << 8) + (buf8 >> 8)) % 31)) {
                    if (8 !== (15 & buf8)) {
                      state.msg = "unknown compression method";
                      state.mode = 30;
                      next_in = buf8;
                      diff2 = buf8;
                      hold = buf8;
                      bits = buf8;
                      continue;
                    } else {
                      bits = buf8 - 4;
                      buf8 = buf8 >>> 4;
                      buf8 = 8 + (15 & buf8);
                      if (0 === state.wbits) {
                        state.wbits = buf8;
                      } else {
                        if (buf8 > state.wbits) {
                          state.msg = "invalid window size";
                          state.mode = 30;
                          next_in = buf8;
                          diff2 = buf8;
                          hold = buf8;
                          tmp14 = buf8;
                          continue;
                        }
                        continue;
                      }
                      state.dmax = 1 << buf8;
                      state.check = 1;
                      state.adler = 1;
                      let num95 = 10;
                      if (!(512 & buf8)) {
                        num95 = 12;
                      }
                      state.mode = num95;
                      next_in = buf8;
                      diff2 = buf8;
                      hold = 0;
                      bits = 0;
                      tmp14 = buf8;
                      continue;
                    }
                    continue;
                  }
                  continue;
                }
                state.msg = "incorrect header check";
                state.mode = 30;
                next_in = buf8;
                diff2 = buf8;
                hold = buf8;
                bits = buf8;
                continue;
              } else {
                let tmp50 = buf8;
                let num55 = buf8;
                let num56 = buf8;
                let tmp51 = tmp6;
                let num57 = num50;
                let tmp52 = buf8;
                while (0 !== buf8) {
                  buf8 = buf8 - 1;
                  buf8 = +buf8;
                  buf8 = buf8 + 1;
                  buf8 = buf8 + (input[buf8] << buf8);
                  buf8 = buf8 + 8;
                  continue;
                }
              }
            }
          } else {
            if (2 === mode) {
              buf8 = next_in;
              buf8 = diff2;
              buf8 = hold;
              buf8 = bits;
              buf8 = next_in;
              buf8 = diff2;
              buf8 = hold;
              buf8 = bits;
              if (bits >= 16) {
                state.flags = buf8;
                if (8 !== (255 & state.flags)) {
                  state.msg = "unknown compression method";
                  state.mode = 30;
                  next_in = buf8;
                  diff2 = buf8;
                  hold = buf8;
                  bits = buf8;
                  continue;
                } else if (57344 & state.flags) {
                  state.msg = "unknown header flags set";
                  state.mode = 30;
                  next_in = buf8;
                  diff2 = buf8;
                  hold = buf8;
                  bits = buf8;
                  continue;
                } else {
                  if (state.head) {
                    state.head.text = buf8 >> 8 & 1;
                  }
                  if (512 & state.flags) {
                    buf8[0] = 255 & buf8;
                    buf8[1] = buf8 >>> 8 & 255;
                    buf8 = require;
                    buf8 = dependencyMap;
                    buf8 = num58;
                    buf8 = num58;
                    let check4 = state.check;
                    buf8 = check4;
                    let num77 = 2;
                    num58 = 0;
                    let num78 = 0;
                    state.check = require(12653)(check4, tmp2, 2, 0);
                  }
                  state.mode = 3;
                  let num79 = 0;
                  let num80 = 0;
                }
                continue;
              } else {
                tmp50 = buf8;
                num55 = buf8;
                num56 = buf8;
                tmp51 = tmp6;
                num57 = num50;
                tmp52 = buf8;
                while (0 !== buf8) {
                  buf8 = buf8 - 1;
                  buf8 = +buf8;
                  buf8 = buf8 + 1;
                  buf8 = buf8 + (input[buf8] << buf8);
                  buf8 = buf8 + 8;
                  continue;
                }
              }
            } else {
              buf8 = next_in;
              buf8 = diff2;
              num79 = hold;
              num80 = bits;
              if (3 !== mode) {
                buf8 = next_in;
                buf8 = diff2;
                let num83 = hold;
                let num84 = bits;
                if (4 !== mode) {
                  buf8 = next_in;
                  buf8 = diff2;
                  let num87 = hold;
                  let num88 = bits;
                  if (5 !== mode) {
                    buf8 = next_in;
                    buf8 = diff2;
                    buf8 = hold;
                    buf8 = bits;
                    if (6 === mode) {
                      buf8 = tmp18;
                      buf8 = tmp20;
                      buf8 = tmp7;
                      buf8 = tmp14;
                      if (!(1024 & state.flags)) {
                        state.length = 0;
                        state.mode = 7;
                        buf8 = tmp22;
                        buf8 = tmp23;
                      } else {
                        let length9 = state.length;
                        if (length9 > tmp20) {
                          length9 = tmp20;
                        }
                        buf8 = tmp18;
                        buf8 = tmp20;
                        buf8 = tmp14;
                        if (length9) {
                          buf8 = tmp14;
                          if (state.head) {
                            buf8 = state.head.extra_len - state.length;
                            if (!state.head.extra) {
                              let _Array = Array;
                              num58 = state.head.extra_len;
                              buf8 = num58;
                              buf8 = new.target;
                              buf8 = new.target;
                              buf8 = new Array(num58);
                              state.head.extra = buf8;
                            }
                            buf8 = require;
                            buf8 = dependencyMap;
                            buf8 = num58;
                            buf8 = num58;
                            let obj3 = require(12646) /* _has */;
                            num58 = state.head.extra;
                            buf8 = num58;
                            buf8 = obj3;
                            buf8 = input;
                            buf8 = tmp18;
                            buf8 = length9;
                            buf8 = obj3.arraySet(num58, tmp16, buf8, length9, buf8);
                          }
                          if (512 & state.flags) {
                            buf8 = require;
                            buf8 = dependencyMap;
                            buf8 = num58;
                            buf8 = num58;
                            let check8 = state.check;
                            buf8 = check8;
                            buf8 = input;
                            buf8 = length9;
                            buf8 = tmp18;
                            state.check = require(12653)(check8, tmp16, length9, buf8);
                          }
                          buf8 = tmp20 - length9;
                          buf8 = tmp18 + length9;
                          state.length = state.length - length9;
                        }
                        buf8 = length9;
                        tmp50 = buf8;
                        tmp52 = buf8;
                        num55 = tmp22;
                        num56 = tmp23;
                        tmp51 = tmp6;
                        num57 = num50;
                      }
                    } else {
                      buf8 = next_in;
                      buf8 = diff2;
                      buf8 = hold;
                      buf8 = bits;
                      buf8 = tmp7;
                      buf8 = tmp14;
                      if (7 !== mode) {
                        buf8 = diff2;
                        buf8 = hold;
                        buf8 = bits;
                        buf8 = tmp7;
                        buf8 = tmp14;
                        if (8 === mode) {
                          if (4096 & state.flags) {
                            let num94 = 0;
                            tmp50 = tmp18;
                            num55 = tmp22;
                            num56 = tmp23;
                            tmp51 = tmp6;
                            num57 = num50;
                            tmp52 = tmp20;
                            if (0 !== tmp20) {
                              while (true) {
                                buf8 = +num94;
                                buf8 = buf8 + 1;
                                buf8 = input[tmp18 + buf8];
                                buf8 = state.head && buf8 && state.length < 65536;
                                if (buf8) {
                                  let head2 = state.head;
                                  let _String2 = String;
                                  buf8 = num58;
                                  buf8 = num58;
                                  head2.comment = head2.comment + String.fromCharCode(buf8);
                                }
                                if (!buf8) {
                                  break;
                                } else {
                                  num94 = buf8;
                                  if (buf8 >= tmp20) {
                                    break;
                                  }
                                }
                              }
                              if (512 & state.flags) {
                                buf8 = require;
                                buf8 = dependencyMap;
                                buf8 = num58;
                                buf8 = num58;
                                let check10 = state.check;
                                buf8 = check10;
                                buf8 = input;
                                buf8 = tmp18;
                                state.check = require(12653)(check10, tmp16, buf8, buf8);
                              }
                              buf8 = tmp20 - buf8;
                              buf8 = tmp18 + buf8;
                              tmp50 = buf8;
                              tmp52 = buf8;
                              num55 = tmp22;
                              num56 = tmp23;
                              tmp51 = tmp6;
                              num57 = num50;
                            }
                          } else {
                            buf8 = tmp18;
                            buf8 = tmp20;
                            buf8 = tmp25;
                            buf8 = tmp32;
                            if (state.head) {
                              state.head.comment = null;
                              buf8 = tmp18;
                              buf8 = tmp20;
                              buf8 = tmp25;
                              buf8 = tmp32;
                            }
                          }
                          state.mode = 9;
                          buf8 = tmp22;
                          buf8 = tmp23;
                        } else {
                          buf8 = next_in;
                          buf8 = diff2;
                          buf8 = hold;
                          buf8 = bits;
                          buf8 = tmp7;
                          buf8 = tmp14;
                          if (9 === mode) {
                            next_in = tmp18;
                            diff2 = tmp20;
                            hold = tmp22;
                            bits = tmp23;
                            if (512 & state.flags) {
                              buf8 = tmp18;
                              buf8 = tmp20;
                              buf8 = tmp22;
                              buf8 = tmp23;
                              buf8 = tmp18;
                              buf8 = tmp20;
                              buf8 = tmp22;
                              buf8 = tmp23;
                              if (tmp23 >= 16) {
                                next_in = buf8;
                                diff2 = buf8;
                                hold = 0;
                                bits = 0;
                                if (buf8 !== (65535 & state.check)) {
                                  state.msg = "header crc mismatch";
                                  state.mode = 30;
                                  next_in = buf8;
                                  diff2 = buf8;
                                  hold = buf8;
                                  bits = buf8;
                                  tmp7 = tmp25;
                                  tmp14 = tmp32;
                                  continue;
                                }
                              } else {
                                tmp50 = buf8;
                                num55 = buf8;
                                num56 = buf8;
                                tmp51 = tmp6;
                                num57 = num50;
                                tmp52 = buf8;
                                while (0 !== buf8) {
                                  buf8 = buf8 - 1;
                                  buf8 = +buf8;
                                  buf8 = buf8 + 1;
                                  buf8 = buf8 + (input[buf8] << buf8);
                                  buf8 = buf8 + 8;
                                  break;
                                }
                              }
                            }
                            if (state.head) {
                              state.head.hcrc = state.flags >> 9 & 1;
                              state.head.done = true;
                            }
                            state.check = 0;
                            state.adler = 0;
                            state.mode = 12;
                            tmp7 = tmp25;
                            tmp14 = tmp32;
                            continue;
                          } else {
                            if (10 === mode) {
                              buf8 = next_in;
                              buf8 = diff2;
                              buf8 = hold;
                              buf8 = bits;
                              buf8 = next_in;
                              buf8 = diff2;
                              buf8 = hold;
                              if (bits >= 32) {
                                buf8 = zswap32;
                                buf8 = num58;
                                buf8 = num58;
                                buf8 = zswap32(buf8);
                                state.check = buf8;
                                state.adler = buf8;
                                state.mode = 11;
                                let num75 = 0;
                                let num76 = 0;
                              } else {
                                tmp50 = buf8;
                                num55 = buf8;
                                num56 = buf8;
                                tmp51 = tmp6;
                                num57 = num50;
                                tmp52 = buf8;
                                while (0 !== buf8) {
                                  buf8 = buf8 - 1;
                                  buf8 = +buf8;
                                  buf8 = buf8 + 1;
                                  buf8 = buf8 + (input[buf8] << buf8);
                                  buf8 = buf8 + 8;
                                  break;
                                }
                              }
                            } else {
                              buf8 = next_in;
                              buf8 = diff2;
                              num75 = hold;
                              num76 = bits;
                              if (11 !== mode) {
                                buf8 = next_in;
                                buf8 = diff2;
                                buf8 = hold;
                                buf8 = bits;
                                if (12 !== mode) {
                                  buf8 = next_in;
                                  buf8 = diff2;
                                  buf8 = hold;
                                  buf8 = bits;
                                  if (13 !== mode) {
                                    if (14 === mode) {
                                      buf8 = hold >>> (7 & bits);
                                      buf8 = bits - (7 & bits);
                                      buf8 = next_in;
                                      buf8 = diff2;
                                      buf8 = next_in;
                                      buf8 = diff2;
                                      if (buf8 >= 32) {
                                        buf8 = 65535 & buf8;
                                        if (buf8 !== (buf8 >>> 16 ^ 65535)) {
                                          state.msg = "invalid stored block lengths";
                                          state.mode = 30;
                                          next_in = buf8;
                                          diff2 = buf8;
                                          hold = buf8;
                                          bits = buf8;
                                          continue;
                                        } else {
                                          state.length = buf8;
                                          state.mode = 15;
                                          num = 0;
                                          num = 0;
                                          tmp50 = buf8;
                                          tmp52 = buf8;
                                          num55 = 0;
                                          num56 = 0;
                                          tmp51 = tmp6;
                                          num57 = num50;
                                        }
                                      } else {
                                        tmp50 = buf8;
                                        num55 = buf8;
                                        num56 = buf8;
                                        tmp51 = tmp6;
                                        num57 = num50;
                                        tmp52 = buf8;
                                        while (0 !== buf8) {
                                          buf8 = buf8 - 1;
                                          buf8 = +buf8;
                                          buf8 = buf8 + 1;
                                          buf8 = buf8 + (input[buf8] << buf8);
                                          buf8 = buf8 + 8;
                                          break;
                                        }
                                      }
                                    } else {
                                      buf8 = next_in;
                                      buf8 = diff2;
                                      num = hold;
                                      num = bits;
                                      if (15 !== mode) {
                                        buf8 = next_in;
                                        buf8 = diff2;
                                        buf8 = hold;
                                        buf8 = bits;
                                        if (16 !== mode) {
                                          if (17 === mode) {
                                            buf8 = next_in;
                                            buf8 = diff2;
                                            buf8 = hold;
                                            buf8 = bits;
                                            buf8 = next_in;
                                            buf8 = diff2;
                                            buf8 = hold;
                                            buf8 = bits;
                                            if (bits >= 14) {
                                              state.nlen = 257 + (31 & buf8);
                                              buf8 = buf8 >>> 5;
                                              state.ndist = 1 + (31 & buf8);
                                              buf8 = buf8 >>> 5;
                                              state.ncode = 4 + (15 & buf8);
                                              buf8 = buf8 >>> 4;
                                              buf8 = buf8 - 5 - 5 - 4;
                                              if (state.nlen <= 286) {
                                                if (state.ndist <= 30) {
                                                  state.have = 0;
                                                  state.mode = 18;
                                                }
                                              }
                                              state.msg = "too many length or distance symbols";
                                              state.mode = 30;
                                              next_in = buf8;
                                              diff2 = buf8;
                                              hold = buf8;
                                              bits = buf8;
                                              continue;
                                            } else {
                                              tmp50 = buf8;
                                              num55 = buf8;
                                              num56 = buf8;
                                              tmp51 = tmp6;
                                              num57 = num50;
                                              tmp52 = buf8;
                                              while (0 !== buf8) {
                                                buf8 = buf8 - 1;
                                                buf8 = +buf8;
                                                buf8 = buf8 + 1;
                                                buf8 = buf8 + (input[buf8] << buf8);
                                                buf8 = buf8 + 8;
                                                break;
                                              }
                                            }
                                          } else {
                                            buf8 = next_in;
                                            buf8 = diff2;
                                            buf8 = hold;
                                            buf8 = bits;
                                            if (18 !== mode) {
                                              buf8 = next_in;
                                              buf8 = diff2;
                                              buf8 = hold;
                                              buf8 = bits;
                                              buf8 = num50;
                                              if (19 !== mode) {
                                                buf8 = next_in;
                                                buf8 = diff2;
                                                buf8 = hold;
                                                buf8 = bits;
                                                buf8 = tmp7;
                                                buf8 = tmp8;
                                                buf8 = tmp9;
                                                buf8 = tmp10;
                                                buf8 = tmp14;
                                                buf8 = num50;
                                                buf8 = tmp15;
                                                if (20 !== mode) {
                                                  buf8 = next_in;
                                                  buf8 = diff2;
                                                  buf8 = hold;
                                                  buf8 = bits;
                                                  buf8 = tmp7;
                                                  buf8 = tmp8;
                                                  buf8 = tmp9;
                                                  buf8 = tmp10;
                                                  buf8 = tmp14;
                                                  buf8 = num50;
                                                  buf8 = tmp15;
                                                  if (21 !== mode) {
                                                    buf8 = next_in;
                                                    buf8 = diff2;
                                                    buf8 = hold;
                                                    buf8 = bits;
                                                    buf8 = tmp7;
                                                    buf8 = tmp11;
                                                    buf8 = tmp12;
                                                    buf8 = tmp13;
                                                    buf8 = tmp14;
                                                    buf8 = num50;
                                                    buf8 = tmp15;
                                                    if (22 !== mode) {
                                                      buf8 = next_in;
                                                      buf8 = diff2;
                                                      buf8 = hold;
                                                      buf8 = bits;
                                                      buf8 = tmp7;
                                                      buf8 = tmp11;
                                                      buf8 = tmp12;
                                                      buf8 = tmp13;
                                                      buf8 = tmp14;
                                                      buf8 = num50;
                                                      buf8 = tmp15;
                                                      if (23 !== mode) {
                                                        buf8 = next_in;
                                                        buf8 = diff2;
                                                        buf8 = hold;
                                                        buf8 = bits;
                                                        buf8 = tmp7;
                                                        buf8 = tmp8;
                                                        buf8 = tmp9;
                                                        buf8 = tmp10;
                                                        buf8 = tmp11;
                                                        buf8 = tmp12;
                                                        buf8 = tmp13;
                                                        buf8 = tmp14;
                                                        buf8 = num50;
                                                        buf8 = tmp15;
                                                        if (24 !== mode) {
                                                          buf8 = next_in;
                                                          buf8 = diff2;
                                                          buf8 = hold;
                                                          buf8 = bits;
                                                          buf8 = tmp8;
                                                          buf8 = tmp9;
                                                          buf8 = tmp10;
                                                          buf8 = tmp11;
                                                          buf8 = tmp12;
                                                          buf8 = tmp13;
                                                          buf8 = tmp14;
                                                          buf8 = num50;
                                                          buf8 = tmp15;
                                                          if (25 !== mode) {
                                                            if (26 === mode) {
                                                              tmp50 = next_in;
                                                              tmp52 = diff2;
                                                              num55 = hold;
                                                              num56 = bits;
                                                              tmp51 = tmp6;
                                                              num57 = num50;
                                                              if (0 !== avail_out) {
                                                                buf8 = +next_out;
                                                                next_out = buf8 + 1;
                                                                output[buf8] = state.length;
                                                                avail_out = avail_out - 1;
                                                                state.mode = 21;
                                                                continue;
                                                              }
                                                            } else {
                                                              if (27 === mode) {
                                                                let tmp39 = next_in;
                                                                let tmp40 = diff2;
                                                                let num53 = hold;
                                                                let num54 = bits;
                                                                let tmp41 = tmp6;
                                                                if (!state.wrap) {
                                                                  state.mode = 28;
                                                                  let tmp35 = tmp39;
                                                                  let tmp36 = tmp40;
                                                                  let tmp37 = num53;
                                                                  let tmp38 = num54;
                                                                  tmp6 = tmp41;
                                                                } else {
                                                                  let tmp42 = next_in;
                                                                  let tmp43 = diff2;
                                                                  let tmp44 = hold;
                                                                  let tmp45 = bits;
                                                                  let tmp46 = next_in;
                                                                  let tmp47 = diff2;
                                                                  let tmp48 = hold;
                                                                  let tmp49 = bits;
                                                                  if (bits >= 32) {
                                                                    let diff = tmp6 - avail_out;
                                                                    let tmp54 = diff;
                                                                    let total_out = state.total_out;
                                                                    let tmp55 = total_out;
                                                                    let tmp56 = total_out;
                                                                    let tmp57 = diff;
                                                                    let sum = total_out + diff;
                                                                    let tmp59 = sum;
                                                                    let tmp60 = sum;
                                                                    state.total_out = sum;
                                                                    let total = state.total;
                                                                    let tmp61 = total;
                                                                    let tmp62 = total;
                                                                    let tmp63 = diff;
                                                                    let sum1 = total + diff;
                                                                    let tmp65 = sum1;
                                                                    let tmp66 = sum1;
                                                                    state.total = sum1;
                                                                    let tmp67 = diff;
                                                                    if (!diff) {
                                                                      let flags2 = state.flags;
                                                                      buf8 = flags2;
                                                                      buf8 = tmp48;
                                                                      buf8 = flags2;
                                                                      if (!flags2) {
                                                                        buf8 = zswap32;
                                                                        buf8 = zswap32;
                                                                        buf8 = zswap32;
                                                                        buf8 = zswap32;
                                                                        buf8 = zswap32;
                                                                        buf8 = zswap32(tmp48);
                                                                      }
                                                                      let check3 = state.check;
                                                                      buf8 = check3;
                                                                      tmp39 = tmp46;
                                                                      tmp40 = tmp47;
                                                                      num53 = 0;
                                                                      num54 = 0;
                                                                      tmp41 = avail_out;
                                                                      num58 = buf8;
                                                                      buf8 = check3;
                                                                      if (buf8 !== check3) {
                                                                        state.msg = "incorrect data check";
                                                                        state.mode = 30;
                                                                        next_in = tmp46;
                                                                        diff2 = tmp47;
                                                                        hold = tmp48;
                                                                        bits = tmp49;
                                                                        tmp6 = avail_out;
                                                                        continue;
                                                                      }
                                                                    } else {
                                                                      let flags = state.flags;
                                                                      let tmp68 = flags;
                                                                      let tmp69 = require;
                                                                      let tmp70 = require;
                                                                      let tmp71 = dependencyMap;
                                                                      let tmp72 = dependencyMap;
                                                                      let tmp73 = flags;
                                                                      if (flags) {
                                                                        let tmp92 = tmp72;
                                                                        let tmp93 = 12653;
                                                                        tmp72 = tmp93;
                                                                        let tmp94 = tmp93;
                                                                        let tmp95 = tmp93;
                                                                        let tmp96 = tmp93;
                                                                        let tmp97 = tmp69;
                                                                        let tmp98 = tmp93;
                                                                        let tmp70Result = tmp70(tmp93);
                                                                        buf8 = tmp70Result;
                                                                        let check2 = state.check;
                                                                        buf8 = check2;
                                                                        buf8 = diff;
                                                                        buf8 = next_out - tmp54;
                                                                        buf8 = output;
                                                                        buf8 = diff;
                                                                        buf8 = tmp70Result;
                                                                        let tmp70ResultResult = tmp70Result(check2, tmp17, tmp54, buf8);
                                                                      } else {
                                                                        let tmp74 = tmp72;
                                                                        let tmp75 = 12652;
                                                                        let tmp76 = tmp75;
                                                                        let tmp77 = tmp75;
                                                                        let tmp78 = tmp75;
                                                                        let tmp79 = tmp75;
                                                                        let tmp80 = tmp69;
                                                                        let tmp81 = tmp75;
                                                                        tmp70Result = tmp70(tmp75);
                                                                        let tmp83 = tmp70Result;
                                                                        let check = state.check;
                                                                        let tmp84 = check;
                                                                        let tmp85 = diff;
                                                                        let diff1 = next_out - tmp54;
                                                                        let tmp87 = diff1;
                                                                        let tmp88 = output;
                                                                        let tmp89 = diff;
                                                                        let tmp90 = tmp70Result;
                                                                        tmp70ResultResult = tmp70Result(check, tmp17, tmp54, diff1);
                                                                      }
                                                                      buf8 = tmp70ResultResult;
                                                                      state.check = tmp70ResultResult;
                                                                      buf8 = tmp70ResultResult;
                                                                      state.adler = tmp70ResultResult;
                                                                    }
                                                                  } else {
                                                                    tmp50 = tmp42;
                                                                    num55 = tmp44;
                                                                    num56 = tmp45;
                                                                    tmp51 = tmp6;
                                                                    num57 = num50;
                                                                    tmp52 = tmp43;
                                                                    while (0 !== tmp43) {
                                                                      buf8 = tmp43;
                                                                      buf8 = tmp43 - 1;
                                                                      tmp43 = buf8;
                                                                      buf8 = tmp42;
                                                                      buf8 = +tmp42;
                                                                      buf8 = buf8 + 1;
                                                                      tmp42 = buf8;
                                                                      buf8 = input[buf8];
                                                                      buf8 = tmp45;
                                                                      buf8 = buf8 << tmp45;
                                                                      buf8 = tmp44;
                                                                      buf8 = tmp44 | buf8;
                                                                      tmp44 = buf8;
                                                                      buf8 = tmp45;
                                                                      num58 = tmp45 + 8;
                                                                      tmp45 = num58;
                                                                      tmp46 = buf8;
                                                                      tmp47 = buf8;
                                                                      tmp48 = buf8;
                                                                      tmp49 = num58;
                                                                      break;
                                                                    }
                                                                  }
                                                                }
                                                              } else {
                                                                tmp35 = next_in;
                                                                tmp36 = diff2;
                                                                tmp37 = hold;
                                                                tmp38 = bits;
                                                                if (28 !== mode) {
                                                                  break;
                                                                }
                                                              }
                                                              let wrap = state.wrap;
                                                              buf8 = wrap;
                                                              buf8 = tmp35;
                                                              buf8 = tmp36;
                                                              let num59 = tmp37;
                                                              let num60 = tmp38;
                                                              buf8 = wrap;
                                                              if (wrap) {
                                                                let flags3 = state.flags;
                                                                buf8 = flags3;
                                                                buf8 = tmp35;
                                                                buf8 = tmp36;
                                                                num59 = tmp37;
                                                                num60 = tmp38;
                                                                buf8 = flags3;
                                                                if (flags3) {
                                                                  buf8 = tmp35;
                                                                  buf8 = tmp36;
                                                                  buf8 = tmp37;
                                                                  buf8 = tmp38;
                                                                  next_in = tmp35;
                                                                  diff2 = tmp36;
                                                                  hold = tmp37;
                                                                  bits = tmp38;
                                                                  num58 = tmp38;
                                                                  if (tmp38 >= 32) {
                                                                    let total2 = state.total;
                                                                    buf8 = total2;
                                                                    buf8 = total2;
                                                                    buf8 = 4294967295 & total2;
                                                                    buf8 = next_in;
                                                                    buf8 = diff2;
                                                                    num59 = 0;
                                                                    num60 = 0;
                                                                    num58 = buf8;
                                                                    if (hold !== buf8) {
                                                                      state.msg = "incorrect length check";
                                                                      state.mode = 30;
                                                                      continue;
                                                                    }
                                                                  } else {
                                                                    tmp50 = buf8;
                                                                    num55 = buf8;
                                                                    num56 = buf8;
                                                                    tmp51 = tmp6;
                                                                    num57 = num50;
                                                                    tmp52 = buf8;
                                                                    while (0 !== buf8) {
                                                                      buf8 = buf8 - 1;
                                                                      buf8 = +buf8;
                                                                      buf8 = buf8 + 1;
                                                                      buf8 = input[buf8];
                                                                      buf8 = buf8 << buf8;
                                                                      buf8 = buf8 + buf8;
                                                                      num58 = buf8 + 8;
                                                                      buf8 = num58;
                                                                      next_in = buf8;
                                                                      diff2 = buf8;
                                                                      hold = buf8;
                                                                      bits = num58;
                                                                      break;
                                                                    }
                                                                  }
                                                                }
                                                              }
                                                              let num61 = 29;
                                                              let num62 = 29;
                                                              num58 = 29;
                                                              state.mode = 29;
                                                              buf8 = num59;
                                                              buf8 = num60;
                                                              buf8 = tmp6;
                                                              tmp50 = buf8;
                                                              tmp52 = buf8;
                                                              num55 = buf8;
                                                              num56 = buf8;
                                                              tmp51 = buf8;
                                                              num57 = 1;
                                                            }
                                                          }
                                                        }
                                                        tmp50 = buf8;
                                                        tmp52 = buf8;
                                                        num55 = buf8;
                                                        num56 = buf8;
                                                        tmp51 = tmp6;
                                                        num57 = buf8;
                                                        if (0 !== avail_out) {
                                                          buf8 = tmp6 - avail_out;
                                                          let offset5 = state.offset;
                                                          buf8 = offset5;
                                                          buf8 = offset5;
                                                          if (offset5 > buf8) {
                                                            let offset4 = state.offset;
                                                            buf8 = offset4;
                                                            buf8 = offset4;
                                                            buf8 = offset4 - buf8;
                                                            let whave = state.whave;
                                                            buf8 = whave;
                                                            buf8 = whave;
                                                            if (buf8 > whave) {
                                                              let sane = state.sane;
                                                              buf8 = sane;
                                                              num58 = sane;
                                                              if (sane) {
                                                                state.msg = "invalid distance too far back";
                                                                state.mode = 30;
                                                                next_in = buf8;
                                                                diff2 = buf8;
                                                                hold = buf8;
                                                                bits = buf8;
                                                                tmp7 = buf8;
                                                                tmp8 = buf8;
                                                                tmp9 = buf8;
                                                                tmp10 = buf8;
                                                                tmp11 = buf8;
                                                                tmp12 = buf8;
                                                                tmp13 = buf8;
                                                                tmp14 = buf8;
                                                                num50 = buf8;
                                                                tmp15 = buf8;
                                                                continue;
                                                              }
                                                            }
                                                            let wnext = state.wnext;
                                                            buf8 = wnext;
                                                            buf8 = wnext;
                                                            if (buf8 > wnext) {
                                                              let wnext3 = state.wnext;
                                                              buf8 = wnext3;
                                                              buf8 = wnext3;
                                                              buf8 = buf8 - wnext3;
                                                              let wsize = state.wsize;
                                                              buf8 = wsize;
                                                              buf8 = wsize;
                                                              buf8 = wsize - buf8;
                                                              let length4 = buf8;
                                                            } else {
                                                              let wnext2 = state.wnext;
                                                              buf8 = wnext2;
                                                              buf8 = wnext2;
                                                              buf8 = wnext2 - buf8;
                                                              length4 = buf8;
                                                            }
                                                            let length5 = state.length;
                                                            buf8 = length5;
                                                            buf8 = length4;
                                                            buf8 = length5;
                                                            if (length4 > length5) {
                                                              length4 = state.length;
                                                            }
                                                            let _window = state.window;
                                                            let length3 = length4;
                                                          } else {
                                                            let offset3 = state.offset;
                                                            buf8 = offset3;
                                                            buf8 = offset3;
                                                            buf8 = next_out - offset3;
                                                            length3 = state.length;
                                                            _window = output;
                                                          }
                                                          buf8 = length3;
                                                          if (length3 > avail_out) {
                                                            length3 = avail_out;
                                                          }
                                                          buf8 = length3;
                                                          buf8 = avail_out - length3;
                                                          let length6 = state.length;
                                                          buf8 = length6;
                                                          buf8 = length6;
                                                          buf8 = length3;
                                                          buf8 = length6 - length3;
                                                          state.length = buf8;
                                                          buf8 = next_out;
                                                          do {
                                                            buf8 = +buf8;
                                                            buf8 = buf8 + 1;
                                                            buf8 = +buf8;
                                                            buf8 = buf8 + 1;
                                                            buf8 = _window;
                                                            buf8 = _window[buf8];
                                                            output[buf8] = buf8;
                                                            buf8 = length3;
                                                            buf8 = length3 - 1;
                                                            length3 = buf8;
                                                          } while (buf8);
                                                          let length7 = state.length;
                                                          buf8 = length7;
                                                          next_in = buf8;
                                                          next_out = buf8;
                                                          diff2 = buf8;
                                                          avail_out = buf8;
                                                          hold = buf8;
                                                          bits = buf8;
                                                          tmp7 = buf8;
                                                          buf8 = _window;
                                                          tmp8 = buf8;
                                                          tmp9 = buf8;
                                                          tmp10 = buf8;
                                                          tmp11 = buf8;
                                                          tmp12 = buf8;
                                                          tmp13 = buf8;
                                                          tmp14 = buf8;
                                                          num50 = buf8;
                                                          tmp15 = buf8;
                                                          num58 = length7;
                                                          if (0 !== length7) {
                                                            continue;
                                                          } else {
                                                            state.mode = 21;
                                                            input = tmp16;
                                                            output = tmp17;
                                                            next_in = buf8;
                                                            next_out = buf8;
                                                            diff2 = buf8;
                                                            avail_out = buf8;
                                                            hold = buf8;
                                                            bits = buf8;
                                                            tmp6 = tmp24;
                                                            tmp7 = buf8;
                                                            buf8 = _window;
                                                            tmp8 = buf8;
                                                            tmp9 = buf8;
                                                            tmp10 = buf8;
                                                            tmp11 = buf8;
                                                            tmp12 = buf8;
                                                            tmp13 = buf8;
                                                            tmp14 = buf8;
                                                            num50 = buf8;
                                                            tmp15 = buf8;
                                                            continue;
                                                          }
                                                          continue;
                                                        }
                                                      }
                                                      let extra7 = state.extra;
                                                      buf8 = extra7;
                                                      buf8 = extra7;
                                                      if (extra7) {
                                                        let extra8 = state.extra;
                                                        num58 = buf8;
                                                        buf8 = extra8;
                                                        if (buf8 >= extra8) {
                                                          let offset = state.offset;
                                                          buf8 = offset;
                                                          let extra9 = state.extra;
                                                          buf8 = extra9;
                                                          buf8 = extra9;
                                                          buf8 = 1 << extra9;
                                                          buf8 = buf8 - 1;
                                                          buf8 = buf8 & buf8;
                                                          buf8 = offset;
                                                          buf8 = offset + buf8;
                                                          state.offset = buf8;
                                                          let extra10 = state.extra;
                                                          buf8 = extra10;
                                                          buf8 = extra10;
                                                          buf8 = buf8 >>> extra10;
                                                          let extra11 = state.extra;
                                                          buf8 = extra11;
                                                          buf8 = extra11;
                                                          buf8 = buf8 - extra11;
                                                          let back5 = state.back;
                                                          buf8 = back5;
                                                          let extra12 = state.extra;
                                                          buf8 = extra12;
                                                          buf8 = back5;
                                                          buf8 = extra12;
                                                          buf8 = back5 + extra12;
                                                          state.back = buf8;
                                                          buf8 = extra8;
                                                        } else {
                                                          tmp50 = buf8;
                                                          num55 = buf8;
                                                          num56 = buf8;
                                                          tmp51 = tmp6;
                                                          num57 = buf8;
                                                          tmp52 = buf8;
                                                          while (0 !== buf8) {
                                                            buf8 = buf8 - 1;
                                                            buf8 = +buf8;
                                                            buf8 = buf8 + 1;
                                                            buf8 = input[buf8];
                                                            buf8 = buf8 << buf8;
                                                            buf8 = buf8 + buf8;
                                                            buf8 = buf8 + 8;
                                                            num58 = buf8;
                                                            buf8 = extra8;
                                                            break;
                                                          }
                                                        }
                                                      }
                                                      let offset2 = state.offset;
                                                      buf8 = offset2;
                                                      let dmax = state.dmax;
                                                      buf8 = dmax;
                                                      num58 = offset2;
                                                      buf8 = dmax;
                                                      if (offset2 > dmax) {
                                                        state.msg = "invalid distance too far back";
                                                        state.mode = 30;
                                                        next_in = buf8;
                                                        diff2 = buf8;
                                                        hold = buf8;
                                                        bits = buf8;
                                                        tmp7 = buf8;
                                                        tmp8 = buf8;
                                                        tmp9 = buf8;
                                                        tmp10 = buf8;
                                                        tmp11 = buf8;
                                                        tmp12 = buf8;
                                                        tmp13 = buf8;
                                                        tmp14 = buf8;
                                                        num50 = buf8;
                                                        tmp15 = buf8;
                                                        continue;
                                                      } else {
                                                        state.mode = 25;
                                                      }
                                                    }
                                                    buf8 = state.distcode[buf8 & (1 << state.distbits) - 1];
                                                    buf8 = buf8 >>> 16 & 255;
                                                    buf8 = 65535 & buf8;
                                                    buf8 = buf8 >>> 24;
                                                    num58 = buf8;
                                                    if (buf8 <= buf8) {
                                                      buf8 = 240 & buf8;
                                                      num58 = buf8;
                                                      if (!buf8) {
                                                        let distcode2 = state.distcode;
                                                        buf8 = distcode2;
                                                        buf8 = buf8 + buf8;
                                                        buf8 = 1 << buf8;
                                                        buf8 = buf8 - 1;
                                                        buf8 = buf8 & buf8;
                                                        buf8 = buf8 >> buf8;
                                                        buf8 = buf8 + buf8;
                                                        buf8 = distcode2;
                                                        buf8 = distcode2[buf8];
                                                        buf8 = buf8 >>> 16;
                                                        buf8 = buf8 & 255;
                                                        buf8 = 65535 & buf8;
                                                        buf8 = buf8 >>> 24;
                                                        buf8 = buf8 + buf8;
                                                        num58 = buf8;
                                                        if (buf8 <= buf8) {
                                                          buf8 = buf8 >>> buf8;
                                                          buf8 = buf8 - buf8;
                                                          let back4 = state.back;
                                                          buf8 = back4;
                                                          buf8 = back4;
                                                          buf8 = back4 + buf8;
                                                          num58 = buf8;
                                                          state.back = buf8;
                                                        } else {
                                                          tmp50 = buf8;
                                                          num55 = buf8;
                                                          num56 = buf8;
                                                          tmp51 = tmp6;
                                                          num57 = buf8;
                                                          tmp52 = buf8;
                                                          while (0 !== buf8) {
                                                            buf8 = buf8 - 1;
                                                            buf8 = +buf8;
                                                            buf8 = buf8 + 1;
                                                            buf8 = input[buf8];
                                                            buf8 = buf8 << buf8;
                                                            buf8 = buf8 + buf8;
                                                            buf8 = buf8 + 8;
                                                            let distcode3 = state.distcode;
                                                            buf8 = distcode3;
                                                            buf8 = buf8 & buf8;
                                                            buf8 = buf8 >> buf8;
                                                            buf8 = buf8 + buf8;
                                                            buf8 = distcode3;
                                                            buf8 = distcode3[buf8];
                                                            buf8 = buf8 >>> 16;
                                                            buf8 = buf8 & 255;
                                                            buf8 = 65535 & buf8;
                                                            buf8 = buf8 >>> 24;
                                                            buf8 = buf8 + buf8;
                                                            num58 = buf8;
                                                            break;
                                                          }
                                                        }
                                                      }
                                                      buf8 = buf8 >>> buf8;
                                                      buf8 = buf8 - buf8;
                                                      state.back = state.back + buf8;
                                                      if (64 & buf8) {
                                                        state.msg = "invalid distance code";
                                                        state.mode = 30;
                                                        next_in = buf8;
                                                        diff2 = buf8;
                                                        hold = buf8;
                                                        bits = buf8;
                                                        tmp7 = buf8;
                                                        tmp8 = buf8;
                                                        tmp9 = buf8;
                                                        tmp10 = buf8;
                                                        tmp11 = buf8;
                                                        tmp12 = buf8;
                                                        tmp13 = buf8;
                                                        tmp14 = buf8;
                                                        num50 = buf8;
                                                        tmp15 = buf8;
                                                        continue;
                                                      } else {
                                                        state.offset = buf8;
                                                        state.extra = 15 & buf8;
                                                        state.mode = 24;
                                                      }
                                                    } else {
                                                      tmp50 = buf8;
                                                      num55 = buf8;
                                                      num56 = buf8;
                                                      tmp51 = tmp6;
                                                      num57 = buf8;
                                                      tmp52 = buf8;
                                                      while (0 !== buf8) {
                                                        buf8 = buf8 - 1;
                                                        buf8 = +buf8;
                                                        buf8 = buf8 + 1;
                                                        buf8 = buf8 + (input[buf8] << buf8);
                                                        buf8 = buf8 + 8;
                                                        buf8 = state.distcode[buf8 & (1 << state.distbits) - 1];
                                                        buf8 = buf8 >>> 16 & 255;
                                                        buf8 = 65535 & buf8;
                                                        buf8 = buf8 >>> 24;
                                                        num58 = buf8;
                                                        break;
                                                      }
                                                    }
                                                  }
                                                  let extra = state.extra;
                                                  buf8 = extra;
                                                  buf8 = extra;
                                                  if (extra) {
                                                    let extra2 = state.extra;
                                                    num58 = buf8;
                                                    buf8 = extra2;
                                                    if (buf8 >= extra2) {
                                                      let length = state.length;
                                                      buf8 = length;
                                                      let extra3 = state.extra;
                                                      buf8 = extra3;
                                                      buf8 = extra3;
                                                      buf8 = 1 << extra3;
                                                      buf8 = buf8 - 1;
                                                      buf8 = buf8 & buf8;
                                                      buf8 = length;
                                                      buf8 = length + buf8;
                                                      state.length = buf8;
                                                      let extra4 = state.extra;
                                                      buf8 = extra4;
                                                      buf8 = extra4;
                                                      buf8 = buf8 >>> extra4;
                                                      let extra5 = state.extra;
                                                      buf8 = extra5;
                                                      buf8 = extra5;
                                                      buf8 = buf8 - extra5;
                                                      let back3 = state.back;
                                                      buf8 = back3;
                                                      let extra6 = state.extra;
                                                      buf8 = extra6;
                                                      buf8 = back3;
                                                      buf8 = extra6;
                                                      buf8 = back3 + extra6;
                                                      state.back = buf8;
                                                      buf8 = extra2;
                                                    } else {
                                                      tmp50 = buf8;
                                                      num55 = buf8;
                                                      num56 = buf8;
                                                      tmp51 = tmp6;
                                                      num57 = buf8;
                                                      tmp52 = buf8;
                                                      while (0 !== buf8) {
                                                        buf8 = buf8 - 1;
                                                        buf8 = +buf8;
                                                        buf8 = buf8 + 1;
                                                        buf8 = input[buf8];
                                                        buf8 = buf8 << buf8;
                                                        buf8 = buf8 + buf8;
                                                        buf8 = buf8 + 8;
                                                        num58 = buf8;
                                                        buf8 = extra2;
                                                        break;
                                                      }
                                                    }
                                                  }
                                                  let length2 = state.length;
                                                  buf8 = length2;
                                                  buf8 = length2;
                                                  state.was = length2;
                                                  state.mode = 23;
                                                }
                                                if (buf8 >= 6) {
                                                  if (avail_out >= 258) {
                                                    state.next_out = next_out;
                                                    state.avail_out = avail_out;
                                                    state.next_in = buf8;
                                                    state.avail_in = buf8;
                                                    state.hold = buf8;
                                                    state.bits = buf8;
                                                    buf8 = require;
                                                    buf8 = dependencyMap;
                                                    buf8 = num58;
                                                    buf8 = num58;
                                                    buf8 = num58;
                                                    buf8 = num58;
                                                    buf8 = num58;
                                                    buf8 = require(12658) /* inflate_fast */(state, tmp6);
                                                    ({ next_out: next_out2, output: output2, avail_out: avail_out2, next_in: next_in2, input: input2, avail_in: avail_in2 } = state);
                                                    ({ hold: hold2, bits: bits3 } = state);
                                                    input = input2;
                                                    output = output2;
                                                    next_in = next_in2;
                                                    next_out = next_out2;
                                                    diff2 = avail_in2;
                                                    avail_out = avail_out2;
                                                    hold = hold2;
                                                    bits = bits3;
                                                    tmp7 = buf8;
                                                    tmp8 = buf8;
                                                    tmp9 = buf8;
                                                    tmp10 = buf8;
                                                    tmp14 = buf8;
                                                    num50 = buf8;
                                                    tmp15 = buf8;
                                                    if (state.mode !== 12) {
                                                      continue;
                                                    } else {
                                                      state.back = -1;
                                                      input = input2;
                                                      output = output2;
                                                      next_in = next_in2;
                                                      next_out = next_out2;
                                                      diff2 = avail_in2;
                                                      avail_out = avail_out2;
                                                      hold = hold2;
                                                      bits = bits3;
                                                      tmp6 = tmp24;
                                                      tmp7 = buf8;
                                                      tmp8 = buf8;
                                                      tmp9 = buf8;
                                                      tmp10 = buf8;
                                                      tmp11 = tmp29;
                                                      tmp12 = tmp30;
                                                      tmp13 = tmp31;
                                                      tmp14 = buf8;
                                                      num50 = buf8;
                                                      tmp15 = buf8;
                                                      continue;
                                                    }
                                                    continue;
                                                  }
                                                }
                                                state.back = 0;
                                                buf8 = state.lencode[buf8 & (1 << state.lenbits) - 1];
                                                buf8 = buf8 >>> 16 & 255;
                                                buf8 = 65535 & buf8;
                                                buf8 = buf8 >>> 24;
                                                num58 = buf8;
                                                if (buf8 <= buf8) {
                                                  buf8 = tmp11;
                                                  buf8 = tmp12;
                                                  buf8 = tmp13;
                                                  if (buf8) {
                                                    buf8 = 240 & buf8;
                                                    buf8 = tmp11;
                                                    buf8 = tmp12;
                                                    buf8 = tmp13;
                                                    if (!buf8) {
                                                      let lencode2 = state.lencode;
                                                      buf8 = lencode2;
                                                      buf8 = buf8 + buf8;
                                                      buf8 = 1 << buf8;
                                                      buf8 = buf8 - 1;
                                                      buf8 = buf8 & buf8;
                                                      buf8 = buf8 >> buf8;
                                                      buf8 = buf8 + buf8;
                                                      buf8 = lencode2;
                                                      buf8 = lencode2[buf8];
                                                      buf8 = buf8 >>> 16;
                                                      buf8 = buf8 & 255;
                                                      buf8 = 65535 & buf8;
                                                      buf8 = buf8 >>> 24;
                                                      buf8 = buf8 + buf8;
                                                      num58 = buf8;
                                                      if (buf8 <= buf8) {
                                                        buf8 = buf8 >>> buf8;
                                                        buf8 = buf8 - buf8;
                                                        let back = state.back;
                                                        buf8 = back;
                                                        buf8 = back;
                                                        buf8 = back + buf8;
                                                        state.back = buf8;
                                                      } else {
                                                        tmp50 = buf8;
                                                        num55 = buf8;
                                                        num56 = buf8;
                                                        tmp51 = tmp6;
                                                        num57 = buf8;
                                                        tmp52 = buf8;
                                                        while (0 !== buf8) {
                                                          buf8 = buf8 - 1;
                                                          buf8 = +buf8;
                                                          buf8 = buf8 + 1;
                                                          buf8 = input[buf8];
                                                          buf8 = buf8 << buf8;
                                                          buf8 = buf8 + buf8;
                                                          buf8 = buf8 + 8;
                                                          let lencode5 = state.lencode;
                                                          buf8 = lencode5;
                                                          buf8 = buf8 & buf8;
                                                          buf8 = buf8 >> buf8;
                                                          buf8 = buf8 + buf8;
                                                          buf8 = lencode5;
                                                          buf8 = lencode5[buf8];
                                                          buf8 = buf8 >>> 16;
                                                          buf8 = buf8 & 255;
                                                          buf8 = 65535 & buf8;
                                                          buf8 = buf8 >>> 24;
                                                          buf8 = buf8 + buf8;
                                                          num58 = buf8;
                                                          break;
                                                        }
                                                      }
                                                    }
                                                  }
                                                  buf8 = buf8 >>> buf8;
                                                  buf8 = buf8 - buf8;
                                                  let back2 = state.back;
                                                  buf8 = back2;
                                                  buf8 = back2;
                                                  buf8 = back2 + buf8;
                                                  num58 = buf8;
                                                  state.back = buf8;
                                                  state.length = buf8;
                                                  if (0 === buf8) {
                                                    state.mode = 26;
                                                    next_in = buf8;
                                                    diff2 = buf8;
                                                    hold = buf8;
                                                    bits = buf8;
                                                    tmp7 = buf8;
                                                    tmp8 = buf8;
                                                    tmp9 = buf8;
                                                    tmp10 = buf8;
                                                    tmp11 = buf8;
                                                    tmp12 = buf8;
                                                    tmp13 = buf8;
                                                    tmp14 = buf8;
                                                    num50 = buf8;
                                                    tmp15 = buf8;
                                                    continue;
                                                  } else {
                                                    buf8 = 32 & buf8;
                                                    num58 = buf8;
                                                    if (buf8) {
                                                      state.back = -1;
                                                      state.mode = 12;
                                                      next_in = buf8;
                                                      diff2 = buf8;
                                                      hold = buf8;
                                                      bits = buf8;
                                                      tmp7 = buf8;
                                                      tmp8 = buf8;
                                                      tmp9 = buf8;
                                                      tmp10 = buf8;
                                                      tmp11 = buf8;
                                                      tmp12 = buf8;
                                                      tmp13 = buf8;
                                                      tmp14 = buf8;
                                                      num50 = buf8;
                                                      tmp15 = buf8;
                                                      continue;
                                                    } else {
                                                      buf8 = 64 & buf8;
                                                      num58 = buf8;
                                                      if (buf8) {
                                                        state.msg = "invalid literal/length code";
                                                        state.mode = 30;
                                                        next_in = buf8;
                                                        diff2 = buf8;
                                                        hold = buf8;
                                                        bits = buf8;
                                                        tmp7 = buf8;
                                                        tmp8 = buf8;
                                                        tmp9 = buf8;
                                                        tmp10 = buf8;
                                                        tmp11 = buf8;
                                                        tmp12 = buf8;
                                                        tmp13 = buf8;
                                                        tmp14 = buf8;
                                                        num50 = buf8;
                                                        tmp15 = buf8;
                                                        continue;
                                                      } else {
                                                        buf8 = 15 & buf8;
                                                        state.extra = buf8;
                                                        state.mode = 22;
                                                      }
                                                    }
                                                    continue;
                                                  }
                                                  continue;
                                                } else {
                                                  tmp50 = buf8;
                                                  num55 = buf8;
                                                  num56 = buf8;
                                                  tmp51 = tmp6;
                                                  num57 = buf8;
                                                  tmp52 = buf8;
                                                  while (0 !== buf8) {
                                                    buf8 = buf8 - 1;
                                                    buf8 = +buf8;
                                                    buf8 = buf8 + 1;
                                                    buf8 = buf8 + (input[buf8] << buf8);
                                                    buf8 = buf8 + 8;
                                                    buf8 = state.lencode[buf8 & (1 << state.lenbits) - 1];
                                                    buf8 = buf8 >>> 16 & 255;
                                                    buf8 = 65535 & buf8;
                                                    buf8 = buf8 >>> 24;
                                                    num58 = buf8;
                                                    break;
                                                  }
                                                }
                                              }
                                              state.mode = 21;
                                            }
                                            buf8 = tmp7;
                                            buf8 = tmp14;
                                            buf8 = tmp15;
                                            buf8 = tmp7;
                                            buf8 = tmp8;
                                            buf8 = tmp9;
                                            buf8 = tmp10;
                                            buf8 = tmp14;
                                            buf8 = tmp15;
                                            if (state.have >= state.nlen + state.ndist) {
                                              next_in = buf8;
                                              diff2 = buf8;
                                              hold = buf8;
                                              bits = buf8;
                                              tmp7 = buf8;
                                              tmp8 = buf8;
                                              tmp9 = buf8;
                                              tmp10 = buf8;
                                              tmp14 = buf8;
                                              num50 = buf8;
                                              tmp15 = buf8;
                                              if (state.mode === 30) {
                                                continue;
                                              } else {
                                                if (0 === state.lens[256]) {
                                                  state.msg = "invalid code -- missing end-of-block";
                                                  state.mode = 30;
                                                  input = tmp16;
                                                  output = tmp17;
                                                  next_in = buf8;
                                                  next_out = tmp19;
                                                  diff2 = buf8;
                                                  avail_out = tmp21;
                                                  hold = buf8;
                                                  bits = buf8;
                                                  tmp6 = tmp24;
                                                  tmp7 = buf8;
                                                  tmp8 = buf8;
                                                  tmp9 = buf8;
                                                  tmp10 = buf8;
                                                  tmp11 = tmp29;
                                                  tmp12 = tmp30;
                                                  tmp13 = tmp31;
                                                  tmp14 = buf8;
                                                  num50 = buf8;
                                                  tmp15 = buf8;
                                                  continue;
                                                } else {
                                                  state.lenbits = 9;
                                                  let obj = { bits: state.lenbits };
                                                  buf8 = require;
                                                  buf8 = require;
                                                  buf8 = dependencyMap;
                                                  buf8 = require;
                                                  buf8 = require;
                                                  buf8 = require;
                                                  buf8 = require(12657) /* inflate_table */;
                                                  let lens7 = state.lens;
                                                  buf8 = lens7;
                                                  let nlen4 = state.nlen;
                                                  buf8 = nlen4;
                                                  let lencode4 = state.lencode;
                                                  buf8 = lencode4;
                                                  let work3 = state.work;
                                                  buf8 = work3;
                                                  num = 1;
                                                  num = 0;
                                                  num = 0;
                                                  num = 0;
                                                  num = 0;
                                                  buf8 = obj;
                                                  num58 = buf8;
                                                  buf8 = buf8(1, lens7, 0, nlen4, lencode4, 0, work3, obj);
                                                  state.lenbits = obj.bits;
                                                  if (buf8) {
                                                    state.msg = "invalid literal/lengths set";
                                                    state.mode = 30;
                                                    input = tmp16;
                                                    output = tmp17;
                                                    next_in = buf8;
                                                    next_out = tmp19;
                                                    diff2 = buf8;
                                                    avail_out = tmp21;
                                                    hold = buf8;
                                                    bits = buf8;
                                                    tmp6 = tmp24;
                                                    tmp7 = buf8;
                                                    tmp8 = buf8;
                                                    tmp9 = buf8;
                                                    tmp10 = buf8;
                                                    tmp11 = tmp29;
                                                    tmp12 = tmp30;
                                                    tmp13 = tmp31;
                                                    tmp14 = buf8;
                                                    num50 = buf8;
                                                    tmp15 = buf8;
                                                    continue;
                                                  } else {
                                                    state.distbits = 6;
                                                    state.distcode = state.distdyn;
                                                    obj = {};
                                                    buf8 = obj;
                                                    buf8 = obj;
                                                    obj.bits = state.distbits;
                                                    buf8 = require;
                                                    buf8 = require;
                                                    buf8 = dependencyMap;
                                                    buf8 = require;
                                                    buf8 = require;
                                                    buf8 = require;
                                                    buf8 = require(12657) /* inflate_table */;
                                                    let lens5 = state.lens;
                                                    buf8 = lens5;
                                                    let nlen3 = state.nlen;
                                                    buf8 = nlen3;
                                                    let ndist2 = state.ndist;
                                                    buf8 = ndist2;
                                                    let distcode = state.distcode;
                                                    buf8 = distcode;
                                                    let work2 = state.work;
                                                    buf8 = work2;
                                                    let num72 = 2;
                                                    let num73 = 0;
                                                    let num74 = 0;
                                                    buf8 = obj;
                                                    buf8 = buf8(2, lens5, nlen3, ndist2, distcode, 0, work2, obj);
                                                    buf8 = obj;
                                                    let bits2 = obj.bits;
                                                    buf8 = bits2;
                                                    num58 = bits2;
                                                    state.distbits = bits2;
                                                    if (buf8) {
                                                      state.msg = "invalid distances set";
                                                      state.mode = 30;
                                                      input = tmp16;
                                                      output = tmp17;
                                                      next_in = buf8;
                                                      next_out = tmp19;
                                                      diff2 = buf8;
                                                      avail_out = tmp21;
                                                      hold = buf8;
                                                      bits = buf8;
                                                      tmp6 = tmp24;
                                                      tmp7 = buf8;
                                                      tmp8 = buf8;
                                                      tmp9 = buf8;
                                                      tmp10 = buf8;
                                                      tmp11 = tmp29;
                                                      tmp12 = tmp30;
                                                      tmp13 = tmp31;
                                                      tmp14 = buf8;
                                                      num50 = buf8;
                                                      tmp15 = buf8;
                                                      continue;
                                                    } else {
                                                      state.mode = 20;
                                                      tmp50 = buf8;
                                                      tmp52 = buf8;
                                                      num55 = buf8;
                                                      num56 = buf8;
                                                      tmp51 = tmp24;
                                                      num57 = buf8;
                                                    }
                                                  }
                                                  continue;
                                                }
                                                continue;
                                              }
                                              continue;
                                            } else {
                                              while (true) {
                                                buf8 = state.lencode[buf8 & (1 << state.lenbits) - 1];
                                                buf8 = buf8 >>> 16 & 255;
                                                buf8 = 65535 & buf8;
                                                buf8 = buf8 >>> 24;
                                                num58 = buf8;
                                                if (buf8 <= buf8) {
                                                  if (buf8 < 16) {
                                                    buf8 = buf8 >>> buf8;
                                                    buf8 = buf8 - buf8;
                                                    let lens4 = state.lens;
                                                    buf8 = lens4;
                                                    let have5 = state.have;
                                                    buf8 = have5;
                                                    buf8 = have5;
                                                    buf8 = +have5;
                                                    buf8 = buf8 + 1;
                                                    state.have = buf8;
                                                    buf8 = lens4;
                                                    lens4[buf8] = buf8;
                                                    let nlen2 = state.nlen;
                                                    buf8 = nlen2;
                                                    num58 = nlen2;
                                                  } else {
                                                    if (16 === buf8) {
                                                      buf8 = buf8 + 2;
                                                      num58 = buf8;
                                                      if (buf8 >= buf8) {
                                                        buf8 = buf8 >>> buf8;
                                                        buf8 = buf8 - buf8;
                                                        let have2 = state.have;
                                                        buf8 = have2;
                                                        num58 = have2;
                                                        if (0 === have2) {
                                                          state.msg = "invalid bit length repeat";
                                                          state.mode = 30;
                                                        } else {
                                                          let lens6 = state.lens;
                                                          buf8 = lens6;
                                                          let have6 = state.have;
                                                          buf8 = have6;
                                                          buf8 = have6;
                                                          buf8 = have6 - 1;
                                                          buf8 = lens6;
                                                          let num70 = lens6[buf8];
                                                          buf8 = 3 & buf8;
                                                          buf8 = 3 + buf8;
                                                          buf8 = buf8 >>> 2;
                                                          buf8 = buf8 - 2;
                                                        }
                                                      } else {
                                                        tmp50 = buf8;
                                                        num55 = buf8;
                                                        num56 = buf8;
                                                        tmp51 = tmp6;
                                                        num57 = buf8;
                                                        tmp52 = buf8;
                                                        while (0 !== buf8) {
                                                          buf8 = buf8 - 1;
                                                          buf8 = +buf8;
                                                          buf8 = buf8 + 1;
                                                          buf8 = input[buf8];
                                                          buf8 = buf8 << buf8;
                                                          buf8 = buf8 + buf8;
                                                          buf8 = buf8 + 8;
                                                          num58 = buf8;
                                                          break;
                                                        }
                                                      }
                                                      break;
                                                    } else if (17 === buf8) {
                                                      buf8 = buf8 + 3;
                                                      num58 = buf8;
                                                      if (buf8 >= buf8) {
                                                        buf8 = buf8 - buf8;
                                                        buf8 = buf8 >>> buf8;
                                                        buf8 = 7 & buf8;
                                                        buf8 = 3 + buf8;
                                                        buf8 = buf8 >>> 3;
                                                        buf8 = buf8 - 3;
                                                        let num71 = 0;
                                                        num70 = 0;
                                                      } else {
                                                        tmp50 = buf8;
                                                        num55 = buf8;
                                                        num56 = buf8;
                                                        tmp51 = tmp6;
                                                        num57 = buf8;
                                                        tmp52 = buf8;
                                                        while (0 !== buf8) {
                                                          buf8 = buf8 - 1;
                                                          buf8 = +buf8;
                                                          buf8 = buf8 + 1;
                                                          buf8 = input[buf8];
                                                          buf8 = buf8 << buf8;
                                                          buf8 = buf8 + buf8;
                                                          buf8 = buf8 + 8;
                                                          num58 = buf8;
                                                          break;
                                                        }
                                                      }
                                                      break;
                                                    } else {
                                                      buf8 = buf8 + 7;
                                                      num58 = buf8;
                                                      if (buf8 >= buf8) {
                                                        buf8 = buf8 - buf8;
                                                        buf8 = buf8 >>> buf8;
                                                        buf8 = 127 & buf8;
                                                        buf8 = 11 + buf8;
                                                        buf8 = buf8 >>> 7;
                                                        buf8 = buf8 - 7;
                                                        let num69 = 0;
                                                        num70 = 0;
                                                      } else {
                                                        tmp50 = buf8;
                                                        num55 = buf8;
                                                        num56 = buf8;
                                                        tmp51 = tmp6;
                                                        num57 = buf8;
                                                        tmp52 = buf8;
                                                        while (0 !== buf8) {
                                                          buf8 = buf8 - 1;
                                                          buf8 = +buf8;
                                                          buf8 = buf8 + 1;
                                                          buf8 = input[buf8];
                                                          buf8 = buf8 << buf8;
                                                          buf8 = buf8 + buf8;
                                                          buf8 = buf8 + 8;
                                                          num58 = buf8;
                                                          break;
                                                        }
                                                      }
                                                      break;
                                                    }
                                                    let have3 = state.have;
                                                    buf8 = have3;
                                                    buf8 = have3;
                                                    buf8 = have3 + buf8;
                                                    let nlen = state.nlen;
                                                    buf8 = nlen;
                                                    let ndist = state.ndist;
                                                    buf8 = ndist;
                                                    buf8 = nlen;
                                                    buf8 = ndist;
                                                    buf8 = nlen + ndist;
                                                    num58 = buf8;
                                                    if (buf8 > buf8) {
                                                      state.msg = "invalid bit length repeat";
                                                      state.mode = 30;
                                                      buf8 = num70;
                                                    } else {
                                                      buf8 = buf8 - 1;
                                                      buf8 = num70;
                                                      for (let buf8 = buf8; buf8; buf8 = buf8) {
                                                        let lens3 = state.lens;
                                                        buf8 = lens3;
                                                        let have4 = state.have;
                                                        buf8 = have4;
                                                        buf8 = have4;
                                                        buf8 = +have4;
                                                        buf8 = buf8 + 1;
                                                        state.have = buf8;
                                                        buf8 = num70;
                                                        buf8 = lens3;
                                                        lens3[buf8] = num70;
                                                        buf8 = +buf8;
                                                        buf8 = buf8 - 1;
                                                        buf8 = num70;
                                                      }
                                                    }
                                                  }
                                                  break;
                                                } else {
                                                  tmp50 = buf8;
                                                  num55 = buf8;
                                                  num56 = buf8;
                                                  tmp51 = tmp6;
                                                  num57 = buf8;
                                                  tmp52 = buf8;
                                                  while (0 !== buf8) {
                                                    buf8 = buf8 - 1;
                                                    buf8 = +buf8;
                                                    buf8 = buf8 + 1;
                                                    buf8 = input[buf8];
                                                    buf8 = buf8 << buf8;
                                                    buf8 = buf8 + buf8;
                                                    buf8 = buf8 + 8;
                                                    let lencode3 = state.lencode;
                                                    buf8 = lencode3;
                                                    let lenbits = state.lenbits;
                                                    buf8 = lenbits;
                                                    buf8 = lenbits;
                                                    buf8 = 1 << lenbits;
                                                    buf8 = buf8 - 1;
                                                    buf8 = buf8 & buf8;
                                                    buf8 = lencode3;
                                                    buf8 = lencode3[buf8];
                                                    buf8 = buf8 >>> 16;
                                                    buf8 = buf8 & 255;
                                                    buf8 = 65535 & buf8;
                                                    buf8 = buf8 >>> 24;
                                                    num58 = buf8;
                                                    continue;
                                                  }
                                                }
                                                break;
                                              }
                                            }
                                          }
                                          if (state.have < state.ncode) {
                                            while (true) {
                                              if (buf8 >= 3) {
                                                let lens = state.lens;
                                                buf8 = lens;
                                                buf8 = +state.have;
                                                state.have = buf8 + 1;
                                                num58 = lens;
                                                lens[items[buf8]] = 7 & buf8;
                                                buf8 = buf8 >>> 3;
                                                buf8 = buf8 - 3;
                                                break;
                                              } else {
                                                tmp50 = buf8;
                                                num55 = buf8;
                                                num56 = buf8;
                                                tmp51 = tmp6;
                                                num57 = num50;
                                                tmp52 = buf8;
                                                while (0 !== buf8) {
                                                  buf8 = buf8 - 1;
                                                  buf8 = +buf8;
                                                  buf8 = buf8 + 1;
                                                  buf8 = input[buf8];
                                                  buf8 = buf8 << buf8;
                                                  num58 = buf8;
                                                  buf8 = buf8 + buf8;
                                                  buf8 = buf8 + 8;
                                                  continue;
                                                }
                                              }
                                              break;
                                            }
                                          }
                                          if (state.have < 19) {
                                            do {
                                              buf8 = +state.have;
                                              state.have = buf8 + 1;
                                              state.lens[items[buf8]] = 0;
                                              have = state.have;
                                            } while (have < 19);
                                          }
                                          state.lencode = state.lendyn;
                                          state.lenbits = 7;
                                          obj = { bits: state.lenbits };
                                          buf8 = require;
                                          buf8 = dependencyMap;
                                          buf8 = num58;
                                          buf8 = num58;
                                          let lens2 = state.lens;
                                          buf8 = lens2;
                                          let lencode = state.lencode;
                                          buf8 = lencode;
                                          let work = state.work;
                                          buf8 = work;
                                          let num63 = 0;
                                          let num64 = 0;
                                          let num65 = 0;
                                          let num66 = 0;
                                          let num67 = 19;
                                          num58 = 0;
                                          let num68 = 0;
                                          buf8 = obj;
                                          buf8 = require(12657) /* inflate_table */(0, lens2, 0, 19, lencode, 0, work, obj);
                                          state.lenbits = obj.bits;
                                          if (buf8) {
                                            state.msg = "invalid code lengths set";
                                            state.mode = 30;
                                            next_in = buf8;
                                            diff2 = buf8;
                                            hold = buf8;
                                            bits = buf8;
                                            num50 = buf8;
                                            continue;
                                          } else {
                                            state.have = 0;
                                            state.mode = 19;
                                          }
                                        }
                                      }
                                      let length8 = state.length;
                                      if (length8) {
                                        if (length8 > buf8) {
                                          length8 = buf8;
                                        }
                                        if (length8 > avail_out) {
                                          length8 = avail_out;
                                        }
                                        tmp50 = buf8;
                                        tmp52 = buf8;
                                        num55 = buf8;
                                        num56 = buf8;
                                        tmp51 = tmp6;
                                        num57 = num50;
                                        if (0 !== length8) {
                                          buf8 = require;
                                          buf8 = dependencyMap;
                                          buf8 = num58;
                                          buf8 = num58;
                                          let obj5 = require(12646) /* _has */;
                                          buf8 = obj5;
                                          buf8 = output;
                                          buf8 = input;
                                          buf8 = length8;
                                          buf8 = next_out;
                                          buf8 = obj5.arraySet(tmp17, tmp16, buf8, length8, tmp19);
                                          diff2 = buf8 - length8;
                                          next_in = buf8 + length8;
                                          avail_out = avail_out - length8;
                                          next_out = next_out + length8;
                                          state.length = state.length - length8;
                                          hold = buf8;
                                          bits = buf8;
                                          tmp7 = length8;
                                          continue;
                                        }
                                      } else {
                                        state.mode = 12;
                                        next_in = buf8;
                                        diff2 = buf8;
                                        hold = buf8;
                                        bits = buf8;
                                        tmp7 = length8;
                                        continue;
                                      }
                                      continue;
                                    }
                                    state.mode = 16;
                                    buf8 = num;
                                    buf8 = num;
                                  }
                                }
                                if (state.last) {
                                  hold = buf8 >>> (7 & buf8);
                                  bits = buf8 - (7 & buf8);
                                  state.mode = 27;
                                  next_in = buf8;
                                  diff2 = buf8;
                                  continue;
                                } else {
                                  next_in = buf8;
                                  diff2 = buf8;
                                  if (buf8 >= 3) {
                                    state.last = 1 & buf8;
                                    buf8 = buf8 - 1;
                                    buf8 = buf8 >>> 1;
                                    buf8 = 3 & buf8;
                                    if (0 === buf8) {
                                      state.mode = 14;
                                    } else if (1 === buf8) {
                                      buf8 = fixedtables;
                                      buf8 = num58;
                                      buf8 = num58;
                                      buf8 = fixedtables(state);
                                      state.mode = 20;
                                      if (6 === arg1) {
                                        num55 = buf8 >>> 2;
                                        num56 = buf8 - 2;
                                        tmp50 = next_in;
                                        tmp52 = diff2;
                                        tmp51 = tmp6;
                                        num57 = num50;
                                      }
                                    } else if (2 === buf8) {
                                      state.mode = 17;
                                    } else if (3 === buf8) {
                                      state.msg = "invalid block type";
                                      state.mode = 30;
                                    }
                                    hold = buf8 >>> 2;
                                    bits = buf8 - 2;
                                    continue;
                                  } else {
                                    tmp50 = buf8;
                                    num55 = buf8;
                                    num56 = buf8;
                                    tmp51 = tmp6;
                                    num57 = num50;
                                    tmp52 = buf8;
                                    while (0 !== buf8) {
                                      buf8 = buf8 - 1;
                                      buf8 = +buf8;
                                      buf8 = buf8 + 1;
                                      buf8 = buf8 + (input[buf8] << buf8);
                                      buf8 = buf8 + 8;
                                      next_in = buf8;
                                      diff2 = buf8;
                                      break;
                                    }
                                  }
                                }
                              }
                              tmp50 = buf8;
                              tmp52 = buf8;
                              num55 = buf8;
                              num56 = buf8;
                              tmp51 = tmp6;
                              num57 = num50;
                              if (5 !== arg1) {
                                tmp50 = buf8;
                                tmp52 = buf8;
                                num55 = buf8;
                                num56 = buf8;
                                tmp51 = tmp6;
                                num57 = num50;
                              }
                            }
                            if (0 === state.havedict) {
                              state.next_out = next_out;
                              state.avail_out = avail_out;
                              state.next_in = buf8;
                              state.avail_in = buf8;
                              state.hold = num75;
                              state.bits = num76;
                              return 2;
                            } else {
                              state.check = 1;
                              state.adler = 1;
                              state.mode = 12;
                              buf8 = num75;
                              buf8 = num76;
                            }
                          }
                        }
                      }
                    }
                    if (2048 & state.flags) {
                      let num93 = 0;
                      tmp50 = buf8;
                      num55 = buf8;
                      num56 = buf8;
                      tmp51 = tmp6;
                      num57 = num50;
                      tmp52 = buf8;
                      if (0 !== buf8) {
                        while (true) {
                          buf8 = +num93;
                          buf8 = buf8 + 1;
                          buf8 = input[buf8 + buf8];
                          buf8 = state.head && buf8 && state.length < 65536;
                          if (buf8) {
                            let head = state.head;
                            let _String = String;
                            buf8 = num58;
                            buf8 = num58;
                            head.name = head.name + String.fromCharCode(buf8);
                          }
                          if (!buf8) {
                            break;
                          } else {
                            num93 = buf8;
                            if (buf8 >= buf8) {
                              break;
                            }
                          }
                        }
                        if (512 & state.flags) {
                          buf8 = require;
                          buf8 = dependencyMap;
                          buf8 = num58;
                          buf8 = num58;
                          let check9 = state.check;
                          buf8 = check9;
                          buf8 = input;
                          state.check = require(12653)(check9, tmp16, buf8, buf8);
                        }
                        buf8 = buf8 - buf8;
                        buf8 = buf8 + buf8;
                        tmp50 = buf8;
                        tmp52 = buf8;
                        num55 = buf8;
                        num56 = buf8;
                        tmp51 = tmp6;
                        num57 = num50;
                      }
                    } else if (state.head) {
                      state.head.name = null;
                    }
                    state.length = 0;
                    state.mode = 8;
                  }
                }
                if (1024 & state.flags) {
                  buf8 = num87;
                  buf8 = num88;
                  if (num88 < 16) {
                    tmp50 = buf8;
                    num55 = buf8;
                    num56 = buf8;
                    tmp51 = tmp6;
                    num57 = num50;
                    tmp52 = buf8;
                    while (0 !== buf8) {
                      buf8 = buf8 - 1;
                      buf8 = +buf8;
                      buf8 = buf8 + 1;
                      num88 = input[buf8] << buf8;
                      buf8 = buf8 + num88;
                      buf8 = buf8 + 8;
                      num87 = buf8;
                      continue;
                    }
                  }
                  state.length = num87;
                  if (state.head) {
                    state.head.extra_len = num87;
                  }
                  let num89 = 0;
                  let num90 = 0;
                  if (512 & state.flags) {
                    buf8[0] = 255 & num87;
                    buf8[1] = num87 >>> 8 & 255;
                    buf8 = require;
                    buf8 = dependencyMap;
                    buf8 = num58;
                    buf8 = num58;
                    let check7 = state.check;
                    buf8 = check7;
                    let num91 = 2;
                    num58 = 0;
                    let num92 = 0;
                    num87 = require(12653)(check7, tmp2, 2, 0);
                    state.check = num87;
                    num89 = 0;
                    num90 = 0;
                  }
                } else {
                  num89 = num87;
                  num90 = num88;
                  if (state.head) {
                    state.head.extra = null;
                    num89 = num87;
                    num90 = num88;
                  }
                }
                state.mode = 6;
                buf8 = num89;
                buf8 = num90;
              }
              buf8 = num83;
              buf8 = num83;
              if (num84 >= 16) {
                if (state.head) {
                  state.head.xflags = 255 & buf8;
                  state.head.os = buf8 >> 8;
                }
                if (512 & state.flags) {
                  buf8[0] = 255 & buf8;
                  buf8[1] = buf8 >>> 8 & 255;
                  buf8 = require;
                  buf8 = dependencyMap;
                  buf8 = num58;
                  buf8 = num58;
                  let check6 = state.check;
                  buf8 = check6;
                  let num85 = 2;
                  num58 = 0;
                  let num86 = 0;
                  state.check = require(12653)(check6, tmp2, 2, 0);
                }
                state.mode = 5;
                num87 = 0;
                num88 = 0;
              } else {
                tmp50 = buf8;
                num55 = buf8;
                num56 = num84;
                tmp51 = tmp6;
                num57 = num50;
                tmp52 = buf8;
                while (0 !== buf8) {
                  buf8 = buf8 - 1;
                  buf8 = +buf8;
                  buf8 = buf8 + 1;
                  buf8 = buf8 + (input[buf8] << num84);
                  num84 = num84 + 8;
                  break;
                }
              }
            }
            buf8 = num79;
            buf8 = num79;
            if (num80 >= 32) {
              if (state.head) {
                state.head.time = buf8;
              }
              if (512 & state.flags) {
                buf8[0] = 255 & buf8;
                buf8[1] = buf8 >>> 8 & 255;
                buf8[2] = buf8 >>> 16 & 255;
                buf8[3] = buf8 >>> 24 & 255;
                buf8 = require;
                buf8 = dependencyMap;
                buf8 = num58;
                buf8 = num58;
                let check5 = state.check;
                buf8 = check5;
                let num81 = 4;
                num58 = 0;
                let num82 = 0;
                state.check = require(12653)(check5, tmp2, 4, 0);
              }
              state.mode = 4;
              num83 = 0;
              num84 = 0;
            } else {
              tmp50 = buf8;
              num55 = buf8;
              num56 = num80;
              tmp51 = tmp6;
              num57 = num50;
              tmp52 = buf8;
              while (0 !== buf8) {
                buf8 = buf8 - 1;
                buf8 = +buf8;
                buf8 = buf8 + 1;
                buf8 = buf8 + (input[buf8] << num80);
                num80 = num80 + 8;
                break;
              }
            }
          }
          state.next_out = next_out;
          state.avail_out = avail_out;
          state.next_in = tmp50;
          state.avail_in = tmp52;
          state.hold = num55;
          state.bits = num56;
          if (state.wsize) {
            buf8 = updatewindow;
            let output3 = state.output;
            buf8 = output3;
            let next_out3 = state.next_out;
            buf8 = next_out3;
            buf8 = tmp51 - state.avail_out;
            buf8 = state;
            buf8 = updatewindow(state, output3, next_out3, buf8);
          }
          buf8 = avail_in - state.avail_in;
          buf8 = tmp51 - state.avail_out;
          state.total_in = state.total_in + buf8;
          state.total_out = state.total_out + buf8;
          state.total = state.total + buf8;
          buf8 = state.wrap && buf8;
          if (!buf8) {
            let num98 = 0;
            if (state.last) {
              num98 = 64;
            }
            let num99 = 0;
            buf8 = state.bits + num98;
            if (state.mode === 12) {
              num99 = 128;
            }
            if (20 === state.mode) {
              num = 256;
            } else {
              num = 0;
            }
            state.data_type = buf8 + num99 + num;
            buf8 = (0 === buf8 && 0 === buf8 || 4 === arg1) && 0 === num57;
            if (buf8) {
              num57 = -5;
            }
            return num57;
          } else {
            buf8 = require;
            let next_out4 = dependencyMap;
            if (state.flags) {
              buf8 = num58;
              buf8 = num58;
              let check13 = state.check;
              buf8 = check13;
              buf8 = buf8(12653);
              next_out4 = state.next_out;
              buf8 = next_out4 - buf8;
              buf8 = output;
              buf8 = buf8(check13, tmp17, buf8, buf8);
            } else {
              buf8 = num58;
              buf8 = num58;
              let check12 = state.check;
              buf8 = check12;
              buf8 = state.next_out - buf8;
              buf8 = output;
              buf8 = buf8(12652)(check12, tmp17, buf8, buf8);
            }
            state.check = buf8;
            state.adler = buf8;
          }
        }
        num = 29;
        buf8 = next_in;
        buf8 = diff2;
        buf8 = hold;
        buf8 = bits;
        buf8 = tmp24;
        if (29 !== mode) {
          num57 = -3;
          tmp50 = next_in;
          tmp52 = diff2;
          num55 = hold;
          num56 = bits;
          tmp51 = tmp24;
          if (30 !== mode) {
            if (31 === mode) {
              return -4;
            } else {
              return -2;
            }
          }
        }
      }
    }
  }
  return -2;
};
arg5.inflateEnd = function inflateEnd(state) {
  if (state) {
    if (state.state) {
      state = state.state;
      if (state.window) {
        state.window = null;
      }
      state.state = null;
      return 0;
    }
  }
  return -2;
};
arg5.inflateGetHeader = function inflateGetHeader(strm, header) {
  let num = -2;
  if (strm) {
    num = -2;
    if (strm.state) {
      const state = strm.state;
      num = -2;
      if (2 & state.wrap) {
        state.head = header;
        header.done = false;
        num = 0;
      }
    }
  }
  return num;
};
arg5.inflateSetDictionary = function inflateSetDictionary(state, output3) {
  let num = -2;
  let num2 = -2;
  if (state) {
    num2 = num;
    if (state.state) {
      state = state.state;
      if (0 === state.wrap) {
        if (11 !== state.mode) {
          updatewindow(state, output3, length, length);
          state.havedict = 1;
          let num9 = 0;
        } else {
          num9 = -3;
        }
        num = num9;
      }
      num2 = num;
    }
  }
  return num2;
};
arg5.inflateInfo = "pako inflate (from Nodeca project)";