// Module ID: 1879
// Function ID: 20897
// Name: decodeImage
// Dependencies: []

// Module 1879 (decodeImage)
let tmp = (() => {
  function decodeImage(data, width, height, tabs) {
    let ctype;
    let depth;
    const result = width * height;
    const rounded = Math.ceil(width * _getBPP(tabs) / 8);
    const uint8Array = new Uint8Array(4 * result);
    const uint32Array = new Uint32Array(uint8Array.buffer);
    ({ ctype, depth } = tabs);
    const readUshort = obj.readUshort;
    const timestamp = Date.now();
    if (6 == ctype) {
      if (8 == depth) {
        let num61 = 0;
        if (0 < tmp69) {
          do {
            uint8Array[num61] = data[num61];
            let sum = num61 + 1;
            uint8Array[sum] = data[sum];
            let sum1 = num61 + 2;
            uint8Array[sum1] = data[sum1];
            let sum2 = num61 + 3;
            uint8Array[sum2] = data[sum2];
            num61 = num61 + 4;
          } while (num61 < tmp69);
        }
      }
      if (16 == depth) {
        let num64 = 0;
        if (0 < tmp69) {
          do {
            uint8Array[num64] = data[num64 << 1];
            num64 = num64 + 1;
          } while (num64 < tmp69);
        }
      }
    } else if (2 == ctype) {
      let tRNS = tabs.tabs.tRNS;
      if (null == tRNS) {
        if (8 == depth) {
          let num55 = 0;
          if (0 < result) {
            do {
              let result1 = 3 * num55;
              uint32Array[num55] = -16777216 | data[result1 + 2] << 16 | data[result1 + 1] << 8 | data[result1];
              num55 = num55 + 1;
            } while (num55 < result);
          }
        }
        if (16 == depth) {
          let num57 = 0;
          if (0 < result) {
            do {
              let result2 = 6 * num57;
              uint32Array[num57] = -16777216 | data[result2 + 4] << 16 | data[result2 + 2] << 8 | data[result2];
              num57 = num57 + 1;
            } while (num57 < result);
          }
        }
      } else {
        const first = tRNS[0];
        if (8 == depth) {
          let num48 = 0;
          if (0 < result) {
            do {
              let result3 = 3 * num48;
              let sum3 = result3 + 2;
              let sum4 = result3 + 1;
              uint32Array[num48] = -16777216 | data[sum3] << 16 | data[sum4] << 8 | data[result3];
              let tmp61 = data[result3] == first;
              let tmp57 = num48 << 2;
              if (tmp61) {
                tmp61 = data[sum4] == tmp76;
              }
              if (tmp61) {
                tmp61 = data[sum3] == tmp77;
              }
              if (tmp61) {
                uint8Array[tmp57 + 3] = 0;
              }
              num48 = num48 + 1;
            } while (num48 < result);
          }
        }
        if (16 == depth) {
          let num50 = 0;
          if (0 < result) {
            do {
              let result4 = 6 * num50;
              let sum5 = result4 + 4;
              let sum6 = result4 + 2;
              uint32Array[num50] = -16777216 | data[sum5] << 16 | data[sum6] << 8 | data[result4];
              let tmp62 = num50 << 2;
              let tmp66 = readUshort(data, result4) == first && readUshort(data, sum6) == tmp76 && readUshort(data, sum5) == tmp77;
              if (tmp66) {
                uint8Array[tmp62 + 3] = 0;
              }
              num50 = num50 + 1;
            } while (num50 < result);
          }
        }
      }
    } else if (3 == ctype) {
      const PLTE = tabs.tabs.PLTE;
      tRNS = tabs.tabs.tRNS;
      let num30 = 0;
      if (tRNS) {
        num30 = tRNS.length;
      }
      let tmp26;
      let tmp27;
      if (1 == depth) {
        let num34 = 0;
        if (0 < height) {
          do {
            let num35 = 0;
            if (0 < width) {
              do {
                let tmp32 = tmp31 + num35 << 2;
                let tmp33 = data[tmp30 + (num35 >> 3)] >> 7 - (7 & num35) & 1;
                let result5 = 3 * tmp33;
                uint8Array[tmp32] = PLTE[result5];
                uint8Array[tmp32 + 1] = PLTE[result5 + 1];
                uint8Array[tmp32 + 2] = PLTE[result5 + 2];
                let num36 = 255;
                if (tmp33 < num30) {
                  num36 = tRNS[tmp33];
                }
                uint8Array[tmp32 + 3] = num36;
                num35 = num35 + 1;
                let tmp28 = tmp32;
                let tmp29 = tmp33;
              } while (num35 < width);
            }
            num34 = num34 + 1;
            tmp26 = tmp28;
            tmp27 = tmp29;
          } while (num34 < height);
        }
      }
      if (2 == depth) {
        let tmp42 = tmp26;
        let num39 = 0;
        let tmp43 = tmp27;
        if (0 < height) {
          do {
            let num37 = 0;
            if (0 < width) {
              do {
                let tmp39 = tmp38 + num37 << 2;
                let tmp40 = data[tmp37 + (num37 >> 2)] >> 6 - ((3 & num37) << 1) & 3;
                let result6 = 3 * tmp40;
                uint8Array[tmp39] = PLTE[result6];
                uint8Array[tmp39 + 1] = PLTE[result6 + 1];
                uint8Array[tmp39 + 2] = PLTE[result6 + 2];
                let num38 = 255;
                if (tmp40 < num30) {
                  num38 = tRNS[tmp40];
                }
                uint8Array[tmp39 + 3] = num38;
                num37 = num37 + 1;
                tmp42 = tmp39;
                tmp43 = tmp40;
              } while (num37 < width);
            }
            num39 = num39 + 1;
            let tmp44 = tmp42;
            let tmp45 = tmp43;
          } while (num39 < height);
        }
      }
      if (4 == depth) {
        for (let num42 = 0; num42 < height; num42 = num42 + 1) {
          let num40 = 0;
          if (0 < width) {
            do {
              let tmp48 = tmp47 + num40 << 2;
              let tmp49 = data[tmp46 + (num40 >> 1)] >> 4 - ((1 & num40) << 2) & 15;
              let result7 = 3 * tmp49;
              uint8Array[tmp48] = PLTE[result7];
              uint8Array[tmp48 + 1] = PLTE[result7 + 1];
              uint8Array[tmp48 + 2] = PLTE[result7 + 2];
              let num41 = 255;
              if (tmp49 < num30) {
                num41 = tRNS[tmp49];
              }
              uint8Array[tmp48 + 3] = num41;
              num40 = num40 + 1;
              let tmp51 = tmp48;
              let tmp52 = tmp49;
            } while (num40 < width);
          }
        }
      }
      if (8 == depth) {
        let num44 = 0;
        if (0 < result) {
          do {
            let tmp53 = num44 << 2;
            let tmp54 = data[num44];
            let result8 = 3 * tmp54;
            uint8Array[tmp53] = PLTE[result8];
            uint8Array[tmp53 + 1] = PLTE[result8 + 1];
            uint8Array[tmp53 + 2] = PLTE[result8 + 2];
            let num43 = 255;
            if (tmp54 < num30) {
              num43 = tRNS[tmp54];
            }
            uint8Array[tmp53 + 3] = num43;
            num44 = num44 + 1;
          } while (num44 < result);
        }
      }
    } else if (4 == ctype) {
      if (8 == depth) {
        let num26 = 0;
        if (0 < result) {
          do {
            let tmp20 = num26 << 2;
            let tmp21 = num26 << 1;
            let tmp22 = data[tmp21];
            uint8Array[tmp20] = tmp22;
            uint8Array[tmp20 + 1] = tmp22;
            uint8Array[tmp20 + 2] = tmp22;
            uint8Array[tmp20 + 3] = data[tmp21 + 1];
            num26 = num26 + 1;
          } while (num26 < result);
        }
      }
      if (16 == depth) {
        let num28 = 0;
        if (0 < result) {
          do {
            let tmp23 = num28 << 2;
            let tmp24 = num28 << 2;
            let tmp25 = data[tmp24];
            uint8Array[tmp23] = tmp25;
            uint8Array[tmp23 + 1] = tmp25;
            uint8Array[tmp23 + 2] = tmp25;
            uint8Array[tmp23 + 3] = data[tmp24 + 2];
            num28 = num28 + 1;
          } while (num28 < result);
        }
      }
    } else if (0 == ctype) {
      let num = -1;
      if (tabs.tabs.tRNS) {
        num = tabs.tabs.tRNS;
      }
      let num10 = 0;
      if (0 < height) {
        do {
          let result9 = num10 * rounded;
          let result10 = num10 * width;
          if (1 == depth) {
            let num22 = 0;
            let tmp9 = tmp6;
            let num23 = 0;
            if (0 < width) {
              do {
                let result11 = 255 * (data[result9 + (num22 >>> 3)] >>> 7 - (7 & num22) & 1);
                let num24 = 255;
                if (result11 === 255 * num) {
                  num24 = 0;
                }
                uint32Array[result10 + num22] = num24 << 24 | result11 << 16 | result11 << 8 | result11;
                num22 = num22 + 1;
                tmp9 = result11;
                let tmp19 = num22;
              } while (num22 < width);
            }
          } else if (2 == depth) {
            let num19 = 0;
            tmp9 = tmp6;
            let num20 = 0;
            if (0 < width) {
              do {
                let result12 = 85 * (data[result9 + (num19 >>> 2)] >>> 6 - ((3 & num19) << 1) & 3);
                let num21 = 255;
                if (result12 === 85 * num) {
                  num21 = 0;
                }
                uint32Array[result10 + num19] = num21 << 24 | result12 << 16 | result12 << 8 | result12;
                num19 = num19 + 1;
                tmp9 = result12;
                let tmp17 = num19;
              } while (num19 < width);
            }
          } else if (4 == depth) {
            let num16 = 0;
            tmp9 = tmp6;
            let num17 = 0;
            if (0 < width) {
              do {
                let result13 = 17 * (data[result9 + (num16 >>> 1)] >>> 4 - ((1 & num16) << 2) & 15);
                let num18 = 255;
                if (result13 === 17 * num) {
                  num18 = 0;
                }
                uint32Array[result10 + num16] = num18 << 24 | result13 << 16 | result13 << 8 | result13;
                num16 = num16 + 1;
                tmp9 = result13;
                let tmp15 = num16;
              } while (num16 < width);
            }
          } else if (8 == depth) {
            let num13 = 0;
            tmp9 = tmp6;
            let num14 = 0;
            if (0 < width) {
              do {
                let tmp12 = data[result9 + num13];
                let num15 = 255;
                if (tmp12 == num) {
                  num15 = 0;
                }
                uint32Array[result10 + num13] = num15 << 24 | tmp12 << 16 | tmp12 << 8 | tmp12;
                num13 = num13 + 1;
                tmp9 = tmp12;
                let tmp13 = num13;
              } while (num13 < width);
            }
          } else {
            tmp9 = tmp6;
            if (16 == depth) {
              let num12 = 0;
              tmp9 = tmp6;
              let num68 = 0;
              if (0 < width) {
                do {
                  let tmp10 = data[result9 + (num12 << 1)];
                  let num11 = 255;
                  if (readUshort(data, result9 + (num12 << 1)) == num) {
                    num11 = 0;
                  }
                  uint32Array[result10 + num12] = num11 << 24 | tmp10 << 16 | tmp10 << 8 | tmp10;
                  num12 = num12 + 1;
                  tmp9 = tmp10;
                  let tmp11 = num12;
                } while (num12 < width);
              }
            }
          }
          num10 = num10 + 1;
          tmp6 = tmp9;
        } while (num10 < height);
      }
    }
    return uint8Array;
  }
  function _decompress(size, arr4, width, height) {
    const timestamp = Date.now();
    const uint8Array = new Uint8Array((Math.ceil(width * _getBPP(size) / 8) + 1 + size.interlace) * height);
    if (size.tabs.CgBI) {
      let tmp4 = callback(arr4, uint8Array);
    } else {
      tmp4 = _inflate(arr4, uint8Array);
    }
    const timestamp1 = Date.now();
    if (0 == size.interlace) {
      _filterZero(tmp4, size, 0, width, height);
      let tmp38 = tmp4;
    } else {
      tmp38 = tmp4;
      if (1 == size.interlace) {
        ({ width, height } = size);
        const tmp46 = _getBPP(size);
        const _Math2 = Math;
        const rounded = Math.ceil(width * tmp46 / 8);
        const _Uint8Array = Uint8Array;
        const uint8Array1 = new Uint8Array(height * rounded);
        const items = [0, 0, 4, 0, 2, 0, 1];
        const items1 = [0, 4, 0, 2, 0, 1, 0];
        let num9 = 0;
        let num8 = 0;
        do {
          let tmp7 = [8, 8, 8, 4, 4, 2, 2][num8];
          let tmp8 = tmp53[num8];
          let sum = items[num8];
          let num = 0;
          let num2 = 0;
          while (sum < height) {
            sum = sum + tmp7;
            num = num + 1;
            num2 = num;
          }
          let sum1 = items1[num8];
          let num3 = 0;
          let num4 = 0;
          while (sum1 < width) {
            sum1 = sum1 + tmp8;
            num3 = num3 + 1;
            num4 = num3;
          }
          let _Math = Math;
          let rounded1 = Math.ceil(num4 * tmp46 / 8);
          let tmp12 = _filterZero;
          let tmp13 = tmp4;
          let tmp14 = size;
          let tmp15 = num9;
          let tmp16 = num4;
          let tmp17 = num2;
          let tmp18 = _filterZero(tmp4, size, num9, num4, num2);
          let sum8 = items[num8];
          let num5 = 0;
          let tmp20 = tmp22;
          let tmp21 = tmp23;
          while (sum8 < height) {
            let sum7 = items1[num8];
            let sum6 = num9 + num5 * rounded1 << 3;
            let tmp26 = tmp20;
            let num6 = tmp21;
            let tmp27 = sum6;
            let tmp28 = tmp20;
            let tmp29 = tmp21;
            let tmp30 = sum7;
            if (sum7 < width) {
              do {
                if (1 == tmp46) {
                  let sum2 = sum8 * rounded + (sum7 >> 3);
                  uint8Array1[sum2] = uint8Array1[sum2] | (tmp4[sum6 >> 3] >> 7 - (7 & sum6) & 1) << 7 - (7 & sum7);
                }
                if (2 == tmp46) {
                  let sum3 = sum8 * rounded + (sum7 >> 2);
                  uint8Array1[sum3] = uint8Array1[sum3] | (tmp4[sum6 >> 3] >> 6 - (7 & sum6) & 3) << 6 - ((3 & sum7) << 1);
                }
                if (4 == tmp46) {
                  let sum4 = sum8 * rounded + (sum7 >> 1);
                  uint8Array1[sum4] = uint8Array1[sum4] | (tmp4[sum6 >> 3] >> 4 - (7 & sum6) & 15) << 4 - ((1 & sum7) << 2);
                }
                if (tmp46 >= 8) {
                  let sum5 = sum8 * rounded + sum7 * tmp47;
                  let num7 = 0;
                  tmp26 = sum5;
                  num6 = 0;
                  if (0 < tmp47) {
                    do {
                      uint8Array1[sum5 + num7] = tmp4[(sum6 >> 3) + num7];
                      num7 = num7 + 1;
                      tmp26 = sum5;
                      num6 = num7;
                    } while (num7 < tmp47);
                  }
                }
                sum6 = sum6 + tmp46;
                sum7 = sum7 + tmp8;
                tmp27 = sum6;
                tmp28 = tmp26;
                tmp29 = num6;
                tmp30 = sum7;
              } while (sum7 < width);
            }
            num5 = num5 + 1;
            sum8 = sum8 + tmp7;
            let tmp35 = tmp30;
            let tmp36 = tmp27;
            tmp20 = tmp28;
            tmp21 = tmp29;
            tmp22 = tmp28;
            tmp23 = tmp29;
          }
          let sum9 = num9;
          if (num4 * num2 != 0) {
            sum9 = num9 + num2 * (1 + rounded1);
          }
          num8 = num8 + 1;
          num9 = sum9;
          tmp38 = uint8Array1;
        } while (num8 < 7);
      }
    }
    return tmp38;
  }
  function _inflate(arr3, uint8Array) {
    uint8Array = new Uint8Array(arr3.buffer, 2, arr3.length - 6);
    return callback(uint8Array, uint8Array);
  }
  function _getBPP(depth) {
    return [1, null, 3, 1, 2, null, 4][depth.ctype] * depth.depth;
  }
  function _filterZero(arg0, depth) {
    const tmp = _getBPP(depth);
    const rounded = Math.ceil(arg3 * tmp / 8);
    const rounded1 = Math.ceil(tmp / 8);
    if (arg0[arg2] > 1) {
      arg0[arg2] = [0, 0, 1][tmp4 - 2];
    }
    if (3 == arg0[arg2]) {
      let sum = rounded1;
      if (rounded1 < rounded) {
        do {
          arg0[sum + 1] = arg0[sum + 1] + (arg0[sum + 1 - rounded1] >>> 1) & 255;
          sum = sum + 1;
        } while (sum < rounded);
      }
    }
    for (let num3 = 0; num3 < arg4; num3 = num3 + 1) {
      let sum1 = arg2 + num3 * rounded;
      let sum2 = sum1 + num3 + 1;
      let tmp8 = arg0[sum2 - 1];
      if (0 == tmp8) {
        for (let num11 = 0; num11 < rounded; num11 = num11 + 1) {
          arg0[sum1 + num11] = arg0[sum2 + num11];
        }
      } else if (1 == tmp8) {
        let num9 = 0;
        let num10 = 0;
        if (0 < rounded1) {
          do {
            arg0[sum1 + num9] = arg0[sum2 + num9];
            num9 = num9 + 1;
            num10 = num9;
          } while (num9 < rounded1);
        }
        if (num10 < rounded) {
          do {
            arg0[sum1 + num10] = arg0[sum2 + num10] + arg0[sum1 + num10 - rounded1];
            num10 = num10 + 1;
          } while (num10 < rounded);
        }
      } else if (2 == tmp8) {
        for (let num8 = 0; num8 < rounded; num8 = num8 + 1) {
          arg0[sum1 + num8] = arg0[sum2 + num8] + arg0[sum1 + num8 - rounded];
        }
      } else if (3 == tmp8) {
        let num6 = 0;
        let num7 = 0;
        if (0 < rounded1) {
          do {
            arg0[sum1 + num6] = arg0[sum2 + num6] + (arg0[sum1 + num6 - rounded] >>> 1);
            num6 = num6 + 1;
            num7 = num6;
          } while (num6 < rounded1);
        }
        if (num7 < rounded) {
          do {
            arg0[sum1 + num7] = arg0[sum2 + num7] + (arg0[sum1 + num7 - rounded] + arg0[sum1 + num7 - rounded1] >>> 1);
            num7 = num7 + 1;
          } while (num7 < rounded);
        }
      } else {
        let num4 = 0;
        let num5 = 0;
        if (0 < rounded1) {
          do {
            let tmp10 = _paeth;
            let sum3 = sum1 + num4;
            arg0[sum3] = arg0[sum2 + num4] + _paeth(0, arg0[sum1 + num4 - rounded], 0);
            num4 = num4 + 1;
            num5 = num4;
          } while (num4 < rounded1);
        }
        if (num5 < rounded) {
          do {
            let tmp12 = _paeth;
            let sum4 = sum1 + num5;
            arg0[sum4] = arg0[sum2 + num5] + _paeth(arg0[sum1 + num5 - rounded1], arg0[sum1 + num5 - rounded], arg0[sum1 + num5 - rounded1 - rounded]);
            num5 = num5 + 1;
          } while (num5 < rounded);
        }
      }
    }
    return arg0;
  }
  function _paeth(arg0, arg1, arg2) {
    let tmp = arg0;
    let tmp2 = arg2;
    const diff = arg0 + arg1 - arg2;
    const diff1 = diff - arg0;
    const diff2 = diff - arg1;
    const diff3 = diff - arg2;
    if (diff1 * diff1 > diff2 * diff2) {
      if (diff2 * diff2 <= diff3 * diff3) {
        tmp2 = arg1;
      }
      tmp = tmp2;
    }
    return tmp;
  }
  function _IHDR(arr3, sum2, arg2) {
    arg2.width = obj.readUint(arr3, sum2);
    const sum = sum2 + 4;
    arg2.height = obj.readUint(arr3, sum);
    const sum1 = sum + 4;
    arg2.depth = arr3[sum1];
    sum2 = sum1 + 1;
    arg2.ctype = arr3[sum2];
    const sum3 = sum2 + 1;
    arg2.compress = arr3[sum3];
    const sum4 = sum3 + 1;
    arg2.filter = arr3[sum4];
    arg2.interlace = arr3[sum4 + 1];
  }
  function _copyTile(arg0, width2, height2, arg3, width, height, arg6, arg7, arg8) {
    const bound = Math.min(width2, width);
    const bound1 = Math.min(height2, height);
    for (let num = 0; num < bound1; num = num + 1) {
      let tmp13 = tmp3;
      let tmp14 = tmp4;
      let tmp15 = tmp5;
      let tmp16 = tmp6;
      let tmp17 = tmp7;
      let tmp18 = tmp8;
      let tmp19 = tmp9;
      let tmp20 = tmp10;
      let tmp21 = tmp11;
      let tmp22 = tmp12;
      let num2 = 0;
      if (0 < bound) {
        while (true) {
          if (arg6 >= 0) {
            if (arg7 >= 0) {
              let tmp23 = num * width2 + num2 << 2;
              let tmp24 = (arg7 + num) * width + arg6 + num2 << 2;
              if (0 == arg8) {
                arg3[tmp24] = arg0[tmp23];
                arg3[tmp24 + 1] = arg0[tmp23 + 1];
                arg3[tmp24 + 2] = arg0[tmp23 + 2];
                arg3[tmp24 + 3] = arg0[tmp23 + 3];
                let tmp25 = tmp13;
                let tmp26 = tmp14;
                let tmp27 = tmp15;
                let tmp28 = tmp16;
                let tmp29 = tmp17;
                let tmp30 = tmp18;
                let tmp31 = tmp19;
                let tmp32 = tmp20;
                let tmp33 = tmp21;
                let tmp34 = tmp22;
              } else if (1 == arg8) {
                let result = 0.00392156862745098 * arg0[tmp23 + 3];
                let result1 = arg0[tmp23] * result;
                let result2 = arg0[tmp23 + 1] * result;
                let result3 = arg0[tmp23 + 2] * result;
                let sum = tmp24 + 3;
                let result4 = 0.00392156862745098 * arg3[sum];
                let result5 = arg3[tmp24] * result4;
                let sum1 = tmp24 + 1;
                let result6 = arg3[sum1] * result4;
                let sum2 = tmp24 + 2;
                let result7 = arg3[sum2] * result4;
                let diff = 1 - result;
                let sum3 = result + result4 * diff;
                let num3 = 0;
                if (0 !== sum3) {
                  num3 = 1 / sum3;
                }
                arg3[sum] = 255 * sum3;
                arg3[tmp24] = (result1 + result5 * diff) * num3;
                arg3[sum1] = (result2 + result6 * diff) * num3;
                arg3[sum2] = (result3 + result7 * diff) * num3;
                tmp25 = result;
                tmp26 = result1;
                tmp27 = result2;
                tmp28 = result3;
                tmp29 = result4;
                tmp30 = result5;
                tmp31 = result6;
                tmp32 = result7;
                tmp33 = diff;
                tmp34 = sum3;
              } else if (2 == arg8) {
                let tmp35 = arg0[tmp23 + 3];
                let tmp36 = arg0[tmp23];
                let tmp37 = arg0[tmp23 + 1];
                let tmp38 = arg0[tmp23 + 2];
                let sum4 = tmp24 + 3;
                let tmp40 = arg3[sum4];
                let tmp41 = arg3[tmp24];
                let sum5 = tmp24 + 1;
                let tmp43 = arg3[sum5];
                let sum6 = tmp24 + 2;
                let tmp45 = arg3[sum6];
                if (tmp35 == tmp40) {
                  if (tmp36 == tmp41) {
                    if (tmp37 == tmp43) {
                      if (tmp38 == tmp45) {
                        arg3[tmp24] = 0;
                        arg3[sum5] = 0;
                        arg3[sum6] = 0;
                        arg3[sum4] = 0;
                        tmp25 = tmp35;
                        tmp26 = tmp36;
                        tmp27 = tmp37;
                        tmp28 = tmp38;
                        tmp29 = tmp40;
                        tmp30 = tmp41;
                        tmp31 = tmp43;
                        tmp32 = tmp45;
                        tmp33 = tmp21;
                        tmp34 = tmp22;
                      }
                    }
                  }
                }
                arg3[tmp24] = tmp36;
                arg3[sum5] = tmp37;
                arg3[sum6] = tmp38;
                arg3[sum4] = tmp35;
                tmp25 = tmp35;
                tmp26 = tmp36;
                tmp27 = tmp37;
                tmp28 = tmp38;
                tmp29 = tmp40;
                tmp30 = tmp41;
                tmp31 = tmp43;
                tmp32 = tmp45;
                tmp33 = tmp21;
                tmp34 = tmp22;
              } else {
                tmp25 = tmp13;
                tmp26 = tmp14;
                tmp27 = tmp15;
                tmp28 = tmp16;
                tmp29 = tmp17;
                tmp30 = tmp18;
                tmp31 = tmp19;
                tmp32 = tmp20;
                tmp33 = tmp21;
                tmp34 = tmp22;
                if (3 == arg8) {
                  let tmp61 = arg0[tmp23 + 3];
                  let tmp62 = arg0[tmp23];
                  let tmp63 = arg0[tmp23 + 1];
                  let tmp64 = arg0[tmp23 + 2];
                  let tmp65 = arg3[tmp24 + 3];
                  let tmp66 = arg3[tmp24];
                  let tmp67 = arg3[tmp24 + 1];
                  let tmp68 = arg3[tmp24 + 2];
                  if (tmp61 == tmp65) {
                    if (tmp62 == tmp66) {
                      if (tmp63 == tmp67) {
                        tmp25 = tmp61;
                        tmp26 = tmp62;
                        tmp27 = tmp63;
                        tmp28 = tmp64;
                        tmp29 = tmp65;
                        tmp30 = tmp66;
                        tmp31 = tmp67;
                        tmp32 = tmp68;
                        tmp33 = tmp21;
                        tmp34 = tmp22;
                      }
                    }
                  }
                  tmp26 = tmp62;
                  tmp27 = tmp63;
                  tmp28 = tmp64;
                  tmp29 = tmp65;
                  tmp30 = tmp66;
                  tmp31 = tmp67;
                  tmp32 = tmp68;
                  tmp33 = tmp21;
                  tmp34 = tmp22;
                  tmp25 = tmp61;
                  if (tmp61 < 220) {
                    tmp25 = tmp61;
                    tmp26 = tmp62;
                    tmp27 = tmp63;
                    tmp28 = tmp64;
                    tmp29 = tmp65;
                    tmp30 = tmp66;
                    tmp31 = tmp67;
                    tmp32 = tmp68;
                    tmp33 = tmp21;
                    tmp34 = tmp22;
                    if (tmp65 > 20) {
                      let flag = false;
                      return false;
                    }
                  }
                }
              }
              num2 = num2 + 1;
              tmp13 = tmp25;
              tmp14 = tmp26;
              tmp15 = tmp27;
              tmp16 = tmp28;
              tmp17 = tmp29;
              tmp18 = tmp30;
              tmp19 = tmp31;
              tmp20 = tmp32;
              tmp21 = tmp33;
              tmp22 = tmp34;
              let tmp59 = tmp23;
              let tmp60 = tmp24;
              tmp3 = tmp25;
              tmp4 = tmp26;
              tmp5 = tmp27;
              tmp6 = tmp28;
              tmp7 = tmp29;
              tmp8 = tmp30;
              tmp9 = tmp31;
              tmp10 = tmp32;
              tmp11 = tmp33;
              tmp12 = tmp34;
              if (num2 >= bound) {
                break;
              }
            }
          }
          tmp23 = (-arg7 + num) * width2 - arg6 + num2 << 2;
          tmp24 = num * width + num2 << 2;
        }
      }
    }
    return true;
  }
  let obj = {
    nextZero(arr3, sum2) {
      let tmp4;
      let tmp = sum2;
      let tmp2 = sum2;
      if (0 != arr3[sum2]) {
        do {
          let sum = tmp + 1;
          tmp = sum;
          tmp2 = sum;
          tmp4 = arr3[sum];
        } while (0 != tmp4);
      }
      return tmp2;
    },
    readUshort(arr3, sum2) {
      return arr3[sum2] << 8 | arr3[sum2 + 1];
    },
    writeUshort(uint8Array, sum40, arg2) {
      uint8Array[sum40] = arg2 >> 8 & 255;
      uint8Array[sum40 + 1] = 255 & arg2;
    },
    readUint(arr3, sum2) {
      return 16777216 * arr3[sum2] + (arr3[sum2 + 1] << 16 | arr3[sum2 + 2] << 8 | arr3[sum2 + 3]);
    },
    writeUint(uint8Array, writeUintResult16, height) {
      uint8Array[writeUintResult16] = height >> 24 & 255;
      uint8Array[writeUintResult16 + 1] = height >> 16 & 255;
      uint8Array[writeUintResult16 + 2] = height >> 8 & 255;
      uint8Array[writeUintResult16 + 3] = 255 & height;
    },
    readASCII(arr3, sum2, sum) {
      let num = 0;
      let str = "";
      let str2 = "";
      if (0 < sum) {
        do {
          let _String = String;
          str = `${String.fromCharCode(arr3[sum2 + num])}`;
          num = num + 1;
          str2 = str;
        } while (num < sum);
      }
      return str2;
    },
    writeASCII(uint8Array, writeUintResult16, IEND) {
      let length;
      let num = 0;
      if (0 < IEND.length) {
        do {
          let sum = writeUintResult16 + num;
          uint8Array[sum] = IEND.charCodeAt(num);
          num = num + 1;
          length = IEND.length;
        } while (num < length);
      }
    },
    readBytes(arr3, sum2, uint) {
      const items = [];
      for (let num = 0; num < uint; num = num + 1) {
        let arr = items.push(arr3[sum2 + num]);
      }
      return items;
    },
    pad(arg0) {
      let text = arg0;
      if (arg0.length < 2) {
        text = `0${arg0}`;
      }
      return text;
    },
    readUTF8(arr3, sum, length) {
      let str = "";
      let num = 0;
      if (0 < length) {
        do {
          let tmp = str;
          let tmp2 = obj;
          let tmp4 = arr3;
          let tmp5 = sum;
          let str2 = arr3[sum + num];
          str = `${"%" + tmp3(str2.toString(16))}`;
          num = num + 1;
          let tmp6 = length;
        } while (num < length);
      }
      return decodeURIComponent(str);
    }
  };
  let closure_1 = (() => {
    function C(arg0, arg1) {
      const v = obj.v;
      for (let num = 0; num <= arg1; num = num + 1) {
        v[num] = 0;
      }
      for (let num2 = 1; num2 < length; num2 = num2 + 2) {
        let tmp = arg0[num2];
        v[tmp] = v[tmp] + 1;
      }
      const m = obj.m;
      v[0] = 0;
      let num3 = 0;
      for (let num4 = 1; num4 <= arg1; num4 = num4 + 1) {
        num3 = num3 + v[num4 - 1] << 1;
        m[num4] = num3;
      }
      for (let num5 = 0; num5 < length; num5 = num5 + 2) {
        let tmp2 = arg0[num5 + 1];
        if (0 != tmp2) {
          arg0[num5] = m[tmp2];
          m[tmp2] = m[tmp2] + 1;
        }
      }
    }
    function t(arg0, arg1, arg2) {
      for (let num = 0; num < length; num = num + 2) {
        let sum = num + 1;
        if (0 != arg0[sum]) {
          let tmp3 = arg0[sum];
          let tmp4 = num >> 1 << 4 | tmp3;
          let diff = arg1 - tmp3;
          let tmp6 = arg0[num] << diff;
          let sum1 = tmp6 + (1 << diff);
          let sum2 = tmp6;
          let tmp9 = tmp4;
          let tmp10 = tmp6;
          let tmp11 = sum1;
          if (tmp6 != sum1) {
            do {
              arg2[tmp[sum2] >>> 15 - arg1] = tmp4;
              sum2 = sum2 + 1;
              let tmp12 = tmp4;
              let tmp13 = sum1;
              let tmp14 = sum2;
            } while (sum2 != sum1);
          }
        }
      }
    }
    function g(arg0, arg1) {
      let length;
      let num = 0;
      if (0 < arg0.length) {
        do {
          arg0[num] = tmp[arg0[num] << arg1 - arg0[num + 1]] >>> tmp2;
          num = num + 2;
          length = arg0.length;
        } while (num < length);
      }
    }
    function F(arg0, arg1, arg2) {
      return (arg0[arg1 >>> 3] | arg0[1 + (arg1 >>> 3)] << 8) >>> (7 & arg1) & (1 << arg2) - 1;
    }
    function s(arg0, arg1, arg2) {
      return (arg0[arg1 >>> 3] | arg0[1 + (arg1 >>> 3)] << 8 | arg0[2 + (arg1 >>> 3)] << 16) >>> (7 & arg1) & (1 << arg2) - 1;
    }
    function w(arg0, arg1) {
      return (arg0[arg1 >>> 3] | arg0[1 + (arg1 >>> 3)] << 8 | arg0[2 + (arg1 >>> 3)] << 16) >>> (7 & arg1);
    }
    function H(arg0, arg1) {
      if (arg1 <= arg0.length) {
        return arg0;
      } else {
        const _Uint8Array = Uint8Array;
        const _Math = Math;
        const uint8Array = new Uint8Array(Math.max(length << 1, arg1));
        const result = uint8Array.set(arg0, 0);
        return uint8Array;
      }
    }
    function B(arg0, arg1, arg2, arg3, arg4, arg5) {
      let sum1;
      let tmp = arg4;
      let num = 0;
      let tmp5 = arg4;
      if (0 < arg2) {
        do {
          let tmp6 = w;
          let tmp7 = arg0[w(undefined, arg3, tmp) & arg1];
          let sum = tmp + (15 & tmp7);
          let tmp9 = tmp7 >>> 4;
          if (tmp9 <= 15) {
            arg5[num] = tmp9;
            sum1 = num + 1;
            let tmp16 = sum;
            let tmp17 = tmp2;
            let tmp18 = tmp3;
            let tmp19 = tmp4;
          } else {
            if (16 === tmp9) {
              let tmp13 = F;
              let num3 = 3 + F(arg3, sum, 2);
              let sum2 = sum + 2;
              let num2 = arg5[num - 1];
            } else if (17 === tmp9) {
              let tmp12 = F;
              num3 = 3 + F(arg3, sum, 3);
              sum2 = sum + 3;
              num2 = 0;
            } else {
              sum2 = sum;
              num2 = 0;
              num3 = 0;
              if (18 === tmp9) {
                let tmp11 = F;
                num3 = 11 + F(arg3, sum, 7);
                sum2 = sum + 7;
                num2 = 0;
              }
            }
            let sum3 = num + num3;
            let sum4 = num;
            tmp16 = sum2;
            tmp17 = num2;
            tmp18 = num3;
            tmp19 = sum3;
            sum1 = num;
            if (num < sum3) {
              do {
                arg5[sum4] = num2;
                sum4 = sum4 + 1;
                tmp16 = sum2;
                tmp17 = num2;
                tmp18 = num3;
                sum1 = sum4;
                tmp19 = sum3;
              } while (sum4 < sum3);
            }
          }
          tmp = tmp16;
          num = sum1;
          tmp2 = tmp17;
          tmp3 = tmp18;
          tmp4 = tmp19;
          tmp5 = tmp16;
        } while (sum1 < arg2);
      }
      return tmp5;
    }
    function d(arg0, arg1, arg2, arg3) {
      let num = 0;
      let num2 = 0;
      let num3 = 0;
      let num4 = 0;
      if (0 < arg2) {
        do {
          let tmp2 = arg0[num2 + arg1];
          arg3[num2 << 1] = 0;
          arg3[1 + (num2 << 1)] = tmp2;
          if (tmp2 > num) {
            num = tmp2;
          }
          num2 = num2 + 1;
          num3 = num;
          num4 = num2;
        } while (num2 < arg2);
      }
      if (num4 < arg3.length >>> 1) {
        do {
          arg3[num4 << 1] = 0;
          arg3[1 + (num4 << 1)] = 0;
          num4 = num4 + 1;
        } while (num4 < tmp);
      }
      return num3;
    }
    let obj = {};
    const uint16Array = new Uint16Array(16);
    obj.m = uint16Array;
    const uint16Array1 = new Uint16Array(16);
    obj.v = uint16Array1;
    obj.d = [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15];
    obj.o = [3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 999, 999, 999];
    obj.z = [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, 0, 0, 0];
    const uint16Array2 = new Uint16Array(32);
    obj.B = uint16Array2;
    obj.p = [1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145, 8193, 12289, 16385, 24577, 65535, 65535];
    obj.w = [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, 0, 0];
    const uint32Array = new Uint32Array(32);
    obj.h = uint32Array;
    const uint16Array3 = new Uint16Array(512);
    obj.g = uint16Array3;
    obj.s = [];
    const uint16Array4 = new Uint16Array(32);
    obj.A = uint16Array4;
    obj.t = [];
    const uint16Array5 = new Uint16Array(32768);
    obj.k = uint16Array5;
    obj.c = [];
    obj.a = [];
    const uint16Array6 = new Uint16Array(32768);
    obj.n = uint16Array6;
    obj.e = [];
    const uint16Array7 = new Uint16Array(512);
    obj.C = uint16Array7;
    obj.b = [];
    const uint16Array8 = new Uint16Array(32768);
    obj.i = uint16Array8;
    const uint32Array1 = new Uint32Array(286);
    obj.r = uint32Array1;
    const uint32Array2 = new Uint32Array(30);
    obj.f = uint32Array2;
    const uint32Array3 = new Uint32Array(19);
    obj.l = uint32Array3;
    const uint32Array4 = new Uint32Array(15000);
    obj.u = uint32Array4;
    const uint16Array9 = new Uint16Array(65536);
    obj.q = uint16Array9;
    const uint16Array10 = new Uint16Array(32768);
    obj.j = uint16Array10;
    (() => {
      let num2;
      class A {
        constructor(arg0, arg1, arg2) {
          tmp = +arg1;
          diff = tmp - 1;
          if (0 != tmp) {
            do {
              arr = arg0.push(0, arg2);
              tmp4 = +diff;
              diff = tmp4 - 1;
            } while (0 != tmp4);
          }
          return;
        }
      }
      let num = 0;
      do {
        let tmp = (2863311530 & num) >>> 1 | (1431655765 & num) << 1;
        let tmp2 = (3435973836 & tmp) >>> 2 | (858993459 & tmp) << 2;
        let tmp3 = (4042322160 & tmp2) >>> 4 | (252645135 & tmp2) << 4;
        let tmp4 = (4278255360 & tmp3) >>> 8 | (16711935 & tmp3) << 8;
        let tmp5 = obj;
        obj.i[num] = (tmp4 >>> 16 | tmp4 << 16) >>> 17;
        num = num + 1;
        num2 = 0;
      } while (num < 32768);
      do {
        let tmp6 = obj;
        let tmp7 = obj;
        let tmp8 = obj;
        obj.B[num2] = obj.o[num2] << 3 | obj.z[num2];
        let tmp9 = obj;
        let tmp10 = obj;
        let tmp11 = obj;
        obj.h[num2] = obj.p[num2] << 4 | obj.w[num2];
        num2 = num2 + 1;
      } while (num2 < 32);
      A(obj.s, 144, 8);
      A(obj.s, 112, 9);
      A(obj.s, 24, 7);
      A(obj.s, 8, 8);
      C(obj.s, 9);
      t(obj.s, 9, obj.g);
      g(obj.s, 9);
      A(obj.t, 32, 5);
      C(obj.t, 5);
      t(obj.t, 5, obj.A);
      g(obj.t, 5);
      A(obj.b, 19, 0);
      A(obj.c, 286, 0);
      A(obj.e, 30, 0);
      A(obj.a, 320, 0);
    })();
    return function v(buffer) {
      let arr;
      let sum5;
      let tmp14;
      let _Uint8Array = arg1;
      _Uint8Array = Uint8Array;
      if (3 == buffer[0]) {
        if (0 == buffer[1]) {
          if (!_Uint8Array) {
            const prototype3 = _Uint8Array.prototype;
            _Uint8Array = new.target;
            _Uint8Array = new.target;
            _Uint8Array = new _Uint8Array(0);
          }
          return _Uint8Array;
        }
      }
      let _Uint8Array1 = _Uint8Array;
      if (null == _Uint8Array) {
        const prototype = _Uint8Array.prototype;
        _Uint8Array1 = new _Uint8Array(buffer.length >>> 2 << 3);
      }
      let num3 = 0;
      let num4 = 0;
      let num5 = 0;
      let num6 = 0;
      let num7 = 0;
      let num8 = 0;
      let num9 = 0;
      do {
        let tmp13 = s;
        tmp14 = s(buffer, num9, 1);
        let tmp15 = s(buffer, num9 + 1, 2);
        let sum = num9 + 3;
        if (0 !== tmp15) {
          let tmp41 = _Uint8Array1;
          if (tmp2) {
            let tmp42 = H;
            tmp41 = H(_Uint8Array1, num8 + 131072);
          }
          if (1 === tmp15) {
            let tmp43 = obj;
            let g = obj.g;
            let tmp44 = obj;
            let A = obj.A;
            num6 = 511;
            num7 = 31;
          }
          let tmp45 = tmp41;
          let sum2 = num8;
          let tmp47 = sum;
          let tmp48 = tmp8;
          let tmp49 = tmp9;
          let tmp50 = tmp10;
          if (2 === tmp15) {
            _Uint8Array = F;
            _Uint8Array = F(buffer, sum, 5) + 257;
            _Uint8Array = F(buffer, sum + 5, 5) + 1;
            _Uint8Array = F(buffer, sum + 10, 4) + 4;
            _Uint8Array = sum + 14;
            let num10 = 0;
            do {
              let tmp51 = obj;
              obj.b[num10] = 0;
              let tmp52 = obj;
              obj.b[num10 + 1] = 0;
              num10 = num10 + 2;
            } while (num10 < 38);
            let num11 = 1;
            let num12 = 0;
            let num13 = 1;
            let num14 = 0;
            if (0 < _Uint8Array) {
              do {
                let tmp53 = F;
                let tmp54 = F(buffer, _Uint8Array + 3 * num12, 3);
                let tmp55 = obj;
                let tmp56 = obj;
                obj.b[1 + (obj.d[num12] << 1)] = tmp54;
                if (tmp54 > num11) {
                  num11 = tmp54;
                }
                num12 = num12 + 1;
                num13 = num11;
                tmp8 = tmp54;
                num14 = num12;
              } while (num12 < _Uint8Array);
            }
            let tmp57 = C;
            let tmp58 = obj;
            let tmp59 = C(obj.b, num13);
            let tmp60 = t;
            let tmp61 = obj;
            let tmp62 = obj;
            let tmp63 = t(obj.b, num13, obj.C);
            let tmp64 = obj;
            let k = obj.k;
            let tmp65 = obj;
            let n = obj.n;
            let tmp66 = B;
            let tmp67 = obj;
            let tmp68 = obj;
            let tmp69 = buffer;
            tmp47 = B(obj.C, (1 << num13) - 1, _Uint8Array + _Uint8Array, buffer, _Uint8Array + 3 * _Uint8Array, obj.a);
            let tmp70 = d;
            let tmp71 = obj;
            let tmp72 = obj;
            let num15 = 0;
            let tmp73 = _Uint8Array;
            let tmp74 = d(obj.a, 0, _Uint8Array, obj.c);
            num6 = (1 << tmp74) - 1;
            let tmp75 = obj;
            let tmp76 = obj;
            let tmp77 = _Uint8Array;
            let tmp78 = _Uint8Array;
            let tmp79 = d(obj.a, _Uint8Array, _Uint8Array, obj.e);
            num7 = (1 << tmp79) - 1;
            let tmp80 = obj;
            let tmp81 = C(obj.c, tmp74);
            let tmp82 = obj;
            let tmp83 = t(obj.c, tmp74, k);
            let tmp84 = obj;
            let tmp85 = C(obj.e, tmp79);
            let tmp86 = obj;
            let tmp87 = t(obj.e, tmp79, n);
            let tmp6 = num13;
            let tmp7 = num14;
            tmp48 = tmp8;
            tmp45 = tmp41;
            g = k;
            A = n;
            num3 = _Uint8Array;
            num4 = _Uint8Array;
            num5 = _Uint8Array;
            sum2 = num8;
            tmp49 = tmp9;
            tmp50 = tmp10;
          }
          while (true) {
            let tmp88 = w;
            let tmp89 = g[w(undefined, buffer, tmp47) & num6];
            let sum1 = tmp47 + (15 & tmp89);
            let tmp91 = tmp89 >>> 4;
            let tmp92 = tmp45;
            _Uint8Array = sum2;
            _Uint8Array = tmp49;
            _Uint8Array = tmp50;
            if (tmp91 >>> 8 === 0) {
              _Uint8Array = +sum2;
              sum2 = _Uint8Array + 1;
              tmp45[_Uint8Array] = tmp91;
              tmp47 = sum1;
              continue;
            } else {
              arr = tmp45;
              let tmp28 = g;
              let tmp29 = A;
              let tmp30 = num3;
              let tmp31 = num4;
              let tmp32 = num5;
              let tmp33 = num6;
              let tmp34 = num7;
              sum5 = sum2;
              num9 = sum1;
              let tmp35 = tmp6;
              let tmp36 = tmp7;
              let tmp37 = tmp48;
              let tmp38 = tmp49;
              let tmp39 = tmp50;
              let sum4 = tmp11;
              let tmp40 = tmp12;
              _Uint8Array = tmp91;
              if (256 === tmp91) {
                break;
              } else {
                _Uint8Array = sum2 + tmp91 - 254;
                _Uint8Array = sum1;
                if (tmp91 > 264) {
                  _Uint8Array = obj;
                  _Uint8Array = obj.B[tmp91 - 257];
                  _Uint8Array = F;
                  _Uint8Array = sum2 + (_Uint8Array >>> 3);
                  _Uint8Array = _Uint8Array + F(buffer, sum1, 7 & _Uint8Array);
                  _Uint8Array = sum1 + (7 & _Uint8Array);
                }
                _Uint8Array = w;
                _Uint8Array = A[w(undefined, buffer, _Uint8Array) & num7];
                _Uint8Array = _Uint8Array + (15 & _Uint8Array);
                _Uint8Array = obj;
                _Uint8Array = obj.h[_Uint8Array >>> 4];
                _Uint8Array = s;
                _Uint8Array = _Uint8Array >>> 4;
                _Uint8Array = _Uint8Array + s(buffer, _Uint8Array, 15 & _Uint8Array);
                _Uint8Array = _Uint8Array + (15 & _Uint8Array);
                _Uint8Array = tmp45;
                if (tmp2) {
                  _Uint8Array = H;
                  _Uint8Array = H(tmp45, sum2 + 131072);
                }
                tmp45 = _Uint8Array;
                sum2 = _Uint8Array;
                tmp47 = _Uint8Array;
                tmp49 = _Uint8Array;
                tmp50 = _Uint8Array;
                if (_Uint8Array >= _Uint8Array) {
                  continue;
                } else {
                  do {
                    _Uint8Array = +_Uint8Array;
                    _Uint8Array = _Uint8Array + 1;
                    _Uint8Array[_Uint8Array] = _Uint8Array[_Uint8Array - _Uint8Array];
                    _Uint8Array = +_Uint8Array;
                    _Uint8Array = _Uint8Array + 1;
                    _Uint8Array[_Uint8Array] = _Uint8Array[_Uint8Array - _Uint8Array];
                    _Uint8Array = +_Uint8Array;
                    _Uint8Array = _Uint8Array + 1;
                    _Uint8Array[_Uint8Array] = _Uint8Array[_Uint8Array - _Uint8Array];
                    _Uint8Array = +_Uint8Array;
                    _Uint8Array = _Uint8Array + 1;
                    _Uint8Array[_Uint8Array] = _Uint8Array[_Uint8Array - _Uint8Array];
                    tmp45 = _Uint8Array;
                    g = tmp93;
                    A = tmp94;
                    num3 = tmp95;
                    num4 = tmp96;
                    num5 = tmp97;
                    num6 = tmp98;
                    num7 = tmp99;
                    sum2 = _Uint8Array;
                    tmp47 = _Uint8Array;
                    tmp6 = _Uint8Array;
                    tmp7 = _Uint8Array;
                    tmp48 = _Uint8Array;
                    tmp50 = _Uint8Array;
                    tmp49 = _Uint8Array;
                  } while (_Uint8Array < _Uint8Array);
                  continue;
                }
                continue;
              }
            }
          }
        } else {
          _Uint8Array = 7 & sum;
          let sum3 = sum;
          if (_Uint8Array) {
            sum3 = sum + (8 - _Uint8Array);
          }
          sum4 = 4 + (sum3 >>> 3);
          let tmp19 = buffer[sum4 - 4] | buffer[sum4 - 3] << 8;
          obj = _Uint8Array1;
          if (tmp2) {
            let tmp20 = H;
            obj = H(_Uint8Array1, num8 + tmp19);
          }
          let prototype2 = _Uint8Array.prototype;
          let tmp21 = new.target;
          let tmp22 = new.target;
          let tmp23 = tmp19;
          let _Uint8Array2 = new _Uint8Array(buffer.buffer, buffer.byteOffset + sum4, tmp19);
          let tmp25 = _Uint8Array2;
          let result = obj.set(_Uint8Array2, num8);
          num9 = sum4 + tmp19 << 3;
          sum5 = num8 + tmp19;
          arr = obj;
          tmp28 = g;
          tmp29 = A;
          tmp30 = num3;
          tmp31 = num4;
          tmp32 = num5;
          tmp33 = num6;
          tmp34 = num7;
          tmp35 = tmp6;
          tmp36 = tmp7;
          tmp37 = tmp8;
          tmp38 = tmp9;
          tmp39 = tmp10;
          tmp40 = tmp19;
        }
        g = tmp28;
        A = tmp29;
        num3 = tmp30;
        num4 = tmp31;
        num5 = tmp32;
        num6 = tmp33;
        num7 = tmp34;
        tmp6 = tmp35;
        tmp7 = tmp36;
        tmp8 = tmp37;
        tmp9 = tmp38;
        tmp10 = tmp39;
        tmp11 = sum4;
        tmp12 = tmp40;
        _Uint8Array1 = arr;
        num8 = sum5;
      } while (0 === tmp14);
      _Uint8Array = arr;
      if (arr.length != sum5) {
        _Uint8Array = arr.slice(0, sum5);
      }
      return _Uint8Array;
    };
  })();
  obj = {
    decode(arg0) {
      let obj;
      let readUint;
      let readUshort;
      const uint8Array = new Uint8Array(arg0);
      let sum = uint8Array;
      const arr3 = uint8Array;
      let num = 8;
      ({ readUshort, readUint } = obj);
      const size = { tabs: {}, frames: [] };
      const uint8Array1 = new Uint8Array(uint8Array.length);
      let num2 = 0;
      while (arr3[num2] == [137, 80, 78, 71, 13, 10, 26, 10][num2]) {
        sum = num2 + 1;
        num2 = sum;
        if (sum < 8) {
          continue;
        } else {
          let tmp6 = num;
          let tmp7 = sum;
          let num3 = 4;
          let num4 = 1;
          let num5 = 2;
          let tmp8 = null;
          let num6 = 1000;
          let num7 = 24;
          let num8 = 25;
          let num9 = 12;
          let num10 = 16;
          let num11 = 22;
          let num12 = 20;
          let num13 = 100;
          let str = "tEXt";
          let num14 = 3;
          let num15 = 100000;
          let num16 = 6;
          let str2 = "IEND";
          let str3 = "bKGD";
          let str4 = "sRGB";
          let str5 = "gAMA";
          let str6 = "tRNS";
          let str7 = "hIST";
          let str8 = "PLTE";
          let str9 = "iTXt";
          let str10 = "zTXt";
          let str11 = "cHRM";
          let str12 = "pHYs";
          let str13 = "fdAT";
          let str14 = "fcTL";
          let str15 = "acTL";
          let str16 = "IDAT";
          let str17 = "CgBI";
          let str18 = "iCCP";
          let str19 = "IHDR";
          let num17 = 0;
          let num18 = 0;
          let num19 = 0;
          if (num < arr3.length) {
            while (true) {
              let tmp15 = tmp2;
              let tmp16 = sum;
              let tmp17 = num;
              let uint = obj.readUint(arr3, num);
              let sum1 = num + 4;
              let tmp20 = sum1;
              let aSCII = obj.readASCII(arr3, sum1, 4);
              let tmp22 = aSCII;
              let sum2 = sum1 + 4;
              if ("IHDR" == aSCII) {
                sum = _IHDR;
                sum = sum2;
                sum = size;
                sum = _IHDR(arr3, sum2, tmp3);
                let uint8Array2 = arr4;
                let sum3 = num17;
                let sum4 = num18;
                let num20 = sum;
                let tmp28 = tmp9;
                let tmp29 = tmp10;
                let tmp30 = tmp11;
                let tmp31 = tmp12;
                let tmp32 = tmp13;
                let tmp33 = tmp14;
              } else {
                sum = aSCII;
                if ("iCCP" == tmp22) {
                  sum = sum2;
                  sum = sum2;
                  if (0 != arr3[sum2]) {
                    do {
                      sum = sum + 1;
                      sum = arr3[sum];
                    } while (0 != sum);
                  }
                  sum = tmp2;
                  sum = sum2;
                  sum = obj.readASCII(arr3, sum2, sum - sum2);
                  sum = arr3[sum + 1];
                  sum = uint;
                  sum = arr3.slice(sum + 2, sum2 + uint);
                  sum = null;
                  sum = _inflate;
                  sum = _inflate(sum);
                  sum = size;
                  sum = aSCII;
                  tmp3.tabs[tmp22] = sum;
                  uint8Array2 = arr4;
                  sum3 = num17;
                  sum4 = num18;
                  num20 = sum;
                  tmp28 = tmp9;
                  tmp29 = tmp10;
                  tmp30 = tmp11;
                  tmp31 = tmp12;
                  tmp32 = tmp13;
                  tmp33 = tmp14;
                } else {
                  sum = aSCII;
                  if ("CgBI" == tmp22) {
                    sum = size;
                    sum = aSCII;
                    sum = sum2;
                    tmp3.tabs[tmp22] = arr3.slice(sum2, sum2 + 4);
                    uint8Array2 = arr4;
                    sum3 = num17;
                    sum4 = num18;
                    num20 = sum;
                    tmp28 = tmp9;
                    tmp29 = tmp10;
                    tmp30 = tmp11;
                    tmp31 = tmp12;
                    tmp32 = tmp13;
                    tmp33 = tmp14;
                  } else {
                    sum = aSCII;
                    if ("IDAT" == tmp22) {
                      sum = uint;
                      let num27 = 0;
                      let num28 = 0;
                      if (0 < uint) {
                        do {
                          sum = sum2;
                          uint8Array1[num17 + num27] = arr3[sum2 + num27];
                          num27 = num27 + 1;
                          sum = uint;
                          num28 = num27;
                        } while (num27 < uint);
                      }
                      sum = uint;
                      sum3 = num17 + uint;
                      num20 = num28;
                      uint8Array2 = arr4;
                      sum4 = num18;
                      tmp28 = tmp9;
                      tmp29 = tmp10;
                      tmp30 = tmp11;
                      tmp31 = tmp12;
                      tmp32 = tmp13;
                      tmp33 = tmp14;
                    } else {
                      sum = aSCII;
                      if ("acTL" == tmp22) {
                        sum = size;
                        sum = aSCII;
                        obj = {};
                        sum = sum2;
                        obj.num_frames = readUint(arr3, sum2);
                        obj.num_plays = readUint(arr3, sum2 + 4);
                        tmp3.tabs[tmp22] = obj;
                        let _Uint8Array = Uint8Array;
                        sum = new.target;
                        sum = new.target;
                        uint8Array2 = new Uint8Array(arr3.length);
                        sum3 = num17;
                        sum4 = num18;
                        num20 = sum;
                        tmp28 = tmp9;
                        tmp29 = tmp10;
                        tmp30 = tmp11;
                        tmp31 = tmp12;
                        tmp32 = tmp13;
                        tmp33 = tmp14;
                      } else {
                        sum = aSCII;
                        if ("fcTL" == tmp22) {
                          let num25 = num18;
                          if (0 != num18) {
                            sum = size;
                            sum = tmp3.frames[tmp3.frames.length - 1];
                            sum = _decompress;
                            sum = tmp3;
                            sum.data = _decompress(size, arr4.slice(0, num18), sum.rect.width, sum.rect.height);
                            num25 = 0;
                          }
                          obj = {};
                          sum = sum2;
                          obj.x = readUint(arr3, sum2 + 12);
                          obj.y = readUint(arr3, sum2 + 16);
                          obj.width = readUint(arr3, sum2 + 4);
                          obj.height = readUint(arr3, sum2 + 8);
                          sum = readUshort(arr3, sum2 + 22);
                          let obj1 = { rect: obj };
                          let num26 = 100;
                          sum = readUshort(arr3, sum2 + 20);
                          if (0 != sum) {
                            num26 = sum;
                          }
                          sum = sum / num26;
                          obj1.delay = 1000 * sum;
                          sum = sum2;
                          obj1.dispose = arr3[sum2 + 24];
                          obj1.blend = arr3[sum2 + 25];
                          sum = size;
                          let frames = tmp3.frames;
                          sum = frames.push(obj1);
                          uint8Array2 = arr4;
                          sum3 = num17;
                          sum4 = num25;
                          num20 = sum;
                          tmp28 = sum;
                          tmp29 = tmp10;
                          tmp30 = tmp11;
                          tmp31 = tmp12;
                          tmp32 = tmp13;
                          tmp33 = tmp14;
                        } else {
                          sum = aSCII;
                          if ("fdAT" == tmp22) {
                            sum = uint;
                            let num23 = 0;
                            let num24 = 0;
                            if (0 < uint - 4) {
                              do {
                                sum = sum2;
                                arr4[num18 + num23] = arr3[sum2 + num23 + 4];
                                num23 = num23 + 1;
                                sum = uint;
                                num24 = num23;
                                sum = uint - 4;
                              } while (num23 < sum);
                            }
                            sum = uint;
                            sum4 = num18 + (uint - 4);
                            num20 = num24;
                            uint8Array2 = arr4;
                            sum3 = num17;
                            tmp28 = tmp9;
                            tmp29 = tmp10;
                            tmp30 = tmp11;
                            tmp31 = tmp12;
                            tmp32 = tmp13;
                            tmp33 = tmp14;
                          } else {
                            sum = aSCII;
                            if ("pHYs" == tmp22) {
                              sum = size;
                              sum = aSCII;
                              sum = tmp2;
                              sum = sum2;
                              let items = [obj.readUint(arr3, sum2), obj.readUint(arr3, sum2 + 4), arr3[sum2 + 8]];
                              tmp3.tabs[tmp22] = items;
                              uint8Array2 = arr4;
                              sum3 = num17;
                              sum4 = num18;
                              num20 = sum;
                              tmp28 = tmp9;
                              tmp29 = tmp10;
                              tmp30 = tmp11;
                              tmp31 = tmp12;
                              tmp32 = tmp13;
                              tmp33 = tmp14;
                            } else {
                              sum = aSCII;
                              if ("cHRM" == tmp22) {
                                sum = size;
                                sum = aSCII;
                                tmp3.tabs[tmp22] = [];
                                let num22 = 0;
                                do {
                                  sum = size;
                                  sum = aSCII;
                                  let arr11 = tmp3.tabs[tmp22];
                                  sum = tmp2;
                                  sum = sum2;
                                  sum = arr11.push(obj.readUint(arr3, sum2 + 4 * num22));
                                  num22 = num22 + 1;
                                  uint8Array2 = arr4;
                                  sum3 = num17;
                                  sum4 = num18;
                                  tmp28 = tmp9;
                                  tmp29 = tmp10;
                                  tmp30 = tmp11;
                                  tmp31 = tmp12;
                                  tmp32 = tmp13;
                                  tmp33 = tmp14;
                                  num20 = num22;
                                } while (num22 < 8);
                              } else {
                                sum = aSCII;
                                if ("tEXt" != tmp22) {
                                  sum = aSCII;
                                  if ("zTXt" != tmp22) {
                                    sum = aSCII;
                                    if ("iTXt" == tmp22) {
                                      let tmp79 = size;
                                      let tmp80 = aSCII;
                                      if (null == tmp3.tabs[tmp22]) {
                                        let tmp81 = size;
                                        let tmp82 = aSCII;
                                        tmp3.tabs[tmp22] = {};
                                      }
                                      let tmp83 = sum2;
                                      let tmp84 = sum2;
                                      let tmp85 = tmp2;
                                      let tmp86 = sum;
                                      let nextZeroResult = obj.nextZero(arr3, sum2);
                                      let aSCII1 = obj.readASCII(arr3, sum2, nextZeroResult - sum2);
                                      let sum5 = nextZeroResult + 1;
                                      let tmp90 = sum5;
                                      let tmp91 = arr3[sum5 + 1];
                                      let sum6 = sum5 + 2;
                                      let tmp93 = sum6;
                                      let nextZeroResult1 = obj.nextZero(arr3, sum6);
                                      let aSCII2 = obj.readASCII(arr3, sum6, nextZeroResult1 - sum6);
                                      let sum7 = nextZeroResult1 + 1;
                                      let tmp97 = sum7;
                                      let nextZeroResult2 = obj.nextZero(arr3, sum7);
                                      let uTF8 = obj.readUTF8(arr3, sum7, nextZeroResult2 - sum7);
                                      sum = uint;
                                      sum = nextZeroResult2 + 1;
                                      sum = uint - (sum - sum2);
                                      if (0 == arr3[sum5]) {
                                        sum = tmp2;
                                        sum = obj.readUTF8(arr3, sum, sum);
                                      } else {
                                        sum = _inflate;
                                        let arr9 = _inflate(arr3.slice(sum, sum + sum));
                                        sum = tmp2;
                                        sum = obj.readUTF8(arr9, 0, arr9.length);
                                      }
                                      sum = size;
                                      sum = aSCII;
                                      tmp3.tabs[tmp22][aSCII1] = sum;
                                      tmp32 = sum;
                                      uint8Array2 = arr4;
                                      sum3 = num17;
                                      sum4 = num18;
                                      num20 = sum;
                                      tmp28 = tmp9;
                                      tmp29 = nextZeroResult2;
                                      tmp30 = aSCII1;
                                      tmp31 = sum;
                                      tmp33 = tmp14;
                                    } else {
                                      sum = aSCII;
                                      if ("PLTE" == tmp22) {
                                        let tmp73 = size;
                                        let tmp74 = aSCII;
                                        let tmp75 = tmp2;
                                        let tmp76 = sum;
                                        let tmp77 = sum2;
                                        let tmp78 = uint;
                                        tmp3.tabs[tmp22] = obj.readBytes(arr3, sum2, uint);
                                        uint8Array2 = arr4;
                                        sum3 = num17;
                                        sum4 = num18;
                                        num20 = sum;
                                        tmp28 = tmp9;
                                        tmp29 = tmp10;
                                        tmp30 = tmp11;
                                        tmp31 = tmp12;
                                        tmp32 = tmp13;
                                        tmp33 = tmp14;
                                      } else {
                                        sum = aSCII;
                                        if ("hIST" == tmp22) {
                                          let tmp65 = size;
                                          let result = tmp3.tabs.PLTE.length / 3;
                                          let tmp67 = aSCII;
                                          tmp3.tabs[tmp22] = [];
                                          let num21 = 0;
                                          uint8Array2 = arr4;
                                          sum3 = num17;
                                          sum4 = num18;
                                          num20 = 0;
                                          tmp28 = tmp9;
                                          tmp29 = tmp10;
                                          tmp30 = tmp11;
                                          tmp31 = tmp12;
                                          tmp32 = tmp13;
                                          tmp33 = result;
                                          if (0 < result) {
                                            do {
                                              let tmp68 = size;
                                              let tmp69 = aSCII;
                                              let arr8 = tmp3.tabs[tmp22];
                                              let tmp70 = sum;
                                              let tmp71 = sum2;
                                              let arr = arr8.push(readUshort(arr3, sum2 + 2 * num21));
                                              num21 = num21 + 1;
                                              uint8Array2 = arr4;
                                              sum3 = num17;
                                              sum4 = num18;
                                              tmp28 = tmp9;
                                              tmp29 = tmp10;
                                              tmp30 = tmp11;
                                              tmp31 = tmp12;
                                              tmp32 = tmp13;
                                              tmp33 = result;
                                              num20 = num21;
                                            } while (num21 < result);
                                          }
                                        } else {
                                          sum = aSCII;
                                          if ("tRNS" == tmp22) {
                                            let tmp54 = size;
                                            if (3 == tmp3.ctype) {
                                              let tmp59 = size;
                                              let tmp60 = aSCII;
                                              let tmp61 = tmp2;
                                              let tmp62 = sum;
                                              let tmp63 = sum2;
                                              let tmp64 = uint;
                                              tmp3.tabs[tmp22] = obj.readBytes(arr3, sum2, uint);
                                              uint8Array2 = arr4;
                                              sum3 = num17;
                                              sum4 = num18;
                                              num20 = sum;
                                              tmp28 = tmp9;
                                              tmp29 = tmp10;
                                              tmp30 = tmp11;
                                              tmp31 = tmp12;
                                              tmp32 = tmp13;
                                              tmp33 = tmp14;
                                            } else {
                                              sum = size;
                                              if (0 == tmp3.ctype) {
                                                let tmp55 = size;
                                                let tmp56 = aSCII;
                                                let tmp57 = sum;
                                                let tmp58 = sum2;
                                                tmp3.tabs[tmp22] = readUshort(arr3, sum2);
                                                uint8Array2 = arr4;
                                                sum3 = num17;
                                                sum4 = num18;
                                                num20 = sum;
                                                tmp28 = tmp9;
                                                tmp29 = tmp10;
                                                tmp30 = tmp11;
                                                tmp31 = tmp12;
                                                tmp32 = tmp13;
                                                tmp33 = tmp14;
                                              } else {
                                                sum = size;
                                                uint8Array2 = arr4;
                                                sum3 = num17;
                                                sum4 = num18;
                                                num20 = sum;
                                                tmp28 = tmp9;
                                                tmp29 = tmp10;
                                                tmp30 = tmp11;
                                                tmp31 = tmp12;
                                                tmp32 = tmp13;
                                                tmp33 = tmp14;
                                                if (2 == tmp3.ctype) {
                                                  sum = size;
                                                  sum = aSCII;
                                                  sum = sum2;
                                                  let items1 = [readUshort(arr3, sum2), readUshort(arr3, sum2 + 2), readUshort(arr3, sum2 + 4)];
                                                  tmp3.tabs[tmp22] = items1;
                                                  uint8Array2 = arr4;
                                                  sum3 = num17;
                                                  sum4 = num18;
                                                  num20 = sum;
                                                  tmp28 = tmp9;
                                                  tmp29 = tmp10;
                                                  tmp30 = tmp11;
                                                  tmp31 = tmp12;
                                                  tmp32 = tmp13;
                                                  tmp33 = tmp14;
                                                }
                                              }
                                            }
                                          } else {
                                            sum = aSCII;
                                            if ("gAMA" == tmp22) {
                                              let tmp49 = size;
                                              let tmp50 = aSCII;
                                              let tmp51 = tmp2;
                                              let tmp52 = sum;
                                              let tmp53 = sum2;
                                              tmp3.tabs[tmp22] = obj.readUint(arr3, sum2) / 100000;
                                              uint8Array2 = arr4;
                                              sum3 = num17;
                                              sum4 = num18;
                                              num20 = sum;
                                              tmp28 = tmp9;
                                              tmp29 = tmp10;
                                              tmp30 = tmp11;
                                              tmp31 = tmp12;
                                              tmp32 = tmp13;
                                              tmp33 = tmp14;
                                            } else {
                                              sum = aSCII;
                                              if ("sRGB" == tmp22) {
                                                let tmp45 = size;
                                                let tmp46 = aSCII;
                                                let tmp47 = sum;
                                                let tmp48 = sum2;
                                                tmp3.tabs[tmp22] = arr3[sum2];
                                                uint8Array2 = arr4;
                                                sum3 = num17;
                                                sum4 = num18;
                                                num20 = sum;
                                                tmp28 = tmp9;
                                                tmp29 = tmp10;
                                                tmp30 = tmp11;
                                                tmp31 = tmp12;
                                                tmp32 = tmp13;
                                                tmp33 = tmp14;
                                              } else {
                                                sum = aSCII;
                                                if ("bKGD" == tmp22) {
                                                  let tmp34 = size;
                                                  if (0 != tmp3.ctype) {
                                                    sum = size;
                                                    if (4 != tmp3.ctype) {
                                                      sum = size;
                                                      if (2 != tmp3.ctype) {
                                                        let tmp35 = size;
                                                        if (6 != tmp3.ctype) {
                                                          let tmp36 = size;
                                                          uint8Array2 = arr4;
                                                          sum3 = num17;
                                                          sum4 = num18;
                                                          num20 = sum;
                                                          tmp28 = tmp9;
                                                          tmp29 = tmp10;
                                                          tmp30 = tmp11;
                                                          tmp31 = tmp12;
                                                          tmp32 = tmp13;
                                                          tmp33 = tmp14;
                                                          if (3 == tmp3.ctype) {
                                                            sum = size;
                                                            sum = aSCII;
                                                            sum = sum2;
                                                            tmp3.tabs[tmp22] = arr3[sum2];
                                                            uint8Array2 = arr4;
                                                            sum3 = num17;
                                                            sum4 = num18;
                                                            num20 = sum;
                                                            tmp28 = tmp9;
                                                            tmp29 = tmp10;
                                                            tmp30 = tmp11;
                                                            tmp31 = tmp12;
                                                            tmp32 = tmp13;
                                                            tmp33 = tmp14;
                                                          }
                                                        }
                                                      }
                                                      let tmp37 = size;
                                                      let tmp38 = aSCII;
                                                      let tmp39 = sum;
                                                      let tmp40 = sum2;
                                                      let items2 = [readUshort(arr3, sum2), readUshort(arr3, sum2 + 2), readUshort(arr3, sum2 + 4)];
                                                      tmp3.tabs[tmp22] = items2;
                                                      uint8Array2 = arr4;
                                                      sum3 = num17;
                                                      sum4 = num18;
                                                      num20 = sum;
                                                      tmp28 = tmp9;
                                                      tmp29 = tmp10;
                                                      tmp30 = tmp11;
                                                      tmp31 = tmp12;
                                                      tmp32 = tmp13;
                                                      tmp33 = tmp14;
                                                    }
                                                  }
                                                  let tmp41 = size;
                                                  let tmp42 = aSCII;
                                                  let tmp43 = sum;
                                                  let tmp44 = sum2;
                                                  let items3 = [readUshort(arr3, sum2)];
                                                  tmp3.tabs[tmp22] = items3;
                                                  uint8Array2 = arr4;
                                                  sum3 = num17;
                                                  sum4 = num18;
                                                  num20 = sum;
                                                  tmp28 = tmp9;
                                                  tmp29 = tmp10;
                                                  tmp30 = tmp11;
                                                  tmp31 = tmp12;
                                                  tmp32 = tmp13;
                                                  tmp33 = tmp14;
                                                } else {
                                                  let tmp24 = aSCII;
                                                  uint8Array2 = arr4;
                                                  sum3 = num17;
                                                  sum4 = num18;
                                                  num20 = sum;
                                                  tmp28 = tmp9;
                                                  tmp29 = tmp10;
                                                  tmp30 = tmp11;
                                                  tmp31 = tmp12;
                                                  tmp32 = tmp13;
                                                  tmp33 = tmp14;
                                                  let arr5 = arr4;
                                                  num19 = num18;
                                                  if ("IEND" == tmp22) {
                                                    break;
                                                  }
                                                }
                                                break;
                                              }
                                              break;
                                            }
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                                sum = size;
                                sum = aSCII;
                                if (null == tmp3.tabs[tmp22]) {
                                  sum = size;
                                  sum = aSCII;
                                  tmp3.tabs[tmp22] = {};
                                }
                                sum = tmp2;
                                sum = sum2;
                                sum = obj.nextZero(arr3, sum2);
                                sum = obj.readASCII(arr3, sum2, sum - sum2);
                                sum = uint;
                                sum = sum2 + uint - sum - 1;
                                sum = aSCII;
                                if ("tEXt" == tmp22) {
                                  sum = tmp2;
                                  sum = obj.readASCII(arr3, sum + 1, sum);
                                } else {
                                  sum = _inflate;
                                  let arr10 = _inflate(arr3.slice(sum + 2, sum + 2 + sum));
                                  sum = tmp2;
                                  sum = obj.readUTF8(arr10, 0, arr10.length);
                                }
                                sum = size;
                                sum = aSCII;
                                tmp3.tabs[tmp22][sum] = sum;
                                tmp32 = sum;
                                uint8Array2 = arr4;
                                sum3 = num17;
                                sum4 = num18;
                                num20 = sum;
                                tmp28 = tmp9;
                                tmp29 = sum;
                                tmp30 = sum;
                                tmp31 = sum;
                                tmp33 = tmp14;
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
              sum = sum2;
              sum = uint;
              sum = sum2 + uint;
              sum = tmp2;
              sum = obj.readUint(arr3, sum);
              sum = sum + 4;
              num = sum;
              arr4 = uint8Array2;
              num17 = sum3;
              num18 = sum4;
              sum = num20;
              tmp9 = tmp28;
              tmp10 = tmp29;
              tmp11 = tmp30;
              tmp12 = tmp31;
              tmp13 = tmp32;
              tmp14 = tmp33;
              arr5 = uint8Array2;
              num19 = sum4;
              if (sum >= arr3.length) {
                break;
              }
            }
          }
          if (0 != num19) {
            sum = size;
            sum = tmp3.frames[tmp3.frames.length - 1];
            sum = _decompress;
            sum = tmp3;
            sum.data = _decompress(size, arr5.slice(0, num19), sum.rect.width, sum.rect.height);
          }
          sum = _decompress;
          sum = size;
          sum = uint8Array1;
          size.data = _decompress(tmp3, tmp5, size.width, size.height);
          delete arr.compress;
          delete arr.interlace;
          delete arr.filter;
          return size;
        }
      }
      throw "The input is not a PNG file!";
    },
    toRGBA8(img) {
      let height;
      let width;
      ({ width, height } = img);
      if (null == img.tabs.acTL) {
        const items = [decodeImage(img.data, width, height, img).buffer];
        return items;
      } else {
        const items1 = [];
        if (null == img.frames[0].data) {
          img.frames[0].data = img.data;
        }
        const result = width * height * 4;
        const _Uint8Array = Uint8Array;
        const uint8Array = new Uint8Array(result);
        const _Uint8Array2 = Uint8Array;
        const uint8Array1 = new Uint8Array(result);
        const _Uint8Array3 = Uint8Array;
        const uint8Array2 = new Uint8Array(result);
        let num4 = 0;
        if (0 < img.frames.length) {
          do {
            let tmp18 = img.frames[num4];
            let x = tmp18.rect.x;
            let y = tmp18.rect.y;
            let width2 = tmp18.rect.width;
            let height2 = tmp18.rect.height;
            let tmp19 = decodeImage;
            let tmp20 = width2;
            let tmp21 = height2;
            let tmp22 = img;
            let tmp23 = decodeImage(tmp18.data, width2, height2, img);
            if (0 != num4) {
              let num6 = 0;
              let num5 = 0;
              if (0 < result) {
                do {
                  uint8Array2[num6] = uint8Array[num6];
                  num6 = num6 + 1;
                  num5 = num6;
                } while (num6 < result);
              }
            }
            if (0 == tmp18.blend) {
              let tmp34 = _copyTile;
              let tmp35 = tmp23;
              let tmp36 = width2;
              let tmp37 = height2;
              let tmp38 = uint8Array;
              let tmp39 = width;
              let tmp40 = height;
              let tmp41 = x;
              let tmp42 = y;
              let num8 = 0;
              let tmp43 = _copyTile(tmp23, width2, height2, tmp7, width, height, x, y, 0);
            } else if (1 == tmp18.blend) {
              let tmp24 = _copyTile;
              let tmp25 = tmp23;
              let tmp26 = width2;
              let tmp27 = height2;
              let tmp28 = uint8Array;
              let tmp29 = width;
              let tmp30 = height;
              let tmp31 = x;
              let tmp32 = y;
              let num7 = 1;
              let tmp33 = _copyTile(tmp23, width2, height2, tmp7, width, height, x, y, 1);
            }
            let buffer = uint8Array.buffer;
            let arr = items1.push(buffer.slice(0));
            let num9 = num5;
            if (0 != tmp18.dispose) {
              if (1 == tmp18.dispose) {
                let tmp45 = _copyTile;
                let tmp46 = uint8Array1;
                let tmp47 = width2;
                let tmp48 = height2;
                let tmp49 = uint8Array;
                let tmp50 = width;
                let tmp51 = height;
                let tmp52 = x;
                let tmp53 = y;
                let num11 = 0;
                let tmp54 = _copyTile(tmp12, width2, height2, tmp7, width, height, x, y, 0);
                num9 = num5;
              } else {
                num9 = num5;
                if (2 == tmp18.dispose) {
                  let num10 = 0;
                  num9 = 0;
                  if (0 < result) {
                    do {
                      uint8Array[num10] = uint8Array2[num10];
                      num10 = num10 + 1;
                      num9 = num10;
                    } while (num10 < result);
                  }
                }
              }
            }
            num4 = num4 + 1;
            num5 = num9;
          } while (num4 < img.frames.length);
        }
        return items1;
      }
    },
    _paeth,
    _copyTile,
    _bin: obj
  };
  return obj;
})();
let closure_0 = tmp;
(() => {
  let closure_0;
  let closure_1;
  let closure_2;
  function addErr(items5, arg1, arg2, arg3) {
    arg1[arg2] = arg1[arg2] + (items5[0] * arg3 >> 4);
    const sum = arg2 + 1;
    arg1[sum] = arg1[sum] + (items5[1] * arg3 >> 4);
    const sum1 = arg2 + 2;
    arg1[sum1] = arg1[sum1] + (items5[2] * arg3 >> 4);
    const sum2 = arg2 + 3;
    arg1[sum2] = arg1[sum2] + (items5[3] * arg3 >> 4);
  }
  function N(arg0) {
    return Math.max(0, Math.min(255, arg0));
  }
  function D(arg0, arg1) {
    const diff = arg0[0] - arg1[0];
    const diff1 = arg0[1] - arg1[1];
    const diff2 = arg0[2] - arg1[2];
    const diff3 = arg0[3] - arg1[3];
    return diff * diff + diff1 * diff1 + diff2 * diff2 + diff3 * diff3;
  }
  function dither(img, width, height, items1, first, first2) {
    let length2;
    let num = arg6;
    if (null == arg6) {
      num = 1;
    }
    const items = [];
    for (let num2 = 0; num2 < length; num2 = num2 + 1) {
      let tmp = items1[num2];
      items1 = [tmp >>> 0 & 255, tmp >>> 8 & 255, tmp >>> 16 & 255, tmp >>> 24 & 255];
      let arr = items.push(items1);
    }
    let num3 = 0;
    if (0 < items1.length) {
      do {
        let num4 = 4294967295;
        let num5 = 0;
        let num6 = 0;
        let num7 = 4294967295;
        let num8 = 0;
        let num9 = 0;
        if (0 < length) {
          do {
            let tmp5 = D;
            let tmp6 = D(items[num3], items[num6]);
            let tmp7 = num6 != num3 && tmp6 < num4;
            if (tmp7) {
              num4 = tmp6;
              num5 = num6;
            }
            num6 = num6 + 1;
            num7 = num4;
            num8 = num5;
            let tmp3 = tmp6;
            num9 = num6;
          } while (num6 < length);
        }
        let _Math = Math;
        let result = Math.sqrt(num7) / 2;
        [][num3] = ~~result * result;
        num3 = num3 + 1;
        let tmp9 = num8;
        let tmp10 = num9;
        let tmp4 = tmp3;
      } while (num3 < length);
    }
    const uint32Array = new Uint32Array(first.buffer);
    const int16Array = new Int16Array(width * height * 4);
    const items2 = [0, 8, 2, 10, 12, 4, 14, 6, 3, 11, 1, 9, 15, 7, 13, 5];
    let num10 = 0;
    if (0 < items2.length) {
      do {
        items2[num10] = 255 * ((items2[num10] + 0.5) / 16 - 0.5);
        num10 = num10 + 1;
        let tmp14 = num10;
        length2 = items2.length;
      } while (num10 < length2);
    }
    for (let num11 = 0; num11 < height; num11 = num11 + 1) {
      let tmp16 = tmp4;
      let tmp17 = tmp15;
      let num12 = 0;
      if (0 < width) {
        do {
          let result1 = 4 * (num11 * width + num12);
          if (2 != num) {
            let tmp21 = N;
            let items3 = [N(img[result1] + int16Array[result1]), , , ];
            let sum = result1 + 1;
            items3[1] = N(img[sum] + int16Array[sum]);
            let sum1 = result1 + 2;
            items3[2] = N(img[sum1] + int16Array[sum1]);
            let sum2 = result1 + 3;
            items3[3] = N(img[sum2] + int16Array[sum2]);
            let tmp19 = tmp16;
            let items4 = items3;
          } else {
            tmp19 = items2[4 * (3 & num11) + (3 & num12)];
            let tmp20 = N;
            items4 = [N(img[result1] + tmp19), N(img[result1 + 1] + tmp19), N(img[result1 + 2] + tmp19), N(img[result1 + 3] + tmp19)];
          }
          let num13 = 0;
          let num14 = 0;
          let num15 = 16777215;
          let num16 = 0;
          let num17 = 0;
          let num18 = 16777215;
          if (0 < length) {
            do {
              let tmp25 = D;
              let tmp26 = D(items4, items[num14]);
              if (tmp26 < num15) {
                num13 = num14;
                num15 = tmp26;
              }
              num14 = num14 + 1;
              num16 = num13;
              num18 = num15;
              tmp17 = tmp26;
              num17 = num14;
            } while (num14 < length);
          }
          let tmp27 = items[num16];
          let items5 = [items4[0] - tmp27[0], items4[1] - tmp27[1], items4[2] - tmp27[2], items4[3] - tmp27[3]];
          let tmp28 = tmp17;
          if (1 == num) {
            if (num12 != width - 1) {
              let tmp29 = addErr;
              let tmp30 = items5;
              let tmp31 = int16Array;
              let num19 = 7;
              let tmp32 = addErr(items5, tmp13, result1 + 4, 7);
            }
            if (num11 != height - 1) {
              if (0 != num12) {
                let tmp33 = addErr;
                let tmp34 = items5;
                let tmp35 = int16Array;
                let num20 = 3;
                let tmp36 = addErr(items5, tmp13, result1 + 4 * width - 4, 3);
              }
              let tmp37 = addErr;
              let tmp38 = items5;
              let tmp39 = int16Array;
              let num21 = 5;
              let tmp40 = addErr(items5, tmp13, result1 + 4 * width, 5);
              if (num12 != width - 1) {
                let tmp41 = addErr;
                let tmp42 = items5;
                let tmp43 = int16Array;
                let num22 = 1;
                let tmp44 = addErr(items5, tmp13, result1 + 4 * width + 4, 1);
              }
            }
          }
          let tmp45 = result1 >> 2;
          first2[tmp45] = num16;
          uint32Array[tmp45] = items1[num16];
          num12 = num12 + 1;
          tmp16 = tmp19;
          let tmp46 = result1;
          let tmp47 = num16;
          let tmp48 = num17;
          tmp4 = tmp19;
          let tmp49 = items4;
          let tmp50 = num18;
          tmp15 = tmp17;
          let tmp51 = items5;
        } while (num12 < width);
      }
    }
  }
  function _main(frames, height, height) {
    let obj = arg4;
    if (null == arg4) {
      obj = {};
    }
    crc = crc.crc;
    const writeUint = closure_1.writeUint;
    const writeUshort = closure_1.writeUshort;
    const writeASCII = closure_1.writeASCII;
    let writeUintResult16 = frames.frames.length > 1;
    let num = 0;
    if (writeUintResult16) {
      num = 20;
    }
    const sum = 33 + num;
    let sum1 = sum;
    if (null != obj.sRGB) {
      sum1 = sum + 13;
    }
    let sum2 = sum1;
    if (null != obj.pHYs) {
      sum2 = sum1 + 21;
    }
    let sum3 = sum2;
    if (null != obj.iCCP) {
      const deflateResult = globalThis.pako.deflate(obj.iCCP);
      sum3 = sum2 + (21 + deflateResult.length + 4);
    }
    let flag = false;
    let sum4 = sum3;
    if (3 == frames.ctype) {
      let flag2 = false;
      let num8 = 0;
      let flag3 = false;
      if (0 < frames.plte.length) {
        do {
          if (frames.plte[num8] >>> 24 !== 255) {
            flag2 = true;
          }
          num8 = num8 + 1;
          flag3 = flag2;
        } while (num8 < length);
      }
      let num9 = 0;
      const result = 3 * length;
      if (flag3) {
        num9 = 8 + length + 4;
      }
      sum4 = sum3 + (8 + result + 4 + num9);
      flag = flag3;
    }
    let tmp9 = sum4;
    let num14 = 0;
    let tmp10 = sum4;
    if (0 < frames.frames.length) {
      do {
        let sum5 = tmp9;
        if (writeUintResult16) {
          sum5 = tmp9 + 38;
        }
        let sum6 = sum5 + (frames.frames[num14].cimg.length + 12);
        let sum7 = sum6;
        if (0 != num14) {
          sum7 = sum6 + 4;
        }
        num14 = num14 + 1;
        tmp9 = sum7;
        tmp10 = sum7;
      } while (num14 < frames.frames.length);
    }
    const uint8Array = new Uint8Array(tmp10 + 12);
    let num15 = 0;
    do {
      uint8Array[num15] = [137, 80, 78, 71, 13, 10, 26, 10][num15];
      num15 = num15 + 1;
    } while (num15 < 8);
    writeUint(uint8Array, 8, 13);
    writeASCII(uint8Array, 12, "IHDR");
    writeUint(uint8Array, 16, height);
    writeUint(uint8Array, 20, height);
    uint8Array[24] = frames.depth;
    uint8Array[25] = frames.ctype;
    uint8Array[26] = 0;
    uint8Array[27] = 0;
    uint8Array[28] = 0;
    writeUint(uint8Array, 29, crc(uint8Array, 12, 17));
    let num16 = 33;
    if (null != obj.sRGB) {
      writeUint(uint8Array, 33, 1);
      writeASCII(uint8Array, 37, "sRGB");
      uint8Array[41] = obj.sRGB;
      writeUint(uint8Array, 42, crc(uint8Array, 37, 5));
      num16 = 46;
    }
    let sum14 = num16;
    if (null != obj.iCCP) {
      const sum8 = 13 + arr.length;
      writeUint(uint8Array, num16, sum8);
      const sum9 = num16 + 4;
      writeASCII(uint8Array, sum9, "iCCP");
      const sum10 = sum9 + 4;
      writeASCII(uint8Array, sum10, "ICC profile");
      const sum11 = sum10 + 11 + 2;
      const result1 = uint8Array.set(arr, sum11);
      const sum12 = sum11 + arr.length;
      const sum13 = sum8 + 4;
      writeUint(uint8Array, sum12, crc(uint8Array, sum12 - sum13, sum13));
      sum14 = sum12 + 4;
    }
    let sum20 = sum14;
    if (null != obj.pHYs) {
      writeUint(uint8Array, sum14, 9);
      const sum15 = sum14 + 4;
      writeASCII(uint8Array, sum15, "pHYs");
      const sum16 = sum15 + 4;
      writeUint(uint8Array, sum16, obj.pHYs[0]);
      const sum17 = sum16 + 4;
      writeUint(uint8Array, sum17, obj.pHYs[1]);
      const sum18 = sum17 + 4;
      uint8Array[sum18] = obj.pHYs[2];
      const sum19 = sum18 + 1;
      writeUint(uint8Array, sum19, crc(uint8Array, sum19 - 13, 13));
      sum20 = sum19 + 4;
    }
    let sum25 = sum20;
    if (writeUintResult16) {
      writeUint(uint8Array, sum20, 8);
      const sum21 = sum20 + 4;
      writeASCII(uint8Array, sum21, "acTL");
      const sum22 = sum21 + 4;
      writeUint(uint8Array, sum22, frames.frames.length);
      const sum23 = sum22 + 4;
      let num25 = 0;
      if (null != obj.loop) {
        num25 = obj.loop;
      }
      writeUint(uint8Array, sum23, num25);
      const sum24 = sum23 + 4;
      writeUint(uint8Array, sum24, crc(uint8Array, sum24 - 12, 12));
      sum25 = sum24 + 4;
    }
    let sum32 = sum25;
    if (3 == frames.ctype) {
      writeUintResult16 = writeUint(uint8Array, sum25, 3 * length3);
      writeUintResult16 = sum25 + 4;
      writeUintResult16 = writeASCII(uint8Array, writeUintResult16, "PLTE");
      writeUintResult16 = writeUintResult16 + 4;
      for (let num26 = 0; num26 < length3; num26 = num26 + 1) {
        let tmp56 = frames.plte[num26];
        let sum26 = writeUintResult16 + 3 * num26;
        uint8Array[sum26] = 255 & tmp56;
        uint8Array[sum26 + 1] = tmp56 >>> 8 & 255;
        uint8Array[sum26 + 2] = tmp56 >>> 16 & 255;
      }
      const sum27 = writeUintResult16 + 3 * length3;
      writeUint(uint8Array, sum27, crc(uint8Array, sum27 - 3 * frames.plte.length - 4, 3 * frames.plte.length + 4));
      const sum28 = sum27 + 4;
      sum32 = sum28;
      if (flag) {
        writeUint(uint8Array, sum28, length3);
        const sum29 = sum28 + 4;
        writeASCII(uint8Array, sum29, "tRNS");
        const sum30 = sum29 + 4;
        for (let num27 = 0; num27 < length3; num27 = num27 + 1) {
          uint8Array[sum30 + num27] = frames.plte[num27] >>> 24 & 255;
        }
        const sum31 = sum30 + length3;
        writeUint(uint8Array, sum31, crc(uint8Array, sum31 - length3 - 4, length3 + 4));
        sum32 = sum31 + 4;
      }
    }
    let sum49 = sum32;
    let num28 = 0;
    let num29 = 0;
    let tmp68 = sum32;
    if (0 < frames.frames.length) {
      do {
        let tmp69 = frames.frames[num28];
        let sum45 = sum49;
        let sum35 = num29;
        if (writeUintResult16) {
          let writeUintResult20 = writeUint(uint8Array, sum49, 26);
          let sum33 = sum49 + 4;
          let writeASCIIResult7 = writeASCII(uint8Array, sum33, "fcTL");
          let sum34 = sum33 + 4;
          let tmp76 = +num29;
          sum35 = tmp76 + 1;
          let writeUintResult21 = writeUint(uint8Array, sum34, tmp76);
          let sum36 = sum34 + 4;
          let writeUintResult22 = writeUint(uint8Array, sum36, tmp69.rect.width);
          let sum37 = sum36 + 4;
          let writeUintResult23 = writeUint(uint8Array, sum37, tmp69.rect.height);
          let sum38 = sum37 + 4;
          let writeUintResult24 = writeUint(uint8Array, sum38, tmp69.rect.x);
          let sum39 = sum38 + 4;
          let writeUintResult25 = writeUint(uint8Array, sum39, tmp69.rect.y);
          let sum40 = sum39 + 4;
          let writeUshortResult = writeUshort(uint8Array, sum40, arg3[num28]);
          let sum41 = sum40 + 2;
          let writeUshortResult1 = writeUshort(uint8Array, sum41, 1000);
          let sum42 = sum41 + 2;
          uint8Array[sum42] = tmp69.dispose;
          let sum43 = sum42 + 1;
          uint8Array[sum43] = tmp69.blend;
          let sum44 = sum43 + 1;
          let writeUintResult26 = writeUint(uint8Array, sum44, crc(uint8Array, sum44 - 30, 30));
          sum45 = sum44 + 4;
        }
        let cimg = tmp69.cimg;
        let length2 = cimg.length;
        let tmp94 = 0 == num28;
        let num30 = 4;
        if (tmp94) {
          num30 = 0;
        }
        let writeUintResult27 = writeUint(uint8Array, sum45, length2 + num30);
        let sum46 = sum45 + 4;
        let str7 = "fdAT";
        if (tmp94) {
          str7 = "IDAT";
        }
        let writeASCIIResult8 = writeASCII(uint8Array, sum46, str7);
        let sum47 = sum46 + 4;
        let sum48 = sum47;
        num29 = sum35;
        if (0 != num28) {
          writeUintResult16 = +sum35;
          num29 = writeUintResult16 + 1;
          writeUintResult16 = writeUint(uint8Array, sum47, writeUintResult16);
          sum48 = sum47 + 4;
        }
        writeUintResult16 = uint8Array.set(cimg, sum48);
        writeUintResult16 = sum48 + length2;
        writeUintResult16 = writeUint(uint8Array, writeUintResult16, crc(uint8Array, sum46, writeUintResult16 - sum46));
        sum49 = writeUintResult16 + 4;
        num28 = num28 + 1;
        tmp68 = sum49;
      } while (num28 < frames.frames.length);
    }
    writeUintResult16 = writeUint(uint8Array, tmp68, 0);
    writeUintResult16 = tmp68 + 4;
    writeUintResult16 = writeASCII(uint8Array, writeUintResult16, "IEND");
    writeUintResult16 = writeUintResult16 + 4;
    writeUintResult16 = writeUint(uint8Array, writeUintResult16, crc(uint8Array, writeUintResult16 - 4, 4));
    return uint8Array.buffer;
  }
  function compressPNG(frames) {
    let length;
    let num = 0;
    if (0 < frames.frames.length) {
      do {
        let tmp = frames.frames[num];
        let width = tmp.rect.width;
        let height = tmp.rect.height;
        let _Uint8Array = Uint8Array;
        let tmp2 = new.target;
        let tmp3 = new.target;
        let uint8Array = new Uint8Array(height * tmp.bpl + height);
        let tmp5 = uint8Array;
        let tmp6 = _filterZero;
        let tmp7 = height;
        let tmp8 = arg1;
        let tmp9 = arg2;
        tmp.cimg = _filterZero(tmp.img, height, tmp.bpp, tmp.bpl, uint8Array, arg1, arg2);
        num = num + 1;
        length = frames.frames.length;
      } while (num < length);
    }
  }
  function compress(arg0, arg1, arg2, arg3, first) {
    let length2;
    let length5;
    let length6;
    let length8;
    first = first[0];
    let num = 255;
    let num2 = 0;
    let num3 = 255;
    if (0 < arg0.length) {
      do {
        let _Uint8Array = Uint8Array;
        let tmp6 = new.target;
        let tmp7 = new.target;
        let uint8Array = new Uint8Array(arg0[num2]);
        let tmp8 = uint8Array;
        let length = uint8Array.length;
        let tmp9 = num;
        let num5 = 0;
        let tmp10 = num;
        let num6 = 0;
        if (0 < length) {
          do {
            tmp9 = tmp9 & uint8Array[num5 + 3];
            num5 = num5 + 4;
            tmp10 = tmp9;
            num6 = num5;
          } while (num5 < length);
        }
        num2 = num2 + 1;
        num = tmp10;
        let num4 = num6;
        num3 = tmp10;
      } while (num2 < arg0.length);
    }
    const items = [];
    let num7 = 0;
    if (0 < arg0.length) {
      do {
        let _Uint8Array2 = Uint8Array;
        let tmp21 = new.target;
        let tmp22 = new.target;
        let uint8Array1 = new Uint8Array(arg0[num7]);
        let tmp23 = uint8Array1;
        let _Uint32Array = Uint32Array;
        let tmp24 = new.target;
        let tmp25 = new.target;
        let uint32Array = new Uint32Array(uint8Array1.buffer);
        let tmp27 = uint32Array;
        let num8 = 0;
        if (first) {
          num8 = 1;
        }
        if (0 != num7) {
          if (!tmp3) {
            if (!first) {
              if (1 != num7) {
                let num11 = 2;
              }
              let num12 = 0;
              let num13 = 0;
              let sum1 = arg1;
              let sum2 = arg2;
              let num14 = 0;
              let num15 = 1000000000;
              let num16 = 0;
              let tmp42 = tmp18;
              let tmp43 = tmp20;
              let num17 = 0;
              let num18 = 0;
              let tmp44 = arg1;
              let tmp45 = arg2;
              let num19 = 0;
              let num20 = 1000000000;
              let num21 = 0;
              let tmp46 = tmp18;
              let tmp47 = tmp20;
              if (0 < num11) {
                do {
                  let _Uint8Array3 = Uint8Array;
                  let tmp48 = new.target;
                  let uint8Array2 = new Uint8Array(arg0[num7 - 1 - num16]);
                  let _Uint32Array2 = Uint32Array;
                  let tmp50 = new.target;
                  let tmp51 = new.target;
                  let uint32Array1 = new Uint32Array(arg0[num7 - 1 - num16]);
                  let tmp53 = uint32Array1;
                  let tmp54 = tmp43;
                  let tmp55 = arg1;
                  let tmp56 = arg2;
                  let num22 = -1;
                  let num23 = -1;
                  let num24 = 0;
                  let num25 = arg1;
                  let num26 = arg2;
                  let num27 = -1;
                  let num28 = -1;
                  let num29 = 0;
                  let tmp57 = tmp43;
                  if (0 < arg2) {
                    do {
                      let tmp58 = tmp55;
                      let tmp59 = tmp56;
                      let tmp60 = num22;
                      let tmp61 = num23;
                      let num30 = 0;
                      let tmp62 = tmp55;
                      let tmp63 = tmp56;
                      let tmp64 = num22;
                      let tmp65 = num23;
                      let num31 = 0;
                      if (0 < arg1) {
                        do {
                          let sum = num24 * arg1 + num30;
                          let tmp67 = tmp58;
                          let tmp68 = tmp59;
                          let tmp69 = tmp60;
                          let tmp70 = tmp61;
                          if (uint32Array[sum] != uint32Array1[sum]) {
                            let tmp71 = tmp58;
                            if (num30 < tmp58) {
                              tmp71 = num30;
                            }
                            let tmp72 = tmp60;
                            if (num30 > tmp60) {
                              tmp72 = num30;
                            }
                            let tmp73 = tmp59;
                            if (num24 < tmp59) {
                              tmp73 = num24;
                            }
                            let tmp74 = tmp61;
                            if (num24 > tmp61) {
                              tmp74 = num24;
                            }
                            tmp70 = tmp74;
                            tmp67 = tmp71;
                            tmp68 = tmp73;
                            tmp69 = tmp72;
                          }
                          num30 = num30 + 1;
                          tmp58 = tmp67;
                          tmp59 = tmp68;
                          tmp60 = tmp69;
                          tmp61 = tmp70;
                          tmp62 = tmp67;
                          tmp63 = tmp68;
                          tmp64 = tmp69;
                          tmp65 = tmp70;
                          tmp54 = sum;
                          num31 = num30;
                        } while (num30 < arg1);
                      }
                      num24 = num24 + 1;
                      tmp55 = tmp62;
                      tmp56 = tmp63;
                      num22 = tmp64;
                      num23 = tmp65;
                      tmp42 = num31;
                      num25 = tmp62;
                      num26 = tmp63;
                      num27 = tmp64;
                      num28 = tmp65;
                      tmp57 = tmp54;
                      num29 = num24;
                    } while (num24 < arg2);
                  }
                  let tmp75 = tmp42;
                  if (-1 == num27) {
                    num25 = 0;
                    num26 = 0;
                    num27 = 0;
                    num28 = 0;
                  }
                  let tmp76 = num25;
                  let tmp77 = num26;
                  if (tmp2) {
                    let diff = num25;
                    if (!(1 & ~num25)) {
                      diff = num25 - 1;
                    }
                    let diff1 = num26;
                    if (!(1 & ~num26)) {
                      diff1 = num26 - 1;
                    }
                    tmp77 = diff1;
                    tmp76 = diff;
                  }
                  let result = (num27 - tmp76 + 1) * (num28 - tmp77 + 1);
                  if (result < num15) {
                    sum1 = num27 - tmp76 + 1;
                    sum2 = num28 - tmp77 + 1;
                    num12 = tmp76;
                    num13 = tmp77;
                    num14 = num16;
                    num15 = result;
                  }
                  num16 = num16 + 1;
                  tmp43 = tmp57;
                  num17 = num12;
                  num18 = num13;
                  tmp44 = sum1;
                  tmp45 = sum2;
                  num19 = num14;
                  num20 = num15;
                  let tmp12 = uint32Array1;
                  let tmp13 = tmp76;
                  let tmp14 = tmp77;
                  let tmp15 = num27;
                  let tmp16 = num28;
                  let tmp17 = num29;
                  tmp46 = tmp42;
                  let tmp19 = result;
                  tmp47 = tmp57;
                  num21 = num16;
                } while (num16 < num11);
              }
              let _Uint8Array4 = Uint8Array;
              let tmp81 = new.target;
              let tmp82 = new.target;
              let uint8Array3 = new Uint8Array(arg0[num7 - 1 - num19]);
              let tmp84 = uint8Array3;
              if (1 == num19) {
                items[num7 - 1].dispose = 2;
              }
              let _Uint8Array5 = Uint8Array;
              let tmp85 = new.target;
              let tmp86 = new.target;
              let uint8Array4 = new Uint8Array(tmp44 * tmp45 * 4);
              let tmp88 = uint8Array4;
              let tmp89 = callback;
              let tmp90 = uint8Array3;
              let tmp91 = arg1;
              let tmp92 = arg2;
              let tmp93 = uint8Array4;
              let tmp94 = tmp44;
              let tmp95 = tmp45;
              let num32 = 0;
              let tmp96 = callback(tmp84, arg1, arg2, uint8Array4, tmp44, tmp45, -num17, -num18, 0);
              let tmp97 = callback;
              let tmp98 = uint8Array1;
              let tmp99 = arg1;
              first = arg2;
              first = uint8Array4;
              first = tmp44;
              first = tmp45;
              let num33 = 3;
              let num34 = 0;
              if (callback(tmp23, arg1, arg2, uint8Array4, tmp44, tmp45, -num17, -num18, 3)) {
                num34 = 1;
              }
              if (1 === num34) {
                first = _prepareDiff;
                let obj = { x: num17, y: num18, width: tmp44, height: tmp45 };
                first = uint8Array1;
                first = arg1;
                first = arg2;
                first = uint8Array4;
                first = obj;
                first = _prepareDiff(tmp23, arg1, arg2, tmp88, obj);
                let substr = uint8Array4;
                let num9 = num17;
                let num10 = num18;
                let tmp29 = tmp44;
                let tmp30 = tmp45;
                num8 = num34;
                first = num11;
                first = num19;
                first = num20;
                first = num21;
                first = uint8Array3;
                let tmp31 = tmp12;
                let tmp32 = tmp13;
                let tmp33 = tmp14;
                let tmp34 = tmp15;
                let tmp35 = tmp16;
                let tmp36 = tmp17;
                let tmp37 = tmp46;
                let tmp38 = tmp19;
                let tmp39 = tmp47;
              } else {
                first = callback;
                first = uint8Array1;
                first = arg1;
                first = arg2;
                first = uint8Array4;
                first = tmp44;
                first = tmp45;
                let num35 = 0;
                first = callback(tmp23, arg1, arg2, tmp88, tmp44, tmp45, -num17, -num18, 0);
                substr = uint8Array4;
                num9 = num17;
                num10 = num18;
                tmp29 = tmp44;
                tmp30 = tmp45;
                num8 = num34;
                first = num11;
                first = num19;
                first = num20;
                first = num21;
                first = uint8Array3;
                tmp31 = tmp12;
                tmp32 = tmp13;
                tmp33 = tmp14;
                tmp34 = tmp15;
                tmp35 = tmp16;
                tmp36 = tmp17;
                tmp37 = tmp46;
                tmp38 = tmp19;
                tmp39 = tmp47;
              }
            }
          }
          num11 = 1;
        } else {
          substr = uint8Array1.slice(0);
          num9 = 0;
          num10 = 0;
          tmp29 = arg1;
          tmp30 = arg2;
          tmp31 = tmp12;
          tmp32 = tmp13;
          tmp33 = tmp14;
          tmp34 = tmp15;
          tmp35 = tmp16;
          tmp36 = tmp17;
          tmp37 = tmp18;
          tmp38 = tmp19;
          tmp39 = tmp20;
        }
        obj = {};
        obj = { x: num9, y: num10, width: tmp29, height: tmp30 };
        obj.rect = obj;
        obj.img = substr;
        obj.blend = num8;
        obj.dispose = 0;
        first = items.push(obj);
        num7 = num7 + 1;
        tmp12 = tmp31;
        tmp13 = tmp32;
        tmp14 = tmp33;
        tmp15 = tmp34;
        tmp16 = tmp35;
        tmp17 = tmp36;
        tmp18 = tmp37;
        tmp19 = tmp38;
        tmp20 = tmp39;
      } while (num7 < arg0.length);
    }
    if (first) {
      for (let num36 = 0; num36 < items.length; num36 = num36 + 1) {
        first = items[num36];
        if (1 != first.blend) {
          let rect = first.rect;
          let rect2 = items[num36 - 1].rect;
          let _Math3 = Math;
          first = Math.min(rect.x, rect2.x);
          let _Math4 = Math;
          first = Math.min(rect.y, rect2.y);
          let obj1 = { x: first, y: first };
          let _Math5 = Math;
          obj1.width = Math.max(rect.x + rect.width, rect2.x + rect2.width) - first;
          let _Math6 = Math;
          obj1.height = Math.max(rect.y + rect.height, rect2.y + rect2.height) - first;
          items[num36 - 1].dispose = 1;
          if (num36 - 1 !== 0) {
            first = _updateFrame;
            first = arg0;
            first = arg1;
            first = arg2;
            first = items;
            first = obj1;
            first = tmp2;
            first = _updateFrame(arg0, arg1, arg2, items, num36 - 1, obj1, tmp2);
          }
          first = _updateFrame;
          first = arg0;
          first = arg1;
          first = arg2;
          first = items;
          first = num36;
          first = obj1;
          first = tmp2;
          first = _updateFrame(arg0, arg1, arg2, items, num36, obj1, tmp2);
          first = obj1;
        }
      }
    }
    if (1 != arg0.length) {
      let num37 = 0;
      if (0 < items.length) {
        do {
          first = items[num37];
          first = first.rect.width * first.rect.height;
          num37 = num37 + 1;
          length2 = items.length;
        } while (num37 < length2);
      }
    }
    const obj2 = {};
    const items1 = [];
    const items2 = [];
    if (0 != arg3) {
      const items3 = [];
      let num41 = 0;
      if (0 < items.length) {
        do {
          first = items3.push(items[num41].img.buffer);
          num41 = num41 + 1;
          length5 = items.length;
        } while (num41 < length5);
      }
      let num42 = 0;
      let num43 = 0;
      let num44 = 0;
      if (0 < items3.length) {
        do {
          num42 = num42 + items3[num43].byteLength;
          num43 = num43 + 1;
          num44 = num42;
          length6 = items3.length;
        } while (num43 < length6);
      }
      const _Uint8Array7 = Uint8Array;
      first = new.target;
      first = new.target;
      first = num44;
      first = new Uint8Array(num44);
      let num45 = 0;
      let num46 = 0;
      if (0 < items3.length) {
        do {
          let _Uint8Array8 = Uint8Array;
          first = new.target;
          first = new.target;
          let uint8Array5 = new Uint8Array(items3[num45]);
          first = uint8Array5;
          let length7 = uint8Array5.length;
          let num47 = 0;
          if (0 < length7) {
            do {
              let num48 = uint8Array5[num47];
              let num49 = uint8Array5[num47 + 1];
              let num50 = uint8Array5[num47 + 2];
              first = uint8Array5[num47 + 3];
              if (0 == first) {
                num48 = 0;
                num49 = 0;
                num50 = 0;
              }
              first[num46 + num47] = num48;
              first[num46 + num47 + 1] = num49;
              first[num46 + num47 + 2] = num50;
              first[num46 + num47 + 3] = first;
              num47 = num47 + 4;
              first = num48;
              first = num49;
              first = num50;
            } while (num47 < length7);
          }
          num46 = num46 + length7;
          num45 = num45 + 1;
        } while (num45 < items3.length);
      }
      first = quantize;
      first = quantize(first.buffer, arg3);
      let num51 = 0;
      if (0 < first.plte.length) {
        do {
          first = items1.push(first.plte[num51].est.rgba);
          num51 = num51 + 1;
          length8 = first.plte.length;
        } while (num51 < length8);
      }
      let num52 = 0;
      let num53 = 0;
      num4 = 0;
      if (0 < items.length) {
        do {
          first = items[num52];
          let length9 = first.img.length;
          let _Uint8Array9 = Uint8Array;
          first = new.target;
          first = new.target;
          first = new Uint8Array(first.inds.buffer, num53 >> 2, length9 >> 2);
          first = items2.push(first);
          let _Uint8Array10 = Uint8Array;
          first = new.target;
          first = new.target;
          first = num53;
          first = length9;
          first = new Uint8Array(first.abuf, num53, length9);
          first = num53;
          if (tmp5) {
            first = dither;
            first = items1;
            first = dither(first.img, first.rect.width, first.rect.height, items1, first, first);
          }
          let img = first.img;
          first = img.set(first);
          num53 = num53 + length9;
          num52 = num52 + 1;
          num4 = num52;
        } while (num52 < items.length);
      }
    } else {
      first = null;
      let num40 = 0;
      if (0 < items.length) {
        do {
          first = items[num40];
          let _Uint32Array3 = Uint32Array;
          first = new.target;
          first = new.target;
          let uint32Array2 = new Uint32Array(first.img.buffer);
          first = uint32Array2;
          let width = first.rect.width;
          let length3 = uint32Array2.length;
          let _Uint8Array6 = Uint8Array;
          first = new.target;
          first = new.target;
          first = length3;
          first = new Uint8Array(length3);
          first = items2.push(first);
          let num38 = 0;
          let num39 = 0;
          if (0 < length3) {
            while (true) {
              first = uint32Array2[num38];
              if (0 != num38) {
                if (first == uint32Array2[num38 - 1]) {
                  first[num38] = first[num38 - 1];
                  num38 = num38 + 1;
                  num39 = num38;
                  if (num38 >= length3) {
                    break;
                  }
                }
              }
              if (num38 > width) {
                if (first == uint32Array2[num38 - width]) {
                  first[num38] = first[num38 - width];
                }
              }
              first = obj2[first];
              if (null != first) {
                first[num38] = first;
              } else {
                let length4 = items1.length;
                obj2[first] = length4;
                first = items1.push(first);
                first = length4;
                num39 = num38;
                first = length4;
                if (items1.length >= 300) {
                  break;
                }
              }
              break;
            }
          }
          num40 = num40 + 1;
          num4 = num39;
        } while (num40 < items.length);
      }
    }
    first = length10 <= 256 && 0 == tmp4;
    let num54 = 8;
    if (first) {
      let num55 = 1;
      if (length10 > 2) {
        let num56 = 2;
        if (length10 > 4) {
          let num58 = 8;
          if (length10 <= 16) {
            num58 = 4;
          }
          num56 = num58;
        }
        num55 = num56;
      }
      const _Math = Math;
      num54 = Math.max(num55, first[3]);
    }
    let num59 = 6;
    let num60 = 0;
    let num61 = 6;
    if (0 < items.length) {
      while (true) {
        first = items[num60];
        let x = first.rect.x;
        let y = first.rect.y;
        let width2 = first.rect.width;
        let height = first.rect.height;
        let img2 = first.img;
        let _Uint32Array4 = Uint32Array;
        first = new.target;
        first = new Uint32Array(img2.buffer);
        first = 4 * width2;
        if (length10 <= 256) {
          if (0 == tmp4) {
            let _Math2 = Math;
            first = Math.ceil(num54 * width2 / 8);
            let _Uint8Array12 = Uint8Array;
            first = new.target;
            first = new.target;
            first = new Uint8Array(first * height);
            first = items2[num60];
            let num66 = 0;
            let num67 = first;
            let num68 = 0;
            if (0 < height) {
              do {
                first = num66 * first;
                first = num66 * width2;
                if (8 == num54) {
                  let num72 = 0;
                  num67 = 0;
                  if (0 < width2) {
                    do {
                      first[first + num72] = first[first + num72];
                      num72 = num72 + 1;
                      num67 = num72;
                    } while (num72 < width2);
                  }
                } else if (4 == num54) {
                  let num71 = 0;
                  num67 = 0;
                  if (0 < width2) {
                    do {
                      first = first + (num71 >> 1);
                      first[first] = first[first] | first[first + num71] << 4 - 4 * (1 & num71);
                      num71 = num71 + 1;
                      num67 = num71;
                    } while (num71 < width2);
                  }
                } else if (2 == num54) {
                  let num70 = 0;
                  num67 = 0;
                  if (0 < width2) {
                    do {
                      first = first + (num70 >> 2);
                      first[first] = first[first] | first[first + num70] << 6 - 2 * (3 & num70);
                      num70 = num70 + 1;
                      num67 = num70;
                    } while (num70 < width2);
                  }
                } else if (1 == num54) {
                  let num69 = 0;
                  num67 = 0;
                  if (0 < width2) {
                    do {
                      first = first + (num69 >> 3);
                      first[first] = first[first] | first[first + num69] << 7 - (7 & num69);
                      num69 = num69 + 1;
                      num67 = num69;
                    } while (num69 < width2);
                  }
                }
                num66 = num66 + 1;
                num4 = first;
                first = num67;
                num68 = num66;
              } while (num66 < height);
            }
            first = num4;
            first = num68;
            let num62 = 3;
            let num63 = 1;
            first.img = first;
            first.bpl = first;
            first.bpp = num63;
            num60 = num60 + 1;
            num59 = num62;
            num4 = first;
            num61 = num62;
            if (num60 >= items.length) {
              break;
            }
          }
        }
        num62 = num59;
        first = num4;
        first = img2;
        num63 = 4;
        if (0 == tmp11) {
          num62 = num59;
          first = num4;
          first = img2;
          num63 = 4;
          if (1 == items.length) {
            let _Uint8Array11 = Uint8Array;
            first = new.target;
            first = new.target;
            first = new Uint8Array(width2 * height * 3);
            first = width2 * height;
            let num64 = 0;
            let num65 = 0;
            if (0 < first) {
              do {
                first = 3 * num64;
                first = 4 * num64;
                first[first] = img2[first];
                first[first + 1] = img2[first + 1];
                first[first + 2] = img2[first + 2];
                num64 = num64 + 1;
                num65 = num64;
              } while (num64 < first);
            }
            first = 3 * width2;
            first = num65;
            num62 = 2;
            num63 = 3;
          }
        }
      }
    }
    const obj3 = { ctype: num61, depth: num54, plte: items1, frames: items };
    return obj3;
  }
  function _updateFrame(arg0, arg1, arg2, items, arg4, height, first) {
    let _Uint8Array = Uint8Array;
    const uint8Array = new Uint8Array(arg0[arg4 - 1]);
    const uint32Array = new Uint32Array(arg0[arg4 - 1]);
    _Uint8Array = null;
    if (arg4 + 1 < arg0.length) {
      const prototype = _Uint8Array.prototype;
      _Uint8Array = new _Uint8Array(arg0[arg4 + 1]);
    }
    const _Uint8Array1 = new _Uint8Array(arg0[arg4]);
    const uint32Array1 = new Uint32Array(_Uint8Array1.buffer);
    let tmp9 = arg1;
    let tmp10 = arg2;
    let num = -1;
    let num2 = -1;
    let num3 = 0;
    let num4 = arg1;
    let num5 = arg2;
    let num6 = -1;
    let num7 = -1;
    if (0 < height.height) {
      do {
        let tmp11 = tmp9;
        let tmp12 = tmp10;
        let tmp13 = num;
        let tmp14 = num2;
        let num8 = 0;
        let tmp15 = tmp9;
        let tmp16 = tmp10;
        let tmp17 = num;
        let tmp18 = num2;
        if (0 < height.width) {
          do {
            let sum = height.x + num8;
            let sum1 = height.y + num3;
            let sum2 = sum1 * arg1 + sum;
            let tmp22 = uint32Array1[sum2];
            let tmp23 = 0 == tmp22;
            if (!tmp23) {
              let tmp24 = 0 == items[arg4 - 1].dispose && uint32Array[sum2] == tmp22;
              if (tmp24) {
                let tmp25 = null == _Uint8Array || 0 != _Uint8Array[4 * sum2 + 3];
                tmp24 = tmp25;
              }
              tmp23 = tmp24;
            }
            let tmp26 = tmp11;
            let tmp27 = tmp12;
            let tmp28 = tmp13;
            let tmp29 = tmp14;
            if (!tmp23) {
              let tmp30 = tmp11;
              if (sum < tmp11) {
                tmp30 = sum;
              }
              let tmp31 = tmp13;
              if (sum > tmp13) {
                tmp31 = sum;
              }
              let tmp32 = tmp12;
              if (sum1 < tmp12) {
                tmp32 = sum1;
              }
              let tmp33 = tmp14;
              if (sum1 > tmp14) {
                tmp33 = sum1;
              }
              tmp29 = tmp33;
              tmp26 = tmp30;
              tmp27 = tmp32;
              tmp28 = tmp31;
            }
            num8 = num8 + 1;
            tmp11 = tmp26;
            tmp12 = tmp27;
            tmp13 = tmp28;
            tmp14 = tmp29;
            tmp15 = tmp26;
            tmp16 = tmp27;
            tmp17 = tmp28;
            tmp18 = tmp29;
            let tmp34 = sum;
            let tmp35 = sum1;
            let tmp36 = sum2;
            let tmp37 = tmp22;
          } while (num8 < height.width);
        }
        num3 = num3 + 1;
        tmp9 = tmp15;
        tmp10 = tmp16;
        num = tmp17;
        num2 = tmp18;
        num4 = tmp15;
        num5 = tmp16;
        num6 = tmp17;
        num7 = tmp18;
      } while (num3 < height.height);
    }
    if (-1 == num6) {
      num4 = 0;
      num5 = 0;
      num6 = 0;
      num7 = 0;
    }
    let tmp38 = num4;
    let tmp39 = num5;
    if (first) {
      let diff = num4;
      if (!(1 & ~num4)) {
        diff = num4 - 1;
      }
      let diff1 = num5;
      if (!(1 & ~num5)) {
        diff1 = num5 - 1;
      }
      tmp39 = diff1;
      tmp38 = diff;
    }
    const size = { x: tmp38, y: tmp39, width: num6 - tmp38 + 1, height: num7 - tmp39 + 1 };
    items[arg4].rect = size;
    items[arg4].blend = 1;
    const uint8Array1 = new Uint8Array(size.width * size.height * 4);
    items[arg4].img = uint8Array1;
    if (0 == items[arg4 - 1].dispose) {
      callback(uint8Array, arg1, arg2, tmp42.img, size.width, size.height, -size.x, -size.y, 0);
      _prepareDiff(tmp7, arg1, arg2, tmp42.img, size);
    } else {
      callback(tmp7, arg1, arg2, tmp42.img, size.width, size.height, -size.x, -size.y, 0);
    }
  }
  function _prepareDiff(arg0, arg1, arg2, img, size) {
    callback(arg0, arg1, arg2, img, size.width, size.height, -size.x, -size.y, 2);
  }
  function _filterZero(buffer, arg1, arg2, arg3, set) {
    const items = [];
    let items1 = [0, 1, 2, 3, 4];
    if (-1 != arg5) {
      const items2 = [arg5];
      items1 = items2;
    } else {
      let tmp = arg1 * arg3 > 500000;
      if (!tmp) {
        tmp = 1 == arg2;
      }
      if (tmp) {
        items1 = [0];
      }
    }
    if (arg6) {
      const obj = { level: 0 };
      const tmp2 = obj;
    }
    if (set.length > 10000000) {
      const _window = window;
      if (null != window.UZIP) {
        const _window2 = window;
        let pako = window.UZIP;
      }
      const _Date = Date;
      const timestamp = Date.now();
      for (let num5 = 0; num5 < items1.length; num5 = num5 + 1) {
        for (let num6 = 0; num6 < arg1; num6 = num6 + 1) {
          let tmp7 = _filterLine;
          let tmp8 = set;
          let tmp9 = buffer;
          let tmp10 = num6;
          let tmp11 = arg3;
          let tmp12 = arg2;
          let tmp13 = _filterLine(set, buffer, num6, arg3, arg2, items1[num5]);
        }
        let arr = items.push(pako.deflate(set, tmp2));
      }
      let num7 = 1000000000;
      let num8 = 0;
      let tmp16;
      if (0 < items.length) {
        do {
          if (items[num8].length < num7) {
            num7 = items[num8].length;
            let tmp15 = num8;
          }
          num8 = num8 + 1;
          tmp16 = tmp15;
        } while (num8 < items.length);
      }
      return items[tmp16];
    }
    pako = globalThis.pako;
  }
  function _filterLine(set, buffer, arg2, arg3, arg4, arg5) {
    const result = arg2 * arg3;
    const sum = result + arg2;
    set[sum] = arg5;
    const sum1 = sum + 1;
    if (0 == arg5) {
      if (arg3 < 500) {
        for (let num18 = 0; num18 < arg3; num18 = num18 + 1) {
          set[sum1 + num18] = buffer[result + num18];
        }
      } else {
        const _Uint8Array = Uint8Array;
        const uint8Array = new Uint8Array(buffer.buffer, result, arg3);
        const result1 = set.set(uint8Array, sum1);
      }
    } else if (1 == arg5) {
      for (let num14 = 0; num14 < arg4; num14 = num14 + 1) {
        set[sum1 + num14] = buffer[result + num14];
      }
      let sum2 = arg4;
      if (arg4 < arg3) {
        do {
          set[sum1 + sum2] = buffer[result + sum2] - buffer[result + sum2 - arg4] + 256 & 255;
          sum2 = sum2 + 1;
        } while (sum2 < arg3);
      }
    } else if (0 == arg2) {
      for (let num8 = 0; num8 < arg4; num8 = num8 + 1) {
        set[sum1 + num8] = buffer[result + num8];
      }
      if (2 == arg5) {
        let sum3 = arg4;
        if (arg4 < arg3) {
          do {
            set[sum1 + sum3] = buffer[result + sum3];
            sum3 = sum3 + 1;
          } while (sum3 < arg3);
        }
      }
      if (3 == arg5) {
        let sum4 = arg4;
        if (arg4 < arg3) {
          do {
            set[sum1 + sum4] = buffer[result + sum4] - (buffer[result + sum4 - arg4] >> 1) + 256 & 255;
            sum4 = sum4 + 1;
          } while (sum4 < arg3);
        }
      }
      if (4 == arg5) {
        let sum6 = arg4;
        if (arg4 < arg3) {
          do {
            let tmp15 = callback2;
            let sum5 = sum1 + sum6;
            set[sum5] = buffer[result + sum6] - callback2(buffer[result + sum6 - arg4], 0, 0) + 256 & 255;
            sum6 = sum6 + 1;
          } while (sum6 < arg3);
        }
      }
    } else {
      if (2 == arg5) {
        for (let num3 = 0; num3 < arg3; num3 = num3 + 1) {
          set[sum1 + num3] = buffer[result + num3] + 256 - buffer[result + num3 - arg3] & 255;
        }
      }
      if (3 == arg5) {
        for (let num5 = 0; num5 < arg4; num5 = num5 + 1) {
          set[sum1 + num5] = buffer[result + num5] + 256 - (buffer[result + num5 - arg3] >> 1) & 255;
        }
        let sum7 = arg4;
        if (arg4 < arg3) {
          do {
            set[sum1 + sum7] = buffer[result + sum7] + 256 - (buffer[result + sum7 - arg3] + buffer[result + sum7 - arg4] >> 1) & 255;
            sum7 = sum7 + 1;
          } while (sum7 < arg3);
        }
      }
      if (4 == arg5) {
        for (let num7 = 0; num7 < arg4; num7 = num7 + 1) {
          let tmp7 = callback2;
          let sum8 = sum1 + num7;
          let sum9 = buffer[result + num7] + 256;
          set[sum8] = sum9 - callback2(0, buffer[result + num7 - arg3], 0) & 255;
        }
        let sum12 = arg4;
        if (arg4 < arg3) {
          do {
            let tmp11 = callback2;
            let sum10 = sum1 + sum12;
            let sum11 = buffer[result + sum12] + 256;
            set[sum10] = sum11 - callback2(buffer[result + sum12 - arg4], buffer[result + sum12 - arg3], buffer[result + sum12 - arg4 - arg3]) & 255;
            sum12 = sum12 + 1;
          } while (sum12 < arg3);
        }
      }
    }
  }
  function quantize(arg0, arg1, arg2) {
    const timestamp = Date.now();
    const uint8Array = new Uint8Array(arg0);
    const substr = uint8Array.slice(0);
    const uint32Array = new Uint32Array(substr.buffer);
    const tmp4 = getKDtree(substr, arg1);
    const first = tmp4[0];
    const uint32Array1 = new Uint32Array(length);
    const uint8Array1 = new Uint8Array(uint32Array1.buffer);
    for (let num = 0; num < length; num = num + 1) {
      uint32Array1[num] = arr2[num].est.rgba;
    }
    const uint8Array2 = new Uint8Array(length2 >> 2);
    if (tmp4[1].length <= 60) {
      findNearest(uint8Array, uint8Array2, uint8Array1);
      remap(uint8Array2, uint32Array, uint32Array1);
    } else if (uint8Array.length < 32000000) {
      for (let num6 = 0; num6 < length2; num6 = num6 + 4) {
        let tmp21 = getNearest;
        let tmp22 = first;
        let tmp23 = getNearest(first, 0.00392156862745098 * uint8Array[num6], 0.00392156862745098 * uint8Array[num6 + 1], 0.00392156862745098 * uint8Array[num6 + 2], 0.00392156862745098 * uint8Array[num6 + 3]);
        let tmp24 = num6 >> 2;
        uint8Array2[tmp24] = tmp23.ind;
        uint32Array[tmp24] = tmp23.est.rgba;
      }
    } else {
      for (let num2 = 0; num2 < length2; num2 = num2 + 4) {
        let result = 0.00392156862745098 * uint8Array[num2];
        let result1 = 0.00392156862745098 * uint8Array[num2 + 1];
        let result2 = 0.00392156862745098 * uint8Array[num2 + 2];
        let result3 = 0.00392156862745098 * uint8Array[num2 + 3];
        let rect = first;
        let tmp13 = first;
        if (first.left) {
          do {
            let tmp14 = planeDst;
            let tmp15 = result;
            let tmp16 = result1;
            let tmp17 = result2;
            let tmp18 = result3;
            tmp19 = planeDst(rect.est, result, result1, result2, result3) <= 0 ? rect.left : rect.right;
            rect = tmp19;
            tmp13 = tmp19;
          } while (tmp19.left);
        }
        let tmp20 = num2 >> 2;
        uint8Array2[tmp20] = tmp13.ind;
        uint32Array[tmp20] = tmp13.est.rgba;
      }
    }
    let num7 = 0;
    let num8 = 1000000000;
    if (arg2) {
      const tmp30 = kmeans(uint8Array, uint8Array2, uint8Array1);
      while (tmp30 / num8 <= 0.997) {
        num7 = num7 + 1;
        let num11 = 10;
        num8 = tmp30;
        if (num7 >= 10) {
          break;
        }
      }
      for (let num12 = 0; num12 < length; num12 = num12 + 1) {
        arr2[num12].est.rgba = uint32Array1[num12];
      }
      remap(uint8Array2, uint32Array, uint32Array1);
    } else {
      num7 = 0;
      num8 = 1000000000;
    }
    return { abuf: substr.buffer, inds: uint8Array2, plte: tmp4[1] };
  }
  function remap(uint8Array2, uint32Array, uint32Array1) {
    let length;
    let num = 0;
    if (0 < uint8Array2.length) {
      do {
        uint32Array[num] = uint32Array1[uint8Array2[num]];
        num = num + 1;
        length = uint8Array2.length;
      } while (num < length);
    }
  }
  function kmeans(uint8Array, uint8Array2, uint8Array1) {
    let length;
    let length2;
    const uint32Array = new Uint32Array(4 * tmp);
    const uint32Array1 = new Uint32Array(tmp);
    let num = 0;
    if (0 < uint8Array.length) {
      do {
        let tmp4 = uint8Array2[num >>> 2];
        let result = 4 * tmp4;
        uint32Array1[tmp4] = uint32Array1[tmp4] + 1;
        uint32Array[result] = uint32Array[result] + uint8Array[num];
        let sum = result + 1;
        uint32Array[sum] = uint32Array[sum] + uint8Array[num + 1];
        let sum1 = result + 2;
        uint32Array[sum1] = uint32Array[sum1] + uint8Array[num + 2];
        let sum2 = result + 3;
        uint32Array[sum2] = uint32Array[sum2] + uint8Array[num + 3];
        num = num + 4;
        length = uint8Array.length;
      } while (num < length);
    }
    let num2 = 0;
    if (0 < uint8Array1.length) {
      do {
        let _Math = Math;
        uint8Array1[num2] = Math.round(uint32Array[num2] / uint32Array1[num2 >>> 2]);
        num2 = num2 + 1;
        length2 = uint8Array1.length;
      } while (num2 < length2);
    }
    return findNearest(uint8Array, uint8Array2, uint8Array1);
  }
  function findNearest(uint8Array, uint8Array2, uint8Array1) {
    const items = [];
    let num = 0;
    if (0 < uint8Array1.length >>> 2) {
      do {
        let result = 4 * num;
        let tmp10 = tmp3;
        let num2 = 0;
        let num3 = 1000000000;
        let num4 = 0;
        let num5 = 1000000000;
        let num6 = 0;
        let tmp11 = tmp3;
        if (tmp2) {
          do {
            let tmp12 = num2;
            let tmp13 = num3;
            if (num != num4) {
              let result1 = 4 * num4;
              let diff = tmp6 - uint8Array1[result1];
              let diff1 = tmp7 - uint8Array1[result1 + 1];
              let diff2 = tmp8 - uint8Array1[result1 + 2];
              let diff3 = tmp9 - uint8Array1[result1 + 3];
              let sum = diff * diff + diff1 * diff1 + diff2 * diff2 + diff3 * diff3;
              tmp12 = num2;
              tmp10 = sum;
              tmp13 = num3;
              if (sum < num3) {
                tmp12 = num4;
                tmp13 = sum;
                tmp10 = sum;
              }
            }
            num4 = num4 + 1;
            num2 = tmp12;
            num3 = tmp13;
            num5 = tmp13;
            tmp11 = tmp10;
            num6 = num4;
          } while (num4 < tmp);
        }
        let _Math = Math;
        items[num] = 0.5 * Math.sqrt(num5);
        items[num] = items[num] * items[num];
        num = num + 1;
        let tmp20 = num6;
        tmp3 = tmp11;
        let tmp4 = tmp11;
      } while (num < tmp);
    }
    let num7 = 0;
    let num8 = 0;
    let num9 = 0;
    if (0 < uint8Array.length) {
      do {
        let tmp21 = uint8Array[num8];
        let tmp22 = uint8Array[num8 + 1];
        let tmp23 = uint8Array[num8 + 2];
        let tmp24 = uint8Array[num8 + 3];
        let tmp25 = num8 >>> 2;
        let tmp26 = uint8Array2[tmp25];
        let result2 = 4 * tmp26;
        let diff4 = tmp21 - uint8Array1[result2];
        let diff5 = tmp22 - uint8Array1[result2 + 1];
        let diff6 = tmp23 - uint8Array1[result2 + 2];
        let diff7 = tmp24 - uint8Array1[result2 + 3];
        let sum1 = diff4 * diff4 + diff5 * diff5 + diff6 * diff6 + diff7 * diff7;
        let tmp33 = tmp26;
        let tmp34 = tmp4;
        let tmp35 = sum1;
        if (sum1 > items[tmp26]) {
          let tmp42 = tmp26;
          let tmp43 = sum1;
          let num10 = 0;
          tmp33 = tmp26;
          tmp35 = sum1;
          let num11 = 0;
          tmp34 = tmp4;
          if (tmp2) {
            while (true) {
              let result3 = 4 * num10;
              let diff8 = tmp21 - uint8Array1[result3];
              let diff9 = tmp22 - uint8Array1[result3 + 1];
              let diff10 = tmp23 - uint8Array1[result3 + 2];
              let diff11 = tmp24 - uint8Array1[result3 + 3];
              let sum2 = diff8 * diff8 + diff9 * diff9 + diff10 * diff10 + diff11 * diff11;
              if (sum2 >= tmp43) {
                num10 = num10 + 1;
                tmp33 = tmp42;
                tmp35 = tmp43;
                tmp34 = sum2;
                let tmp45 = num10;
                if (num10 >= tmp) {
                  break;
                }
              } else {
                tmp42 = num10;
                tmp43 = sum2;
                tmp33 = num10;
                tmp35 = sum2;
                let tmp44 = num10;
                tmp34 = sum2;
                if (sum2 < items[num10]) {
                  break;
                }
              }
              break;
            }
          }
        }
        uint8Array2[tmp25] = tmp33;
        num7 = num7 + tmp35;
        num8 = num8 + 4;
        tmp4 = tmp34;
        num9 = num7;
      } while (num8 < uint8Array.length);
    }
    return num9 / (uint8Array.length >>> 2);
  }
  function getKDtree(substr, arg1) {
    let length;
    let num = arg2;
    if (null == arg2) {
      num = 0.0001;
    }
    const uint32Array = new Uint32Array(substr.buffer);
    let obj = { i0: 0, i1: substr.length, bst: null, est: null, tdst: 0, left: null, right: null };
    obj.bst = stats(substr, obj.i0, obj.i1);
    obj.est = estats(obj.bst);
    const items = [obj];
    if (items.length < arg1) {
      while (true) {
        let num2 = 0;
        let num3 = 0;
        let num4 = 0;
        let num5 = 0;
        let num6 = 0;
        if (0 < items.length) {
          do {
            if (items[num4].est.L > num2) {
              num2 = items[num4].est.L;
              num3 = num4;
            }
            num4 = num4 + 1;
            num5 = num2;
            num6 = num3;
          } while (num4 < items.length);
        }
        if (num5 < num) {
          break;
        } else {
          let tmp7 = items[num6];
          let tmp8 = splitPixels;
          let tmp9 = substr;
          let tmp10 = uint32Array;
          let tmp11 = splitPixels(substr, uint32Array, tmp7.i0, tmp7.i1, tmp7.est.e, tmp7.est.eMq255);
          if (tmp7.i0 < tmp11) {
            if (tmp7.i1 > tmp11) {
              obj = { i0: tmp7.i0, i1: tmp11, bst: null, est: null, tdst: 0, left: null, right: null };
              let tmp12 = stats;
              obj.bst = stats(substr, obj.i0, obj.i1);
              let tmp13 = estats;
              obj.est = estats(obj.bst);
              obj = { i0: tmp11, i1: tmp7.i1, bst: null, est: null, tdst: 0, left: null, right: null };
              let obj1 = { R: [], m: [], N: tmp7.bst.N - obj.bst.N };
              obj.bst = obj1;
              let num7 = 0;
              do {
                obj.bst.R[num7] = tmp7.bst.R[num7] - obj.bst.R[num7];
                num7 = num7 + 1;
                let num8 = 0;
              } while (num7 < 16);
              do {
                obj.bst.m[num8] = tmp7.bst.m[num8] - obj.bst.m[num8];
                num8 = num8 + 1;
              } while (num8 < 4);
              let tmp4 = estats;
              obj.est = estats(obj.bst);
              tmp7.left = obj;
              tmp7.right = obj;
              items[num6] = obj;
              let arr = items.push(obj);
            }
            let tmp2 = obj;
            let tmp3 = obj;
            if (items.length >= arg1) {
              break;
            }
          }
          tmp7.est.L = 0;
          obj = tmp2;
          obj = tmp3;
        }
      }
    }
    const sorted = items.sort((bst, bst2) => bst2.bst.N - bst.bst.N);
    let num9 = 0;
    if (0 < items.length) {
      do {
        items[num9].ind = num9;
        num9 = num9 + 1;
        length = items.length;
      } while (num9 < length);
    }
    const items1 = [obj, items];
    return items1;
  }
  function getNearest(first, result, result1, result2, result3) {
    let left;
    let right;
    if (null == first.left) {
      const q = first.est.q;
      const diff = result - q[0];
      const diff1 = result1 - q[1];
      const diff2 = result2 - q[2];
      const diff3 = result3 - q[3];
      first.tdst = diff * diff + diff1 * diff1 + diff2 * diff2 + diff3 * diff3;
      return first;
    } else {
      const tmp25 = planeDst(first.est, result, result1, result2, result3);
      ({ left: right, right: left } = first);
      if (tmp25 > 0) {
        ({ right, left } = first);
      }
      const tmp7 = getNearest(right, result, result1, result2, result3);
      if (tmp7.tdst <= tmp25 * tmp25) {
        return tmp7;
      } else {
        const tmp14 = getNearest(left, result, result1, result2, result3);
        let tmp15 = tmp7;
        if (tmp14.tdst < tmp7.tdst) {
          tmp15 = tmp14;
        }
        return tmp15;
      }
    }
  }
  function planeDst(est, result, result1, result2, result3) {
    const e = est.e;
    return e[0] * result + e[1] * result1 + e[2] * result2 + e[3] * result3 - est.eMq;
  }
  function splitPixels(substr, uint32Array, i0, i1, arg4, eMq255) {
    let tmp21;
    let diff = i1 - 4;
    let sum1 = i0;
    let tmp3 = i0;
    if (i0 < diff) {
      while (true) {
        let tmp4 = vecDot;
        let tmp5 = sum1;
        let tmp6 = sum1;
        if (vecDot(substr, sum1, arg4) <= eMq255) {
          do {
            let sum = tmp5 + 4;
            let tmp8 = vecDot;
            tmp5 = sum;
            tmp6 = sum;
            tmp9 = vecDot(substr, sum, arg4);
          } while (tmp9 <= eMq255);
        }
        let tmp10 = vecDot;
        let tmp11 = diff;
        let tmp12 = diff;
        if (vecDot(substr, diff, arg4) > eMq255) {
          do {
            let diff1 = tmp11 - 4;
            let tmp14 = vecDot;
            tmp11 = diff1;
            tmp12 = diff1;
            tmp15 = vecDot(substr, diff1, arg4);
          } while (tmp15 > eMq255);
        }
        tmp3 = tmp6;
        if (tmp6 >= tmp12) {
          break;
        } else {
          let tmp16 = tmp12 >> 2;
          uint32Array[tmp6 >> 2] = uint32Array[tmp16];
          uint32Array[tmp16] = uint32Array[tmp6 >> 2];
          sum1 = tmp6 + 4;
          diff = tmp12 - 4;
          tmp3 = sum1;
          if (sum1 >= diff) {
            break;
          }
        }
      }
    }
    let tmp17 = tmp3;
    let tmp18 = tmp3;
    if (vecDot(substr, tmp3, arg4) > eMq255) {
      do {
        let diff2 = tmp17 - 4;
        let tmp20 = vecDot;
        tmp17 = diff2;
        tmp18 = diff2;
        tmp21 = vecDot(substr, diff2, arg4);
      } while (tmp21 > eMq255);
    }
    return tmp18 + 4;
  }
  function vecDot(substr, diff, arg2) {
    return substr[diff] * arg2[0] + substr[diff + 1] * arg2[1] + substr[diff + 2] * arg2[2] + substr[diff + 3] * arg2[3];
  }
  function stats(substr, i0, i1) {
    let sum = i0;
    const R = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
    const m = [0, 0, 0, 0];
    const N = i1 - i0 >> 2;
    if (i0 < i1) {
      do {
        let result = 0.00392156862745098 * substr[sum];
        let result1 = 0.00392156862745098 * substr[sum + 1];
        let result2 = 0.00392156862745098 * substr[sum + 2];
        let result3 = 0.00392156862745098 * substr[sum + 3];
        m[0] = m[0] + result;
        m[1] = m[1] + result1;
        m[2] = m[2] + result2;
        m[3] = m[3] + result3;
        R[0] = R[0] + result * result;
        R[1] = R[1] + result * result1;
        R[2] = R[2] + result * result2;
        R[3] = R[3] + result * result3;
        R[5] = R[5] + result1 * result1;
        R[6] = R[6] + result1 * result2;
        R[7] = R[7] + result1 * result3;
        R[10] = R[10] + result2 * result2;
        R[11] = R[11] + result2 * result3;
        R[15] = R[15] + result3 * result3;
        sum = sum + 4;
      } while (sum < i1);
    }
    R[4] = R[1];
    R[8] = R[2];
    R[9] = R[6];
    R[12] = R[3];
    R[13] = R[7];
    R[14] = R[11];
    return { R, m, N };
  }
  function estats(bst) {
    let N;
    let R;
    let m;
    ({ R, m, N } = bst);
    const first = m[0];
    let num = 0;
    if (0 != N) {
      num = 1 / N;
    }
    const items = [R[0] - first * first * num, R[1] - first * m[1] * num, R[2] - first * m[2] * num, R[3] - first * m[3] * num, R[4] - m[1] * first * num, R[5] - m[1] * m[1] * num, R[6] - m[1] * m[2] * num, R[7] - m[1] * m[3] * num, R[8] - m[2] * first * num, R[9] - m[2] * m[1] * num, R[10] - m[2] * m[2] * num, R[11] - m[2] * m[3] * num, R[12] - m[3] * first * num, R[13] - m[3] * m[1] * num, R[14] - m[3] * m[2] * num, R[15] - m[3] * m[3] * num];
    let obj = closure_4;
    const items1 = [Math.random(), Math.random(), Math.random(), Math.random()];
    let tmp5 = items1;
    let num2 = 0;
    if (0 != N) {
      const multVecResult = obj.multVec(items, items1);
      const _Math = Math;
      const sqrtResult = Math.sqrt(obj.dot(multVecResult, multVecResult));
      let smlResult = obj.sml(1 / sqrtResult, multVecResult);
      let tmp9 = sqrtResult;
      let num5 = 0;
      const sum = num5 + 1;
      tmp5 = smlResult;
      num2 = tmp9;
      while (sum < 16) {
        let multVecResult1 = obj.multVec(items, smlResult);
        let _Math2 = Math;
        let sqrtResult1 = Math.sqrt(obj.dot(multVecResult1, multVecResult1));
        let smlResult1 = obj.sml(1 / sqrtResult1, multVecResult1);
        smlResult = smlResult1;
        tmp9 = sqrtResult1;
        num5 = sum;
        if (0 == sum) {
          continue;
        } else {
          let _Math3 = Math;
          smlResult = smlResult1;
          tmp9 = sqrtResult1;
          num5 = sum;
          tmp5 = smlResult1;
          num2 = tmp11;
          if (Math.abs(sqrtResult1 - tmp11) < 0.000000001) {
            break;
          }
        }
        continue;
      }
    }
    const items2 = [first * num, m[1] * num, m[2] * num, m[3] * num];
    obj = { Cov: items, q: items2, e: tmp5, L: num2 };
    obj.eMq255 = obj.dot(obj.sml(255, items2), tmp5);
    obj.eMq = obj.dot(tmp5, items2);
    const tmp15 = Math.round(255 * items2[3]) << 24;
    const tmp16 = Math.round(255 * items2[2]) << 16;
    obj.rgba = (tmp15 | tmp16 | Math.round(255 * items2[1]) << 8 | Math.round(255 * items2[0])) >>> 0;
    return obj;
  }
  ({ _copyTile: closure_0, _bin: closure_1, _paeth: closure_2 } = closure_0);
  let uint32Array = new Uint32Array(256);
  let num = 0;
  let tmp2 = num;
  let num2 = 0;
  do {
    do {
      let tmp3 = tmp2 >>> 1;
      let tmp4 = 1 & tmp2 ? 3988292384 ^ tmp3 : tmp3;
      num2 = num2 + 1;
      tmp2 = tmp4;
    } while (num2 < 8);
    uint32Array[num] = tmp4;
    num = num + 1;
  } while (num < 256);
})();

export default tmp;