// Module ID: 12926
// Function ID: 12927
// Name: StaticTreeDesc
// Dependencies: [12921]

// Module 12926 (StaticTreeDesc)
const require = arg1;
const dependencyMap = arg6;
function StaticTreeDesc(static_tree, extra_bits, extra_base, elems, max_length) {
  let length = static_tree;
  if (static_tree) {
    length = static_tree.length;
  }
  { static_tree, extra_bits, extra_base, elems, max_length }.has_stree = length;
}
function TreeDesc(arg0, arg1) {

}
function send_code(bi_valid, dyn_dtree, bl_tree) {
  if (bi_valid.bi_valid > 16 - bl_tree[2 * dyn_dtree + 1]) {
    bi_valid.bi_buf = bi_valid.bi_buf | tmp << bi_valid.bi_valid & 65535;
    const bi_buf = bi_valid.bi_buf;
    bi_valid.pending = +bi_valid.pending + 1;
    bi_valid.pending_buf[+bi_valid.pending] = 255 & bi_buf;
    bi_valid.pending = +bi_valid.pending + 1;
    bi_valid.pending_buf[+bi_valid.pending] = bi_buf >>> 8 & 255;
    bi_valid.bi_buf = tmp >> 16 - bi_valid.bi_valid;
    bi_valid.bi_valid = bi_valid.bi_valid + (tmp2 - 16);
  } else {
    bi_valid.bi_buf = bi_valid.bi_buf | tmp << bi_valid.bi_valid & 65535;
    bi_valid.bi_valid = bi_valid.bi_valid + tmp2;
  }
}
function pqdownheap(heap_len, dyn_tree, diff) {
  let tmp3 = diff;
  if (diff << 1 <= heap_len.heap_len) {
    let tmp10 = tmp2 < heap_len.heap_len;
    if (tmp10) {
      const depth = heap_len.depth;
      const result = 2 * tmp4;
      const result1 = 2 * tmp5;
      let tmp8 = dyn_tree[result] < dyn_tree[result1];
      if (!tmp8) {
        tmp8 = dyn_tree[result] === dyn_tree[result1] && depth[tmp4] <= depth[tmp5];
        const tmp9 = dyn_tree[result] === dyn_tree[result1] && depth[tmp4] <= depth[tmp5];
      }
      tmp10 = tmp8;
    }
    let sum = tmp2;
    if (tmp10) {
      sum = tmp2 + 1;
    }
    const depth2 = heap_len.depth;
    const result2 = 2 * tmp;
    const result3 = 2 * tmp12;
    let tmp15 = dyn_tree[result2] < dyn_tree[result3];
    if (!tmp15) {
      tmp15 = dyn_tree[result2] === dyn_tree[result3] && depth2[tmp] <= depth2[tmp12];
      const tmp16 = dyn_tree[result2] === dyn_tree[result3] && depth2[tmp] <= depth2[tmp12];
    }
    let tmp17 = diff;
    tmp3 = diff;
    if (!tmp15) {
      heap_len.heap[tmp17] = heap_len.heap[sum];
      tmp3 = sum;
      while (sum << 1 <= heap_len.heap_len) {
        let tmp26 = tmp18 < heap_len.heap_len;
        if (tmp26) {
          let tmp20 = heap_len.heap[tmp18 + 1];
          let tmp21 = heap_len.heap[tmp18];
          let depth3 = heap_len.depth;
          let result4 = 2 * tmp20;
          let result5 = 2 * tmp21;
          let tmp24 = dyn_tree[result4] < dyn_tree[result5];
          if (!tmp24) {
            let tmp25 = dyn_tree[result4] === dyn_tree[result5] && depth3[tmp20] <= depth3[tmp21];
            tmp24 = tmp25;
          }
          tmp26 = tmp24;
        }
        let sum1 = tmp18;
        if (tmp26) {
          sum1 = tmp18 + 1;
        }
        let tmp28 = heap_len.heap[sum1];
        let depth4 = heap_len.depth;
        let result6 = 2 * tmp;
        let result7 = 2 * tmp28;
        let tmp31 = dyn_tree[result6] < dyn_tree[result7];
        if (!tmp31) {
          let tmp32 = dyn_tree[result6] === dyn_tree[result7] && depth4[tmp] <= depth4[tmp28];
          tmp31 = tmp32;
        }
        sum = sum1;
        tmp17 = tmp19;
        tmp3 = tmp19;
        if (tmp31) {
          break;
        }
      }
    }
  }
  heap_len.heap[tmp3] = heap_len.heap[diff];
}
function compress_block(last_lit, arr, array) {
  let num = 0;
  if (0 !== last_lit.last_lit) {
    do {
      let result = 2 * num;
      let tmp2 = last_lit.pending_buf[last_lit.d_buf + result] << 8 | last_lit.pending_buf[last_lit.d_buf + result + 1];
      let tmp3 = last_lit.pending_buf[last_lit.l_buf + num];
      let tmp4 = num;
      if (0 === tmp2) {
        let tmp17 = send_code;
        let tmp18 = send_code(last_lit, tmp3, arr);
      } else {
        let tmp21 = array1;
        let tmp22 = array1[tmp3];
        let tmp20 = send_code;
        let tmp23 = send_code(last_lit, tmp22 + 256 + 1, arr);
        let tmp24 = dependencyMap;
        let tmp25 = dependencyMap[tmp22];
        if (0 !== tmp25) {
          let tmp26 = array2;
          let diff = tmp3 - array2[tmp22];
          if (last_lit.bi_valid > 16 - tmp25) {
            last_lit.bi_buf = last_lit.bi_buf | diff << last_lit.bi_valid & 65535;
            let bi_buf = last_lit.bi_buf;
            let tmp5 = +last_lit.pending;
            last_lit.pending = tmp5 + 1;
            last_lit.pending_buf[tmp5] = 255 & bi_buf;
            let tmp6 = +last_lit.pending;
            last_lit.pending = tmp6 + 1;
            last_lit.pending_buf[tmp6] = bi_buf >>> 8 & 255;
            last_lit.bi_buf = diff >> 16 - last_lit.bi_valid;
            last_lit.bi_valid = last_lit.bi_valid + (tmp25 - 16);
          } else {
            last_lit.bi_buf = last_lit.bi_buf | diff << last_lit.bi_valid & 65535;
            last_lit.bi_valid = last_lit.bi_valid + tmp25;
          }
        }
        let diff1 = tmp2 - 1;
        if (diff1 < 256) {
          let tmp10 = array;
          let tmp9 = array[diff1];
        } else {
          let tmp8 = array;
          tmp9 = array[256 + (diff1 >>> 7)];
        }
        let tmp20Result = tmp20(last_lit, tmp9, array);
        let tmp12 = dependencyMap2;
        let tmp13 = dependencyMap2[tmp9];
        let tmp14 = tmp9;
        if (0 !== tmp13) {
          let tmp28 = array3;
          let diff2 = diff1 - array3[tmp9];
          if (last_lit.bi_valid > 16 - tmp13) {
            last_lit.bi_buf = last_lit.bi_buf | diff2 << last_lit.bi_valid & 65535;
            let bi_buf2 = last_lit.bi_buf;
            let tmp15 = +last_lit.pending;
            last_lit.pending = tmp15 + 1;
            last_lit.pending_buf[tmp15] = 255 & bi_buf2;
            let tmp16 = +last_lit.pending;
            last_lit.pending = tmp16 + 1;
            last_lit.pending_buf[tmp16] = bi_buf2 >>> 8 & 255;
            last_lit.bi_buf = diff2 >> 16 - last_lit.bi_valid;
            last_lit.bi_valid = last_lit.bi_valid + (tmp13 - 16);
          } else {
            last_lit.bi_buf = last_lit.bi_buf | diff2 << last_lit.bi_valid & 65535;
            last_lit.bi_valid = last_lit.bi_valid + tmp13;
          }
        }
      }
      num = num + 1;
    } while (num < last_lit.last_lit);
  }
  send_code(last_lit, 256, arr);
}
function build_tree(heap_len, bl_desc) {
  let dyn_tree2;
  let max_code;
  const dyn_tree = bl_desc.dyn_tree;
  const elems = bl_desc.stat_desc.elems;
  heap_len.heap_len = 0;
  heap_len.heap_max = 573;
  let num = -1;
  let num2 = 0;
  let num3 = -1;
  if (0 < elems) {
    do {
      let result = 2 * num2;
      let tmp4 = num;
      let tmp5 = num2;
      if (0 !== dyn_tree[result]) {
        let sum = heap_len.heap_len + 1;
        heap_len.heap_len = sum;
        heap_len.heap[sum] = num2;
        heap_len.depth[num2] = 0;
        tmp4 = num2;
      } else {
        dyn_tree[result + 1] = 0;
      }
      num2 = num2 + 1;
      num = tmp4;
      num3 = tmp4;
    } while (num2 < elems);
  }
  let tmp7 = num3;
  let tmp8 = num3;
  if (heap_len.heap_len < 2) {
    do {
      let sum1 = heap_len.heap_len + 1;
      heap_len.heap_len = sum1;
      let tmp10 = tmp7;
      let num4 = 0;
      let sum2 = tmp7;
      if (tmp7 < 2) {
        sum2 = tmp7 + 1;
        num4 = sum2;
      }
      heap_len.heap[sum1] = num4;
      let result1 = 2 * num4;
      dyn_tree[result1] = 1;
      heap_len.depth[num4] = 0;
      heap_len.opt_len = heap_len.opt_len - 1;
      if (tmp2) {
        heap_len.static_len = heap_len.static_len - tmp[result1 + 1];
      }
      tmp7 = sum2;
      tmp8 = sum2;
    } while (heap_len.heap_len < 2);
  }
  bl_desc.max_code = tmp8;
  let diff = heap_len.heap_len >> 1;
  let sum3 = elems;
  if (1 <= diff) {
    do {
      let tmp15 = pqdownheap;
      let tmp16 = pqdownheap(heap_len, dyn_tree, diff);
      diff = diff - 1;
      sum3 = elems;
    } while (1 <= diff);
  }
  do {
    let tmp17 = heap_len.heap[1];
    let tmp18 = +heap_len.heap_len;
    heap_len.heap_len = tmp18 - 1;
    heap_len.heap[1] = heap_len.heap[tmp18];
    let tmp19 = pqdownheap;
    let tmp20 = pqdownheap(heap_len, dyn_tree, 1);
    let tmp21 = heap_len.heap[1];
    let diff1 = heap_len.heap_max - 1;
    heap_len.heap_max = diff1;
    heap_len.heap[diff1] = tmp17;
    let diff2 = heap_len.heap_max - 1;
    heap_len.heap_max = diff2;
    heap_len.heap[diff2] = tmp21;
    dyn_tree[2 * sum3] = dyn_tree[2 * tmp17] + dyn_tree[2 * tmp21];
    let tmp24 = sum3;
    if (heap_len.depth[tmp17] >= heap_len.depth[tmp21]) {
      let tmp25 = heap_len.depth[tmp17];
    } else {
      tmp25 = heap_len.depth[tmp21];
    }
    heap_len.depth[sum3] = tmp25 + 1;
    dyn_tree[2 * tmp21 + 1] = sum3;
    dyn_tree[2 * tmp17 + 1] = sum3;
    let tmp26 = +sum3;
    sum3 = tmp26 + 1;
    heap_len.heap[1] = tmp26;
    let tmp19Result = tmp19(heap_len, dyn_tree, 1);
  } while (heap_len.heap_len >= 2);
  const diff3 = heap_len.heap_max - 1;
  heap_len.heap_max = diff3;
  heap_len.heap[diff3] = heap_len.heap[1];
  ({ dyn_tree: dyn_tree2, max_code } = bl_desc);
  const extra_base = bl_desc.stat_desc.extra_base;
  let max_length = bl_desc.stat_desc.max_length;
  let num5 = 0;
  do {
    heap_len.bl_count[num5] = 0;
    num5 = num5 + 1;
  } while (num5 <= 15);
  dyn_tree2[2 * heap_len.heap[heap_len.heap_max] + 1] = 0;
  let sum4 = heap_len.heap_max + 1;
  let num6 = 0;
  let num7 = 0;
  let tmp29 = sum4;
  if (sum4 < 573) {
    do {
      let tmp30 = heap_len.heap[sum4];
      let sum5 = dyn_tree2[2 * dyn_tree2[2 * tmp30 + 1] + 1] + 1;
      let tmp32 = num6;
      let tmp33 = sum4;
      let sum6 = num6;
      if (sum5 > max_length) {
        sum6 = num6 + 1;
        sum5 = max_length;
      }
      dyn_tree2[2 * tmp30 + 1] = sum5;
      if (tmp30 <= max_code) {
        let bl_count = heap_len.bl_count;
        bl_count[sum5] = bl_count[sum5] + 1;
        let num8 = 0;
        if (tmp30 >= extra_base) {
          num8 = tmp63[tmp30 - extra_base];
        }
        let tmp35 = dyn_tree2[2 * tmp30];
        heap_len.opt_len = heap_len.opt_len + tmp35 * (sum5 + num8);
        if (tmp62) {
          heap_len.static_len = heap_len.static_len + tmp35 * (tmp61[2 * tmp30 + 1] + num8);
        }
      }
      sum4 = sum4 + 1;
      num6 = sum6;
      num7 = sum6;
      tmp29 = sum4;
    } while (sum4 < 573);
  }
  if (0 !== num7) {
    do {
      let diff4 = max_length - 1;
      let tmp37 = num7;
      let tmp38 = diff4;
      let tmp39 = diff4;
      if (0 === heap_len.bl_count[diff4]) {
        do {
          let diff5 = tmp38 - 1;
          tmp38 = diff5;
          tmp39 = diff5;
          tmp41 = heap_len.bl_count[diff5];
        } while (0 === tmp41);
      }
      let bl_count2 = heap_len.bl_count;
      bl_count2[tmp39] = bl_count2[tmp39] - 1;
      let bl_count3 = heap_len.bl_count;
      let sum7 = tmp39 + 1;
      bl_count3[sum7] = bl_count3[sum7] + 2;
      let bl_count4 = heap_len.bl_count;
      bl_count4[max_length] = bl_count4[max_length] - 1;
      num7 = num7 - 2;
    } while (0 < num7);
    if (0 !== max_length) {
      do {
        let tmp43 = heap_len.bl_count[max_length];
        let tmp44 = max_length;
        let tmp45 = tmp29;
        let tmp46 = tmp29;
        if (0 !== tmp43) {
          do {
            let diff6 = tmp45 - 1;
            let tmp48 = heap_len.heap[diff6];
            let tmp49 = tmp43;
            diff7 = tmp43;
            if (tmp48 <= max_code) {
              if (dyn_tree2[2 * tmp48 + 1] !== max_length) {
                heap_len.opt_len = heap_len.opt_len + (max_length - dyn_tree2[2 * tmp48 + 1]) * dyn_tree2[2 * tmp48];
                dyn_tree2[2 * tmp48 + 1] = max_length;
              }
              diff7 = tmp43 - 1;
            }
            tmp43 = diff7;
            tmp45 = diff6;
            tmp46 = diff6;
          } while (0 !== diff7);
        }
        max_length = max_length - 1;
        tmp29 = tmp46;
      } while (0 !== max_length);
    }
  }
  const array = new Array(16);
  let num9 = 0;
  let num10 = 1;
  do {
    let tmp53 = num9 + tmp51[num10 - 1] << 1;
    array[num10] = tmp53;
    num10 = num10 + 1;
    num9 = tmp53;
  } while (num10 <= 15);
  let num11 = 0;
  if (0 <= tmp8) {
    do {
      let result2 = 2 * num11;
      let diff8 = dyn_tree[result2 + 1];
      let tmp56 = num11;
      if (0 !== diff8) {
        let tmp57 = +array[diff8];
        array[diff8] = tmp57 + 1;
        let num12 = 0;
        do {
          let tmp58 = 1 & tmp57;
          tmp57 = tmp57 >>> 1;
          let tmp59 = (num12 | tmp58) << 1;
          diff8 = diff8 - 1;
          num12 = tmp59;
        } while (diff8 > 0);
        dyn_tree[result2] = tmp59 >>> 1;
      }
      num11 = num11 + 1;
    } while (num11 <= tmp8);
  }
}
function scan_tree(bl_tree, dyn_dtree, max_code) {
  let sum;
  let tmp = dyn_dtree[1];
  let num = 4;
  let num2 = 7;
  if (0 === tmp) {
    num = 3;
    num2 = 138;
  }
  dyn_dtree[2 * (max_code + 1) + 1] = 65535;
  let num3 = -1;
  let num4 = 0;
  let num5 = 0;
  if (0 <= max_code) {
    do {
      sum = num5 + 1;
      let tmp3 = dyn_dtree[2 * sum + 1];
      let sum1 = num4 + 1;
      let tmp5 = sum1 < num2;
      let tmp6 = num;
      let tmp7 = num2;
      let tmp8 = tmp;
      let tmp9 = num3;
      if (sum1 < num2) {
        tmp5 = tmp === tmp3;
      }
      let tmp10 = num;
      let num6 = sum1;
      let tmp11 = num3;
      if (!tmp5) {
        if (sum1 < num) {
          let bl_tree5 = bl_tree.bl_tree;
          let result = 2 * tmp;
          bl_tree5[result] = bl_tree5[result] + sum1;
        } else if (0 !== tmp) {
          if (tmp !== num3) {
            let bl_tree3 = bl_tree.bl_tree;
            let result1 = 2 * tmp;
            bl_tree3[result1] = bl_tree3[result1] + 1;
          }
          let bl_tree4 = bl_tree.bl_tree;
          bl_tree4[32] = bl_tree4[32] + 1;
        } else if (sum1 <= 10) {
          let bl_tree2 = bl_tree.bl_tree;
          bl_tree2[34] = bl_tree2[34] + 1;
        } else {
          bl_tree = bl_tree.bl_tree;
          bl_tree[36] = bl_tree[36] + 1;
        }
        let num7 = 3;
        let num8 = 138;
        if (0 !== tmp3) {
          let num9 = 4;
          let num10 = 7;
          if (tmp === tmp3) {
            num9 = 3;
            num10 = 6;
          }
          num7 = num9;
          num8 = num10;
        }
        tmp10 = num7;
        tmp7 = num8;
        num6 = 0;
        tmp11 = tmp;
      }
      num = tmp10;
      num2 = tmp7;
      num4 = num6;
      num3 = tmp11;
      tmp = tmp3;
      num5 = sum;
    } while (sum <= max_code);
  }
}
function send_tree(bl_tree, dyn_dtree, diff2) {
  let sum;
  let tmp = dyn_dtree[1];
  let num = 4;
  let num2 = 7;
  if (0 === tmp) {
    num = 3;
    num2 = 138;
  }
  let num3 = -1;
  let num4 = 0;
  let num5 = 0;
  if (0 <= diff2) {
    do {
      sum = num5 + 1;
      let tmp3 = dyn_dtree[2 * sum + 1];
      let sum1 = num4 + 1;
      let tmp5 = num;
      let num6 = num2;
      let tmp6 = tmp;
      let tmp7 = num3;
      if (sum1 >= num2) {
        let diff = sum1;
        if (sum1 < num) {
          do {
            let tmp25 = send_code;
            let tmp26 = send_code(bl_tree, tmp, bl_tree.bl_tree);
            diff = diff - 1;
          } while (0 !== diff);
        } else if (0 !== tmp) {
          let diff1 = sum1;
          if (tmp !== num3) {
            let tmp18 = send_code;
            let tmp19 = send_code(bl_tree, tmp, bl_tree.bl_tree);
            diff1 = sum1 - 1;
          }
          let tmp20 = send_code;
          let tmp21 = send_code(bl_tree, 16, bl_tree.bl_tree);
          diff2 = diff1 - 3;
          if (bl_tree.bi_valid > 14) {
            bl_tree.bi_buf = bl_tree.bi_buf | diff2 << bl_tree.bi_valid & 65535;
            let bi_buf3 = bl_tree.bi_buf;
            let tmp23 = +bl_tree.pending;
            bl_tree.pending = tmp23 + 1;
            bl_tree.pending_buf[tmp23] = 255 & bi_buf3;
            let tmp24 = +bl_tree.pending;
            bl_tree.pending = tmp24 + 1;
            bl_tree.pending_buf[tmp24] = bi_buf3 >>> 8 & 255;
            bl_tree.bi_buf = diff2 >> 16 - bl_tree.bi_valid;
            bl_tree.bi_valid = bl_tree.bi_valid + -14;
          } else {
            bl_tree.bi_buf = bl_tree.bi_buf | diff2 << bl_tree.bi_valid & 65535;
            bl_tree.bi_valid = bl_tree.bi_valid + 2;
          }
        } else if (sum1 <= 10) {
          let tmp12 = send_code;
          let tmp13 = send_code(bl_tree, 17, bl_tree.bl_tree);
          let diff3 = sum1 - 3;
          if (bl_tree.bi_valid > 13) {
            bl_tree.bi_buf = bl_tree.bi_buf | diff3 << bl_tree.bi_valid & 65535;
            let bi_buf2 = bl_tree.bi_buf;
            let tmp15 = +bl_tree.pending;
            bl_tree.pending = tmp15 + 1;
            bl_tree.pending_buf[tmp15] = 255 & bi_buf2;
            let tmp16 = +bl_tree.pending;
            bl_tree.pending = tmp16 + 1;
            bl_tree.pending_buf[tmp16] = bi_buf2 >>> 8 & 255;
            bl_tree.bi_buf = diff3 >> 16 - bl_tree.bi_valid;
            bl_tree.bi_valid = bl_tree.bi_valid + -13;
          } else {
            bl_tree.bi_buf = bl_tree.bi_buf | diff3 << bl_tree.bi_valid & 65535;
            bl_tree.bi_valid = bl_tree.bi_valid + 3;
          }
        } else {
          let tmp27 = send_code;
          let tmp28 = send_code(bl_tree, 18, bl_tree.bl_tree);
          let diff4 = sum1 - 11;
          if (bl_tree.bi_valid > 9) {
            bl_tree.bi_buf = bl_tree.bi_buf | diff4 << bl_tree.bi_valid & 65535;
            let bi_buf = bl_tree.bi_buf;
            let tmp10 = +bl_tree.pending;
            bl_tree.pending = tmp10 + 1;
            bl_tree.pending_buf[tmp10] = 255 & bi_buf;
            let tmp11 = +bl_tree.pending;
            bl_tree.pending = tmp11 + 1;
            bl_tree.pending_buf[tmp11] = bi_buf >>> 8 & 255;
            bl_tree.bi_buf = diff4 >> 16 - bl_tree.bi_valid;
            bl_tree.bi_valid = bl_tree.bi_valid + -9;
          } else {
            bl_tree.bi_buf = bl_tree.bi_buf | diff4 << bl_tree.bi_valid & 65535;
            bl_tree.bi_valid = bl_tree.bi_valid + 7;
          }
        }
        let num7 = 3;
        num6 = 138;
        let num8 = 0;
        let tmp8 = tmp;
        if (0 !== tmp3) {
          num7 = 4;
          num6 = 7;
          num8 = 0;
          tmp8 = tmp;
          if (tmp === tmp3) {
            num7 = 3;
            num6 = 6;
            num8 = 0;
            tmp8 = tmp;
          }
        }
      } else {
        num7 = num;
        num8 = sum1;
        tmp8 = num3;
      }
      num = num7;
      num2 = num6;
      num4 = num8;
      num3 = tmp8;
      tmp = tmp3;
      num5 = sum;
    } while (sum <= diff2);
  }
}
function _tr_stored_block(state8, state8, arg2, arg3) {
  let num = 0;
  if (arg3) {
    num = 1;
  }
  if (state8.bi_valid > 13) {
    state8.bi_buf = state8.bi_buf | tmp << state8.bi_valid & 65535;
    const bi_buf = state8.bi_buf;
    state8.pending = +state8.pending + 1;
    state8.pending_buf[+state8.pending] = 255 & bi_buf;
    state8.pending = +state8.pending + 1;
    state8.pending_buf[+state8.pending] = bi_buf >>> 8 & 255;
    state8.bi_buf = tmp >> 16 - state8.bi_valid;
    state8.bi_valid = state8.bi_valid + -13;
  } else {
    state8.bi_buf = state8.bi_buf | tmp << state8.bi_valid & 65535;
    state8.bi_valid = state8.bi_valid + 3;
  }
  if (state8.bi_valid > 8) {
    const bi_buf2 = state8.bi_buf;
    state8.pending = +state8.pending + 1;
    state8.pending_buf[+state8.pending] = 255 & bi_buf2;
    state8.pending = +state8.pending + 1;
    state8.pending_buf[+state8.pending] = bi_buf2 >>> 8 & 255;
  } else if (state8.bi_valid > 0) {
    state8.pending = +state8.pending + 1;
    state8.pending_buf[+state8.pending] = state8.bi_buf;
  }
  state8.bi_buf = 0;
  state8.bi_valid = 0;
  state8.pending = +state8.pending + 1;
  state8.pending_buf[+state8.pending] = 255 & arg2;
  state8.pending = +state8.pending + 1;
  state8.pending_buf[+state8.pending] = arg2 >>> 8 & 255;
  state8.pending = +state8.pending + 1;
  state8.pending_buf[+state8.pending] = 255 & ~arg2;
  state8.pending = +state8.pending + 1;
  state8.pending_buf[+state8.pending] = ~arg2 >>> 8 & 255;
  require(12921) /* assign */.arraySet(state8.pending_buf, state8.window, state8, arg2, state8.pending);
  state8.pending = state8.pending + arg2;
}
let closure_2 = [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0];
let closure_3 = [0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13];
let closure_4 = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 3, 7];
let closure_5 = [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15];
const arr = new Array(576);
let diff = arr.length - 1;
if (diff >= 0) {
  do {
    arr[diff] = 0;
    diff = diff - 1;
  } while (diff >= 0);
}
let array = new Array(60);
let diff1 = array.length - 1;
if (diff1 >= 0) {
  do {
    array[diff1] = 0;
    diff1 = diff1 - 1;
  } while (diff1 >= 0);
}
array = new Array(512);
let diff2 = array.length - 1;
if (diff2 >= 0) {
  do {
    array[diff2] = 0;
    diff2 = diff2 - 1;
  } while (diff2 >= 0);
}
const array1 = new Array(256);
let diff3 = array1.length - 1;
if (diff3 >= 0) {
  do {
    array1[diff3] = 0;
    diff3 = diff3 - 1;
  } while (diff3 >= 0);
}
const array2 = new Array(29);
let diff4 = array2.length - 1;
if (diff4 >= 0) {
  do {
    array2[diff4] = 0;
    diff4 = diff4 - 1;
  } while (diff4 >= 0);
}
const array3 = new Array(30);
let diff5 = array3.length - 1;
if (diff5 >= 0) {
  do {
    array3[diff5] = 0;
    diff5 = diff5 - 1;
  } while (diff5 >= 0);
}
let c23 = false;
arg5._tr_init = function _tr_init(state) {
  let num30;
  let num32;
  let num36;
  let num37;
  let sum1;
  let sum3;
  let sum5;
  let tmp21;
  if (!c23) {
    const _Array = Array;
    let array = new Array(16);
    let num6 = 0;
    let num7 = 0;
    do {
      let tmp6 = array2;
      array2[num6] = num7;
      let tmp7 = dependencyMap;
      let tmp8 = num6;
      let tmp9 = num7;
      let num8 = 0;
      let tmp10 = num7;
      if (0 < 1 << dependencyMap[num6]) {
        do {
          let tmp11 = array1;
          let sum = tmp9 + 1;
          array1[tmp9] = num6;
          num8 = num8 + 1;
          let tmp13 = dependencyMap;
          tmp9 = sum;
          tmp10 = sum;
          tmp14 = 1 << dependencyMap[num6];
        } while (num8 < tmp14);
      }
      sum1 = num6 + 1;
      num7 = tmp10;
      num6 = sum1;
    } while (sum1 < 28);
    array1[tmp10 - 1] = sum1;
    let num9 = 0;
    let num10 = 0;
    do {
      let tmp17 = array3;
      array3[num10] = num9;
      let tmp18 = dependencyMap2;
      let tmp19 = num9;
      let tmp20 = num10;
      let num11 = 0;
      tmp21 = num9;
      if (0 < 1 << dependencyMap2[num10]) {
        do {
          let tmp22 = array;
          let sum2 = tmp19 + 1;
          array[tmp19] = num10;
          num11 = num11 + 1;
          let tmp24 = dependencyMap2;
          tmp19 = sum2;
          tmp21 = sum2;
          tmp25 = 1 << dependencyMap2[num10];
        } while (num11 < tmp25);
      }
      sum3 = num10 + 1;
      num9 = tmp21;
      num10 = sum3;
    } while (sum3 < 16);
    let tmp27 = tmp21 >> 7;
    let num19 = 0;
    if (sum3 < 30) {
      do {
        let tmp28 = array3;
        array3[sum3] = tmp27 << 7;
        let tmp29 = dependencyMap2;
        let tmp30 = tmp27;
        let tmp31 = sum3;
        let num20 = 0;
        let tmp32 = tmp27;
        if (0 < 1 << dependencyMap2[sum3] - 7) {
          do {
            let tmp33 = array;
            let sum4 = tmp30 + 1;
            array[256 + tmp30] = sum3;
            num20 = num20 + 1;
            let tmp35 = dependencyMap2;
            tmp30 = sum4;
            tmp32 = sum4;
            tmp36 = 1 << dependencyMap2[sum3] - 7;
          } while (num20 < tmp36);
        }
        sum3 = sum3 + 1;
        tmp27 = tmp32;
        num19 = 0;
      } while (sum3 < 30);
    }
    do {
      array[num19] = 0;
      num19 = num19 + 1;
      let num21 = 0;
    } while (num19 <= 15);
    do {
      let tmp37 = arr;
      arr[2 * num21 + 1] = 8;
      sum5 = num21 + 1;
      array[8] = array[8] + 1;
      num21 = sum5;
    } while (sum5 <= 143);
    let sum6 = sum5;
    let tmp40 = sum5;
    if (sum5 <= 255) {
      do {
        let tmp41 = arr;
        arr[2 * sum6 + 1] = 9;
        sum6 = sum6 + 1;
        array[9] = array[9] + 1;
        tmp37 = arr;
        tmp40 = sum6;
      } while (sum6 <= 255);
    }
    let sum7 = tmp40;
    let sum8 = tmp40;
    if (tmp40 <= 279) {
      do {
        let tmp44 = arr;
        arr[2 * sum7 + 1] = 7;
        sum7 = sum7 + 1;
        array[7] = array[7] + 1;
        tmp37 = arr;
        sum8 = sum7;
      } while (sum7 <= 279);
    }
    if (sum8 <= 287) {
      do {
        let tmp45 = arr;
        arr[2 * sum8 + 1] = 8;
        sum8 = sum8 + 1;
        array[8] = array[8] + 1;
        tmp37 = arr;
      } while (sum8 <= 287);
    }
    const _Array2 = Array;
    array = new Array(16);
    let num28 = 0;
    let num29 = 1;
    do {
      let tmp50 = num28 + array[num29 - 1] << 1;
      array[num29] = tmp50;
      num29 = num29 + 1;
      num28 = tmp50;
      num30 = 0;
    } while (num29 <= 15);
    do {
      let result = 2 * num30;
      let diff = tmp37[result + 1];
      let tmp53 = num30;
      if (0 !== diff) {
        let tmp54 = +array[diff];
        array[diff] = tmp54 + 1;
        let num31 = 0;
        do {
          let tmp55 = 1 & tmp54;
          tmp54 = tmp54 >>> 1;
          let tmp56 = (num31 | tmp55) << 1;
          diff = diff - 1;
          num31 = tmp56;
        } while (diff > 0);
        tmp37[result] = tmp56 >>> 1;
      }
      num30 = num30 + 1;
      num32 = 0;
    } while (num30 <= 287);
    const result1 = 2 * num32;
    array[result1 + 1] = 5;
    let num33 = 0;
    let num34 = 5;
    let tmp60 = num32;
    do {
      do {
        let tmp61 = (num33 | 1 & tmp60) << 1;
        num34 = num34 - 1;
        num33 = tmp61;
        tmp60 = tmp60 >>> 1;
      } while (0 < num34);
      tmp57[result1] = tmp61 >>> 1;
      num32 = num32 + 1;
    } while (num32 < 30);
  }
  let obj = Object.create(TreeDesc.prototype);
  obj = { dyn_tree: state.dyn_ltree, max_code: 0, stat_desc: closure_11 };
  state.l_desc = obj;
  obj = Object.create(TreeDesc.prototype);
  state.d_desc = { dyn_tree: state.dyn_dtree, max_code: 0, stat_desc: closure_12 };
  Object.create(TreeDesc.prototype);
  state.bl_desc = { dyn_tree: state.bl_tree, max_code: 0, stat_desc: closure_13 };
  state.bi_buf = 0;
  state.bi_valid = 0;
  let num35 = 0;
  do {
    state.dyn_ltree[2 * num35] = 0;
    num35 = num35 + 1;
    num36 = 0;
  } while (num35 < 286);
  do {
    state.dyn_dtree[2 * num36] = 0;
    num36 = num36 + 1;
    num37 = 0;
  } while (num36 < 30);
  do {
    state.bl_tree[2 * num37] = 0;
    num37 = num37 + 1;
  } while (num37 < 19);
  state.dyn_ltree[512] = 1;
  state.static_len = 0;
  state.opt_len = 0;
  state.matches = 0;
  state.last_lit = 0;
};
arg5._tr_stored_block = _tr_stored_block;
arg5._tr_flush_block = function _tr_flush_block(level, state8, arg2, arg3) {
  let num72;
  let num73;
  if (level.level > 0) {
    if (2 === level.strm.data_type) {
      let num6 = 4093624447;
      let num5 = 0;
      while (true) {
        let tmp3 = num6;
        let tmp4 = num5;
        if (!(1 & num6)) {
          num5 = num5 + 1;
          num6 = num6 >>> 1;
          if (num5 <= 31) {
            continue;
          } else {
            let num4 = 1;
            if (0 !== level.dyn_ltree[18]) {
              break;
            } else {
              num4 = 1;
              if (0 !== level.dyn_ltree[20]) {
                break;
              } else {
                let num7 = 32;
                let num8 = 256;
                num4 = 1;
                if (0 !== level.dyn_ltree[26]) {
                  break;
                } else {
                  let tmp5 = num7;
                  num4 = 1;
                  while (0 === level.dyn_ltree[2 * num7]) {
                    num7 = num7 + 1;
                    num4 = 0;
                    if (num7 >= 256) {
                      break;
                    }
                  }
                }
              }
            }
          }
          break;
        } else {
          num4 = 0;
          if (0 !== level.dyn_ltree[2 * num5]) {
            break;
          }
        }
        tmp56.data_type = num4;
      }
    }
    build_tree(level, level.l_desc);
    build_tree(level, level.d_desc);
    scan_tree(level, level.dyn_ltree, level.l_desc.max_code);
    scan_tree(level, level.dyn_dtree, level.d_desc.max_code);
    build_tree(level, level.bl_desc);
    let num10 = 18;
    let num12 = 18;
    if (0 === level.bl_tree[2 * dependencyMap3[18] + 1]) {
      const diff = num10 - 1;
      num12 = diff;
      while (3 <= diff) {
        let tmp15 = dependencyMap3;
        num10 = diff;
        num12 = diff;
        if (0 !== level.bl_tree[2 * dependencyMap3[diff] + 1]) {
          break;
        }
      }
    }
    level.opt_len = level.opt_len + (3 * (num12 + 1) + 5 + 5 + 4);
    let tmp2 = level.opt_len + 3 + 7 >>> 3;
    let num2 = num12;
    let sum = tmp16;
    if (level.static_len + 3 + 7 >>> 3 <= tmp2) {
      num2 = num12;
      sum = tmp16;
      tmp2 = tmp16;
    }
  } else {
    sum = arg2 + 5;
    num2 = 0;
    tmp2 = sum;
  }
  if (arg2 + 4 <= tmp2) {
    if (-1 !== state8) {
      _tr_stored_block(level, state8, arg2, arg3);
      let num58 = 0;
    }
    do {
      let num67 = 2;
      level.dyn_ltree[2 * num58] = 0;
      let num68 = 1;
      num58 = num58 + 1;
      let num69 = 286;
      let num70 = 30;
      let num71 = 19;
      num72 = 0;
    } while (num58 < 286);
    do {
      level.dyn_dtree[2 * num72] = 0;
      num72 = num72 + 1;
      num73 = 0;
    } while (num72 < 30);
    do {
      level.bl_tree[2 * num73] = 0;
      num73 = num73 + 1;
    } while (num73 < 19);
    level.dyn_ltree[512] = 1;
    level.static_len = 0;
    level.opt_len = 0;
    level.matches = 0;
    level.last_lit = 0;
    if (arg3) {
      let num75 = 8;
      if (level.bi_valid > 8) {
        const bi_buf7 = level.bi_buf;
        level.pending = +level.pending + 1;
        level.pending_buf[+level.pending] = 255 & bi_buf7;
        level.pending = +level.pending + 1;
        num75 = bi_buf7 >>> num75 & 255;
        level.pending_buf[+level.pending] = num75;
      } else if (level.bi_valid > 0) {
        level.pending = +level.pending + 1;
        level.pending_buf[+level.pending] = level.bi_buf;
      }
      level.bi_buf = 0;
      level.bi_valid = 0;
    }
  }
  if (4 !== level.strategy) {
    if (sum !== tmp2) {
      let num17 = 0;
      if (arg3) {
        num17 = 1;
      }
      const sum1 = 4 + num17;
      if (level.bi_valid > 13) {
        level.bi_buf = level.bi_buf | sum1 << level.bi_valid & 65535;
        const bi_buf = level.bi_buf;
        level.pending = +level.pending + 1;
        level.pending_buf[+level.pending] = 255 & bi_buf;
        level.pending = +level.pending + 1;
        level.pending_buf[+level.pending] = bi_buf >>> 8 & 255;
        level.bi_buf = sum1 >> 16 - level.bi_valid;
        level.bi_valid = level.bi_valid + -13;
      } else {
        level.bi_buf = level.bi_buf | sum1 << level.bi_valid & 65535;
        level.bi_valid = level.bi_valid + 3;
      }
      const sum2 = level.l_desc.max_code + 1;
      const diff1 = sum2 - 257;
      const sum3 = level.d_desc.max_code + 1;
      if (level.bi_valid > 11) {
        level.bi_buf = level.bi_buf | diff1 << level.bi_valid & 65535;
        const bi_buf2 = level.bi_buf;
        level.pending = +level.pending + 1;
        level.pending_buf[+level.pending] = 255 & bi_buf2;
        level.pending = +level.pending + 1;
        level.pending_buf[+level.pending] = bi_buf2 >>> 8 & 255;
        level.bi_buf = diff1 >> 16 - level.bi_valid;
        level.bi_valid = level.bi_valid + -11;
      } else {
        level.bi_buf = level.bi_buf | diff1 << level.bi_valid & 65535;
        level.bi_valid = level.bi_valid + 5;
      }
      const diff2 = sum3 - 1;
      if (level.bi_valid > 11) {
        level.bi_buf = level.bi_buf | diff2 << level.bi_valid & 65535;
        const bi_buf3 = level.bi_buf;
        level.pending = +level.pending + 1;
        level.pending_buf[+level.pending] = 255 & bi_buf3;
        level.pending = +level.pending + 1;
        level.pending_buf[+level.pending] = bi_buf3 >>> 8 & 255;
        level.bi_buf = diff2 >> 16 - level.bi_valid;
        level.bi_valid = level.bi_valid + -11;
      } else {
        level.bi_buf = level.bi_buf | diff2 << level.bi_valid & 65535;
        level.bi_valid = level.bi_valid + 5;
      }
      const sum4 = num2 + 1;
      const diff3 = sum4 - 4;
      if (level.bi_valid > 12) {
        level.bi_buf = level.bi_buf | diff3 << level.bi_valid & 65535;
        const bi_buf4 = level.bi_buf;
        level.pending = +level.pending + 1;
        level.pending_buf[+level.pending] = 255 & bi_buf4;
        level.pending = +level.pending + 1;
        level.pending_buf[+level.pending] = bi_buf4 >>> 8 & 255;
        level.bi_buf = diff3 >> 16 - level.bi_valid;
        level.bi_valid = level.bi_valid + -12;
      } else {
        level.bi_buf = level.bi_buf | diff3 << level.bi_valid & 65535;
        level.bi_valid = level.bi_valid + 4;
      }
      let num57 = 0;
      if (0 < sum4) {
        do {
          let tmp33 = dependencyMap3;
          let tmp34 = level.bl_tree[2 * dependencyMap3[num57] + 1];
          let tmp35 = num57;
          if (level.bi_valid > 13) {
            level.bi_buf = level.bi_buf | tmp34 << level.bi_valid & 65535;
            let bi_buf5 = level.bi_buf;
            let tmp36 = +level.pending;
            level.pending = tmp36 + 1;
            level.pending_buf[tmp36] = 255 & bi_buf5;
            let tmp37 = +level.pending;
            level.pending = tmp37 + 1;
            level.pending_buf[tmp37] = bi_buf5 >>> 8 & 255;
            level.bi_buf = tmp34 >> 16 - level.bi_valid;
            level.bi_valid = level.bi_valid + -13;
          } else {
            level.bi_buf = level.bi_buf | tmp34 << level.bi_valid & 65535;
            level.bi_valid = level.bi_valid + 3;
          }
          num57 = num57 + 1;
        } while (num57 < sum4);
      }
      send_tree(level, level.dyn_ltree, sum2 - 1);
      send_tree(level, level.dyn_dtree, diff2);
      compress_block(level, level.dyn_ltree, level.dyn_dtree);
      num58 = 0;
    }
  }
  let num59 = 0;
  if (arg3) {
    num59 = 1;
  }
  const sum5 = 2 + num59;
  if (level.bi_valid > 13) {
    level.bi_buf = level.bi_buf | sum5 << level.bi_valid & 65535;
    const bi_buf6 = level.bi_buf;
    level.pending = +level.pending + 1;
    level.pending_buf[+level.pending] = 255 & bi_buf6;
    level.pending = +level.pending + 1;
    level.pending_buf[+level.pending] = bi_buf6 >>> 8 & 255;
    level.bi_buf = sum5 >> 16 - level.bi_valid;
    level.bi_valid = level.bi_valid + -13;
  } else {
    level.bi_buf = level.bi_buf | sum5 << level.bi_valid & 65535;
    level.bi_valid = level.bi_valid + 3;
  }
  compress_block(level, arr, array);
  num58 = 0;
};
arg5._tr_tally = function _tr_tally(state8, arg1, arg2) {
  state8.pending_buf[state8.d_buf + 2 * state8.last_lit] = arg1 >>> 8 & 255;
  state8.pending_buf[state8.d_buf + 2 * state8.last_lit + 1] = 255 & arg1;
  state8.pending_buf[state8.l_buf + state8.last_lit] = 255 & arg2;
  state8.last_lit = state8.last_lit + 1;
  if (0 === arg1) {
    const dyn_ltree2 = state8.dyn_ltree;
    const result = 2 * arg2;
    dyn_ltree2[result] = dyn_ltree2[result] + 1;
  } else {
    state8.matches = state8.matches + 1;
    const diff = arg1 - 1;
    const dyn_ltree = state8.dyn_ltree;
    const result1 = 2 * (array1[arg2] + 256 + 1);
    dyn_ltree[result1] = dyn_ltree[result1] + 1;
    const dyn_dtree = state8.dyn_dtree;
    if (diff < 256) {
      let tmp5 = array[diff];
    } else {
      tmp5 = array[256 + (diff >>> 7)];
    }
    const result2 = 2 * tmp5;
    dyn_dtree[result2] = dyn_dtree[result2] + 1;
  }
  return state8.last_lit === state8.lit_bufsize - 1;
};
arg5._tr_align = function _tr_align(state8) {
  if (state8.bi_valid > 13) {
    state8.bi_buf = state8.bi_buf | 2 << state8.bi_valid & 65535;
    const bi_buf = state8.bi_buf;
    state8.pending = +state8.pending + 1;
    state8.pending_buf[+state8.pending] = 255 & bi_buf;
    state8.pending = +state8.pending + 1;
    state8.pending_buf[+state8.pending] = bi_buf >>> 8 & 255;
    state8.bi_buf = 2 >> 16 - state8.bi_valid;
    state8.bi_valid = state8.bi_valid + -13;
  } else {
    state8.bi_buf = state8.bi_buf | 2 << state8.bi_valid & 65535;
    state8.bi_valid = state8.bi_valid + 3;
  }
  send_code(state8, 256, arr);
  if (16 === state8.bi_valid) {
    const bi_buf2 = state8.bi_buf;
    state8.pending = +state8.pending + 1;
    state8.pending_buf[+state8.pending] = 255 & bi_buf2;
    state8.pending = +state8.pending + 1;
    state8.pending_buf[+state8.pending] = bi_buf2 >>> 8 & 255;
    state8.bi_buf = 0;
    state8.bi_valid = 0;
  } else if (state8.bi_valid >= 8) {
    state8.pending = +state8.pending + 1;
    state8.pending_buf[+state8.pending] = 255 & state8.bi_buf;
    state8.bi_buf = state8.bi_buf >> 8;
    state8.bi_valid = state8.bi_valid - 8;
  }
};