// Metro module 1904 (f1905).
let c1595_0, _decompress, _inflate, c1595_4, _filterZero, _IHDR, _copyTile;
let c1596_0;
const decodeImage = function decodeImage(data, a1, a2, a3) {
  const r30 = a1 * a2;
  const r37 = Math.ceil(a1 * ([1, null, 3, 1, 2, null, 4][a3.ctype] * a3.depth) / 8);
  const uint8Array = new Uint8Array(4 * r30);
  const uint32Array = new Uint32Array(uint8Array.buffer);
  const { ctype, depth } = a3;
  const readUshort2 = c1595_0.readUshort;
  Date.now();
  if (ctype == 6) {
    const r375 = r30 << 2;
    if (depth == 8) {
      let r378 = 0;
      while (r378 < r375) {
        uint8Array[r378] = data[r378];
        const r380 = r378 + 1;
        uint8Array[r380] = data[r380];
        const r382 = r378 + 2;
        uint8Array[r382] = data[r382];
        const r384 = r378 + 3;
        uint8Array[r384] = data[r384];
        r378 = r378 + 4;
      }
    }
    if (depth == 16) {
      let r388 = 0;
      while (r388 < r375) {
        uint8Array[r388] = data[r388 << 1];
        r388 = r388 + 1;
      }
    }
  } else if (ctype == 2) {
    const tRNS2 = a3.tabs.tRNS;
    if (tRNS2 == null) {
      if (depth == 8) {
        let r347 = 0;
        while (r347 < r30) {
          const r348 = 3 * r347;
          uint32Array[r347] = -16777216 | data[r348 + 2] << 16 | data[r348 + 1] << 8 | data[r348];
          r347 = r347 + 1;
        }
      }
      if (depth == 16) {
        let r362 = 0;
        while (r362 < r30) {
          const r363 = 6 * r362;
          uint32Array[r362] = -16777216 | data[r363 + 4] << 16 | data[r363 + 2] << 8 | data[r363];
          r362 = r362 + 1;
        }
      }
    } else {
      const r291 = tRNS2[0];
      const r292 = tRNS2[1];
      const r293 = tRNS2[2];
      if (depth == 8) {
        let r299 = 0;
        while (r299 < r30) {
          const r300 = 3 * r299;
          const r301 = r300 + 2;
          const r303 = data[r301] << 16;
          const r304 = r300 + 1;
          uint32Array[r299] = -16777216 | r303 | data[r304] << 8 | data[r300];
          let r312 = data[r300] == r291;
          const r313 = r299;
          if (r312) {
            r312 = data[r304] == r292;
          }
          if (r312) {
            r312 = data[r301] == r293;
          }
          if (r312) {
            uint8Array[(r313 << 2) + 3] = 0;
          }
          r299 = r313 + 1;
        }
      }
      if (depth == 16) {
        let r324 = 0;
        while (r324 < r30) {
          const r325 = 6 * r324;
          const r326 = r325 + 4;
          const r328 = data[r326] << 16;
          const r329 = r325 + 2;
          uint32Array[r324] = -16777216 | r328 | data[r329] << 8 | data[r325];
          let r337 = readUshort2(data, r325) == r291;
          const r338 = r324;
          if (r337) {
            r337 = readUshort2(data, r329) == r292;
          }
          if (r337) {
            r337 = readUshort2(data, r326) == r293;
          }
          if (r337) {
            uint8Array[(r338 << 2) + 3] = 0;
          }
          r324 = r338 + 1;
        }
      }
    }
  } else if (ctype == 3) {
    const PLTE = a3.tabs.PLTE;
    const tRNS = a3.tabs.tRNS;
    const r179 = tRNS ? tRNS.length : 0;
    if (depth == 1) {
      const r181 = 0 < a2;
      let r184 = 0;
      if (r181) {
        do {
          const r185 = r184 * r37;
          const r186 = r184 * a1;
          const r187 = 0 < a1;
          const r188 = r184;
          let r189 = 0;
          if (r187) {
            do {
              const r191 = r186 + r189 << 2;
              const r198 = data[r185 + (r189 >> 3)] >> 7 - (7 & r189) & 1;
              const r199 = 3 * r198;
              uint8Array[r191] = PLTE[r199];
              uint8Array[r191 + 1] = PLTE[r199 + 1];
              uint8Array[r191 + 2] = PLTE[r199 + 2];
              const r207 = r198 < r179;
              const r208 = r189;
              uint8Array[r191 + 3] = r207 ? tRNS[r198] : 255;
              r189 = r208 + 1;
            } while (r189 < a1);
          }
          r184 = r188 + 1;
        } while (r184 < a2);
      }
    }
    if (depth == 2) {
      const r211 = 0 < a2;
      let r213 = 0;
      if (r211) {
        do {
          const r214 = r213 * r37;
          const r215 = r213 * a1;
          const r216 = 0 < a1;
          const r217 = r213;
          let r218 = 0;
          if (r216) {
            do {
              const r220 = r215 + r218 << 2;
              const r228 = data[r214 + (r218 >> 2)] >> 6 - ((3 & r218) << 1) & 3;
              const r229 = 3 * r228;
              uint8Array[r220] = PLTE[r229];
              uint8Array[r220 + 1] = PLTE[r229 + 1];
              uint8Array[r220 + 2] = PLTE[r229 + 2];
              const r237 = r228 < r179;
              const r238 = r218;
              uint8Array[r220 + 3] = r237 ? tRNS[r228] : 255;
              r218 = r238 + 1;
            } while (r218 < a1);
          }
          r213 = r217 + 1;
        } while (r213 < a2);
      }
    }
    if (depth == 4) {
      const r241 = 0 < a2;
      let r244 = 0;
      if (r241) {
        do {
          const r245 = r244 * r37;
          const r246 = r244 * a1;
          const r247 = 0 < a1;
          const r248 = r244;
          let r249 = 0;
          if (r247) {
            do {
              const r251 = r246 + r249 << 2;
              const r259 = data[r245 + (r249 >> 1)] >> 4 - ((1 & r249) << 2) & 15;
              const r260 = 3 * r259;
              uint8Array[r251] = PLTE[r260];
              uint8Array[r251 + 1] = PLTE[r260 + 1];
              uint8Array[r251 + 2] = PLTE[r260 + 2];
              const r268 = r259 < r179;
              const r269 = r249;
              uint8Array[r251 + 3] = r268 ? tRNS[r259] : 255;
              r249 = r269 + 1;
            } while (r249 < a1);
          }
          r244 = r248 + 1;
        } while (r244 < a2);
      }
    }
    if (depth == 8) {
      let r273 = 0;
      while (r273 < r30) {
        const r274 = r273 << 2;
        const r275 = data[r273];
        const r276 = 3 * r275;
        uint8Array[r274] = PLTE[r276];
        uint8Array[r274 + 1] = PLTE[r276 + 1];
        uint8Array[r274 + 2] = PLTE[r276 + 2];
        const r284 = r275 < r179;
        const r285 = r273;
        uint8Array[r274 + 3] = r284 ? tRNS[r275] : 255;
        r273 = r285 + 1;
      }
    }
  } else if (ctype == 4) {
    if (depth == 8) {
      let r156 = 0;
      while (r156 < r30) {
        const r157 = r156 << 2;
        const r158 = r156 << 1;
        const r159 = data[r158];
        uint8Array[r157] = r159;
        uint8Array[r157 + 1] = r159;
        uint8Array[r157 + 2] = r159;
        uint8Array[r157 + 3] = data[r158 + 1];
        r156 = r156 + 1;
      }
    }
    if (depth == 16) {
      let r167 = 0;
      while (r167 < r30) {
        const r168 = r167 << 2;
        const r169 = data[r168];
        uint8Array[r168] = r169;
        uint8Array[r168 + 1] = r169;
        const r171 = r168 + 2;
        uint8Array[r171] = r169;
        uint8Array[r168 + 3] = data[r171];
        r167 = r167 + 1;
      }
    }
  } else if (ctype == 0) {
    const r66 = a3.tabs.tRNS ? a3.tabs.tRNS : -1;
    const r25 = 0 < a2;
    let r68 = 0;
    if (r25) {
      do {
        const r21 = r68 * r37;
        const r14 = r68 * a1;
        const r9 = r68;
        if (depth == 1) {
          const r135 = 0 < a1;
          let r136 = 0;
          if (r135) {
            do {
              const r144 = 255 * (data[r21 + (r136 >>> 3)] >>> 7 - (7 & r136) & 1);
              const r145 = 255 * r66;
              const r146 = r136;
              uint32Array[r14 + r146] = (r144 === r145 ? 0 : 255) << 24 | r144 << 16 | r144 << 8 | r144;
              r136 = r146 + 1;
            } while (r136 < a1);
          }
        } else if (depth == 2) {
          const r114 = 0 < a1;
          let r115 = 0;
          if (r114) {
            do {
              const r124 = 85 * (data[r21 + (r115 >>> 2)] >>> 6 - ((3 & r115) << 1) & 3);
              const r125 = 85 * r66;
              const r126 = r115;
              uint32Array[r14 + r126] = (r124 === r125 ? 0 : 255) << 24 | r124 << 16 | r124 << 8 | r124;
              r115 = r126 + 1;
            } while (r115 < a1);
          }
        } else if (depth == 4) {
          const r94 = 0 < a1;
          let r95 = 0;
          if (r94) {
            do {
              const r104 = 17 * (data[r21 + (r95 >>> 1)] >>> 4 - ((1 & r95) << 2) & 15);
              const r105 = 17 * r66;
              const r106 = r95;
              uint32Array[r14 + r106] = (r104 === r105 ? 0 : 255) << 24 | r104 << 16 | r104 << 8 | r104;
              r95 = r106 + 1;
            } while (r95 < a1);
          }
        } else if (depth == 8) {
          const r80 = 0 < a1;
          let r81 = 0;
          if (r80) {
            do {
              const r83 = data[r21 + r81];
              const r84 = r83 == r66;
              const r85 = r81;
              uint32Array[r14 + r85] = (r84 ? 0 : 255) << 24 | r83 << 16 | r83 << 8 | r83;
              r81 = r85 + 1;
            } while (r81 < a1);
          }
        } else if (depth == 16) {
          const r69 = 0 < a1;
          let r3 = 0;
          if (r69) {
            do {
              const r70 = r21 + (r3 << 1);
              const r71 = data[r70];
              const r73 = readUshort2(data, r70) == r66;
              const r74 = r3;
              uint32Array[r14 + r74] = (r73 ? 0 : 255) << 24 | r71 << 16 | r71 << 8 | r71;
              r3 = r74 + 1;
            } while (r3 < a1);
          }
        }
        r68 = r9 + 1;
      } while (r68 < a2);
    }
  }
  return uint8Array;
};
_decompress = function _decompress(a0, a1, a2, a3) {
  let r89;
  Date.now();
  const uint8Array2 = new Uint8Array((Math.ceil(a2 * ([1, null, 3, 1, 2, null, 4][a0.ctype] * a0.depth) / 8) + 1 + a0.interlace) * a3);
  const CgBI = a0.tabs.CgBI;
  const r81 = CgBI ? c1595_4(a1, uint8Array2) : c1595_4(new Uint8Array(a1.buffer, 2, a1.length - 6), uint8Array2);
  Date.now();
  if (a0.interlace == 0) {
    _filterZero(r81, a0, 0, a2, a3);
    r89 = r81;
  } else {
    const interlace = a0.interlace;
    r89 = r81;
    if (interlace == 1) {
      const { width, height } = a0;
      const r38 = [1, null, 3, 1, 2, null, 4][a0.ctype] * a0.depth;
      const r14 = r38 >> 3;
      const r37 = Math.ceil(width * r38 / 8);
      const uint8Array = new Uint8Array(height * r37);
      const r102 = [0, 0, 4, 0, 2, 0, 1];
      const r103 = [0, 4, 0, 2, 0, 1, 0];
      const r104 = [8, 8, 8, 4, 4, 2, 2];
      const r105 = [8, 8, 4, 4, 2, 2, 1];
      let r21 = 0;
      let r106 = 0;
      do {
        const r45 = r104[r21];
        const r44 = r105[r21];
        let r42 = r102[r21];
        const r24 = r42 < height;
        const r20 = r21;
        const r19 = r106;
        let r16 = 0;
        let r18 = 0;
        if (r24) {
          do {
            r42 = r42 + r45;
            r16 = r16 + 1;
            r18 = r16;
          } while (r42 < height);
        }
        let r107 = r103[r20];
        const r108 = r107 < width;
        let r12 = 0;
        let r109 = 0;
        if (r108) {
          do {
            r107 = r107 + r44;
            r12 = r12 + 1;
            r109 = r12;
          } while (r107 < width);
        }
        const r113 = Math.ceil(r109 * r38 / 8);
        _filterZero(r81, a0, r19, r109, r18);
        let r120 = r102[r20];
        const r121 = r120 < height;
        let r122 = 0;
        if (r121) {
          do {
            let r47 = r103[r20];
            let r8 = r19 + r122 * r113 << 3;
            const r46 = r120;
            const r124 = r122;
            while (r47 < width) {
              const r5 = r8;
              const r48 = r47;
              if (r38 == 1) {
                const r127 = r81[r5 >> 3] >> 7 - (7 & r5);
                const r129 = r46 * r37 + (r48 >> 3);
                uint8Array[r129] = uint8Array[r129] | (r127 & 1) << 7 - (7 & r48);
              }
              if (r38 == 2) {
                const r139 = r81[r5 >> 3] >> 6 - (7 & r5);
                const r142 = r46 * r37 + (r48 >> 2);
                uint8Array[r142] = uint8Array[r142] | (r139 & 3) << 6 - ((3 & r48) << 1);
              }
              if (r38 == 4) {
                const r154 = r81[r5 >> 3] >> 4 - (7 & r5);
                const r157 = r46 * r37 + (r48 >> 1);
                uint8Array[r157] = uint8Array[r157] | (r154 & 15) << 4 - ((1 & r48) << 2);
              }
              if (r38 >= 8) {
                const r167 = r46 * r37 + r48 * r14;
                const r168 = r5 >> 3;
                let r169 = 0;
                while (r169 < r14) {
                  uint8Array[r167 + r169] = r81[r168 + r169];
                  r169 = r169 + 1;
                }
              }
              r8 = r5 + r38;
              r47 = r48 + r44;
            }
            r122 = r124 + 1;
            r120 = r46 + r45;
          } while (r120 < height);
        }
        const r173 = r109 * r18 !== 0 ? r19 + r18 * (1 + r113) : r19;
        r21 = r20 + 1;
        r106 = r173;
        r89 = uint8Array;
      } while (r21 < 7);
    }
  }
  return r89;
};
_inflate = function _inflate(a0, a1) {
  return c1595_4(new Uint8Array(a0.buffer, 2, a0.length - 6), a1);
};
_filterZero = function _filterZero(a0, a1, a2, a3, a4) {
  const r17 = [1, null, 3, 1, 2, null, 4][a1.ctype] * a1.depth;
  const r35 = Math.ceil(a3 * r17 / 8);
  const r39 = Math.ceil(r17 / 8);
  const r40 = a0[a2];
  if (r40 > 1) {
    a0[a2] = [0, 0, 1][r40 - 2];
  }
  if (r40 == 3) {
    let r46 = r39;
    while (r46 < r35) {
      a0[r46 + 1] = a0[r46 + 1] + (a0[r46 + 1 - r39] >>> 1) & 255;
      r46 = r46 + 1;
    }
  }
  const r11 = 0 < a4;
  let r57 = 0;
  if (r11) {
    do {
      const r58 = a2 + r57 * r35;
      const r60 = r58 + r57 + 1;
      const r62 = a0[r60 - 1];
      const r63 = r57;
      if (r62 == 0) {
        const r131 = 0 < r35;
        let r132 = 0;
        if (r131) {
          do {
            a0[r58 + r132] = a0[r60 + r132];
            r132 = r132 + 1;
          } while (r132 < r35);
        }
      } else if (r62 == 1) {
        const r119 = 0 < r39;
        let r120 = 0;
        let r121 = 0;
        if (r119) {
          do {
            a0[r58 + r120] = a0[r60 + r120];
            r120 = r120 + 1;
            r121 = r120;
          } while (r121 < r39);
        }
        while (r121 < r35) {
          const r125 = r58 + r121;
          a0[r125] = a0[r60 + r121] + a0[r125 - r39];
          r121 = r121 + 1;
        }
      } else if (r62 == 2) {
        const r111 = 0 < r35;
        let r112 = 0;
        if (r111) {
          do {
            const r113 = r58 + r112;
            a0[r113] = a0[r60 + r112] + a0[r113 - r35];
            r112 = r112 + 1;
          } while (r112 < r35);
        }
      } else if (r62 == 3) {
        const r91 = 0 < r39;
        let r92 = 0;
        let r93 = 0;
        if (r91) {
          do {
            const r94 = r58 + r92;
            a0[r94] = a0[r60 + r92] + (a0[r94 - r35] >>> 1);
            r92 = r92 + 1;
            r93 = r92;
          } while (r93 < r39);
        }
        while (r93 < r35) {
          const r101 = r58 + r93;
          a0[r101] = a0[r60 + r93] + (a0[r101 - r35] + a0[r101 - r39] >>> 1);
          r93 = r93 + 1;
        }
      } else {
        const r64 = 0 < r39;
        let r0 = 0;
        let r1 = 0;
        if (r64) {
          do {
            const r20 = r58 + r0;
            const r21 = a0[r60 + r0];
            const r23 = a0[r20 - r35];
            const r67 = 0 + r23 - 0;
            const r5 = r67 - 0;
            const r68 = r67 - r23;
            const r6 = r5 * r5;
            const r69 = r68 * r68;
            const r70 = r0;
            a0[r20] = r21 + (r6 <= r69 ? r6 <= r6 ? 0 : r69 <= r6 ? r23 : 0 : r69 <= r6 ? r23 : 0);
            r0 = r70 + 1;
            r1 = r0;
          } while (r1 < r39);
        }
        while (r1 < r35) {
          const r73 = r58 + r1;
          const r75 = a0[r60 + r1];
          let r77 = a0[r73 - r39];
          const r79 = a0[r73 - r35];
          let r82 = a0[r73 - r39 - r35];
          const r83 = r77 + r79 - r82;
          const r26 = r83 - r77;
          const r25 = r83 - r79;
          const r84 = r83 - r82;
          const r28 = r26 * r26;
          const r27 = r25 * r25;
          const r85 = r1;
          if (!(r28 <= r27 && r26 * r26 <= r84 * r84)) {
            if (r25 * r25 <= r84 * r84) {
              r82 = r79;
            }
            r77 = r82;
          }
          a0[r73] = r75 + r77;
          r1 = r85 + 1;
        }
      }
      r57 = r63 + 1;
    } while (r57 < a4);
  }
  return a0;
};
_IHDR = function _IHDR(uint8Array, a1, a2) {
  a2.width = c1595_0.readUint(uint8Array, a1);
  const r10 = a1 + 4;
  a2.height = c1595_0.readUint(uint8Array, r10);
  const r13 = r10 + 4;
  a2.depth = uint8Array[r13];
  const r15 = r13 + 1;
  a2.ctype = uint8Array[r15];
  const r17 = r15 + 1;
  a2.compress = uint8Array[r17];
  const r19 = r17 + 1;
  a2.filter = uint8Array[r19];
  a2.interlace = uint8Array[r19 + 1];
};
_copyTile = function _copyTile(uint8Array2, width2, height2, uint8Array, width, height, a6, a7, a8) {
  let r2, r56;
  const r45 = Math.min(width2, width);
  const r48 = Math.min(height2, height);
  const r27 = 0 < r48;
  let r23 = 0;
  if (r27) {
    do {
      const r49 = 0 < r45;
      const r13 = r23;
      let r12 = 0;
      if (r49) {
        do {
          const r11 = r12;
          if (a6 >= 0 && a7 >= 0) {
            r2 = r13 * width2 + r11 << 2;
            r56 = (a7 + r13) * width + a6 + r11 << 2;
          } else {
            r2 = (-a7 + r13) * width2 - a6 + r11 << 2;
            r56 = r13 * width + r11 << 2;
          }
          L27: {
            if (a8 == 0) {
              uint8Array[r56] = uint8Array2[r2];
              uint8Array[r56 + 1] = uint8Array2[r2 + 1];
              uint8Array[r56 + 2] = uint8Array2[r2 + 2];
              uint8Array[r56 + 3] = uint8Array2[r2 + 3];
            } else if (a8 == 1) {
              const r6 = 0.00392156862745098 * uint8Array2[r2 + 3];
              const r14 = uint8Array2[r2] * r6;
              const r18 = uint8Array2[r2 + 1] * r6;
              const r21 = uint8Array2[r2 + 2] * r6;
              const r17 = r56 + 3;
              const r92 = 0.00392156862745098 * uint8Array[r17];
              const r8 = uint8Array[r56] * r92;
              const r19 = r56 + 1;
              const r9 = uint8Array[r19] * r92;
              const r95 = r56 + 2;
              const r20 = uint8Array[r95] * r92;
              const r97 = 1 - r6;
              const r99 = r6 + r92 * r97;
              const r100 = r99 !== 0 ? 1 / r99 : 0;
              uint8Array[r17] = 255 * r99;
              uint8Array[r56 + 0] = (r14 + r8 * r97) * r100;
              uint8Array[r19] = (r18 + r9 * r97) * r100;
              uint8Array[r95] = (r21 + r20 * r97) * r100;
            } else if (a8 == 2) {
              const r72 = uint8Array2[r2 + 3];
              const r73 = uint8Array2[r2];
              const r75 = uint8Array2[r2 + 1];
              const r77 = uint8Array2[r2 + 2];
              const r78 = r56 + 3;
              const r79 = uint8Array[r78];
              const r80 = uint8Array[r56];
              const r3 = r56 + 1;
              const r81 = uint8Array[r3];
              const r82 = r56 + 2;
              const r83 = uint8Array[r82];
              if (r72 == r79 && r73 == r80 && r75 == r81 && r77 == r83) {
                uint8Array[r56] = 0;
                uint8Array[r3] = 0;
                uint8Array[r82] = 0;
                uint8Array[r78] = 0;
                break L27;
              }
              uint8Array[r56] = r73;
              uint8Array[r3] = r75;
              uint8Array[r82] = r77;
              uint8Array[r78] = r72;
            } else if (a8 == 3) {
              const r62 = uint8Array2[r2 + 3];
              const r44 = uint8Array2[r2];
              const r42 = uint8Array2[r2 + 1];
              const r40 = uint8Array2[r2 + 2];
              const r66 = uint8Array[r56 + 3];
              const r43 = uint8Array[r56];
              const r41 = uint8Array[r56 + 1];
              const r69 = uint8Array[r56 + 2];
              if (r62 == r66 && r44 == r43 && r42 == r41 && r40 == r69) {
                break L27;
              }
              if (r62 < 220 && r66 > 20) {
                return false;
              }
            }
          }
          r12 = r11 + 1;
        } while (r12 < r45);
      }
      r23 = r13 + 1;
    } while (r23 < r48);
  }
  return true;
};
c1595_0 = {
  nextZero: function nextZero(a0, a1) {
    let r7;
    const r2 = a0[a1];
    let r3 = a1;
    let r6 = a1;
    if (r2 != 0) {
      do {
        const r5 = r3 + 1;
        r7 = a0[r5];
        r3 = r5;
        r6 = r3;
      } while (r7 != 0);
    }
    return r6;
  },
  readUshort: function readUshort(a0, a1) {
    return a0[a1] << 8 | a0[a1 + 1];
  },
  writeUshort: function writeUshort(a0, a1, a2) {
    a0[a1] = a2 >> 8 & 255;
    a0[a1 + 1] = 255 & a2;
  },
  readUint: function readUint(a0, a1) {
    return 16777216 * a0[a1] + (a0[a1 + 1] << 16 | a0[a1 + 2] << 8 | a0[a1 + 3]);
  },
  writeUint: function writeUint(a0, a1, a2) {
    a0[a1] = a2 >> 24 & 255;
    a0[a1 + 1] = a2 >> 16 & 255;
    a0[a1 + 2] = a2 >> 8 & 255;
    a0[a1 + 3] = 255 & a2;
  },
  readASCII: function readASCII(a0, a1, a2) {
    let r0 = 0;
    const r3 = 0 < a2;
    let r5 = "";
    let r4 = "";
    if (r3) {
      do {
        r5 = r5 + String.fromCharCode(a0[a1 + r0]);
        r0 = r0 + 1;
        r4 = r5;
      } while (r0 < a2);
    }
    return r4;
  },
  writeASCII: function writeASCII(a0, a1, a2) {
    const length = a2.length;
    let r0 = 0;
    if (0 < length) {
      do {
        a0[a1 + r0] = a2.charCodeAt(r0);
        r0 = r0 + 1;
      } while (r0 < a2.length);
    }
  },
  readBytes: function readBytes(a0, a1, a2) {
    const r4 = [];
    let r0 = 0;
    while (r0 < a2) {
      r4.push(a0[a1 + r0]);
      r0 = r0 + 1;
    }
    return r4;
  },
  pad: function pad(a0) {
    return a0.length < 2 ? "0" + a0 : a0;
  },
  readUTF8: function readUTF8(a0, a1, a2) {
    let r23;
    let r11 = 0;
    const r12 = 0 < a2;
    let r5 = "";
    let r6 = "";
    if (r12) {
      do {
        r5 = r5 + ("%" + c1595_0.pad(a0[a1 + r11].toString(16)));
        r11 = r11 + 1;
        r6 = r5;
      } while (r11 < a2);
    }
    try {
      r23 = decodeURIComponent(r6);
    } catch ($e) {
      return c1595_0.readASCII(a0, a1, a2);
    }
    return r23;
  }
};
const r29 = Uint16Array;
const r30 = Uint32Array;
c1596_0 = {
  m: new r29(16),
  v: new r29(16),
  d: [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15],
  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],
  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],
  B: new r29(32),
  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],
  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],
  h: new r30(32),
  g: new r29(512),
  s: [],
  A: new r29(32),
  t: [],
  k: new r29(32768),
  c: [],
  a: [],
  n: new r29(32768),
  e: [],
  C: new r29(512),
  b: [],
  i: new r29(32768),
  r: new r30(286),
  f: new r30(30),
  l: new r30(19),
  u: new r30(15000),
  q: new r29(65536),
  j: new r29(32768)
};
let r1 = 0;
while (true) {
  const r139 = (2863311530 & r1) >>> 1 | (1431655765 & r1) << 1;
  const r144 = (3435973836 & r139) >>> 2 | (858993459 & r139) << 2;
  const r149 = (4042322160 & r144) >>> 4 | (252645135 & r144) << 4;
  const r154 = (4278255360 & r149) >>> 8 | (16711935 & r149) << 8;
  c1596_0.i[r1] = (r154 >>> 16 | r154 << 16) >>> 17;
  r1 = r1 + 1;
  let r160 = 0;
  if (!(r1 < 32768)) {
    while (true) {
      c1596_0.B[r160] = c1596_0.o[r160] << 3 | c1596_0.z[r160];
      c1596_0.h[r160] = c1596_0.p[r160] << 4 | c1596_0.w[r160];
      r160 = r160 + 1;
      if (!(r160 < 32)) {
        const r175 = c1596_0.s;
        let r176 = 143;
        while (true) {
          r175.push(0, 8);
          const r179 = r176 - 1;
          const r180 = r176;
          r176 = r179;
          if (r180 === 0) {
            const r181 = c1596_0.s;
            let r182 = 111;
            while (true) {
              r181.push(0, 9);
              const r186 = r182 - 1;
              const r187 = r182;
              r182 = r186;
              if (r187 === 0) {
                const r188 = c1596_0.s;
                let r189 = 23;
                while (true) {
                  r188.push(0, 7);
                  const r193 = r189 - 1;
                  const r194 = r189;
                  r189 = r193;
                  if (r194 === 0) {
                    const r195 = c1596_0.s;
                    let r196 = 7;
                    while (true) {
                      r195.push(0, 8);
                      const r199 = r196 - 1;
                      const r200 = r196;
                      r196 = r199;
                      if (r200 === 0) {
                        const r201 = c1596_0.s;
                        const length = r201.length;
                        const r203 = c1596_0.v;
                        let r204 = 0;
                        while (true) {
                          r203[r204] = 0;
                          r204 = r204 + 1;
                          if (!(r204 <= 9)) {
                            const r22 = 1 < length;
                            let r205 = 1;
                            if (r22) {
                              do {
                                const r33 = r201[r205];
                                r203[r33] = r203[r33] + 1;
                                r205 = r205 + 2;
                              } while (r205 < length);
                            }
                            const r208 = c1596_0.m;
                            r203[0] = 0;
                            let r209 = 1;
                            let r210 = 0;
                            while (true) {
                              const r214 = r210 + r203[r209 - 1] << 1;
                              r208[r209] = r214;
                              r209 = r209 + 1;
                              r210 = r214;
                              if (!(r209 <= 9)) {
                                const r215 = 0 < length;
                                let r216 = 0;
                                if (r215) {
                                  do {
                                    const r218 = r201[r216 + 1];
                                    const r219 = r216;
                                    if (r218 != 0) {
                                      r201[r219] = r208[r218];
                                      r208[r218] = r208[r218] + 1;
                                    }
                                    r216 = r219 + 2;
                                  } while (r216 < length);
                                }
                                const { s: r223, g: r224 } = c1596_0;
                                const length2 = r223.length;
                                const r226 = c1596_0.i;
                                const r227 = 0 < length2;
                                let r229 = 0;
                                if (r227) {
                                  do {
                                    const r230 = r229 + 1;
                                    const r231 = r223[r230];
                                    const r232 = r229;
                                    if (r231 != 0) {
                                      const r233 = r223[r230];
                                      const r236 = r232 >> 1 << 4 | r233;
                                      const r237 = 9 - r233;
                                      let r239 = r223[r232] << r237;
                                      const r241 = r239 + (1 << r237);
                                      while (r239 !== r241) {
                                        r224[r226[r239] >>> 6] = r236;
                                        r239 = r239 + 1;
                                      }
                                    }
                                    r229 = r232 + 2;
                                  } while (r229 < length2);
                                }
                                const { s: r244, i: r245 } = c1596_0;
                                const r247 = 0 < r244.length;
                                let r248 = 0;
                                if (r247) {
                                  do {
                                    r244[r248] = r245[r244[r248] << 9 - r244[r248 + 1]] >>> 6;
                                    r248 = r248 + 2;
                                  } while (r248 < r244.length);
                                }
                                const r257 = c1596_0.t;
                                let r258 = 31;
                                while (true) {
                                  r257.push(0, 5);
                                  const r262 = r258 - 1;
                                  const r263 = r258;
                                  r258 = r262;
                                  if (r263 === 0) {
                                    const r264 = c1596_0.t;
                                    const length3 = r264.length;
                                    const r266 = c1596_0.v;
                                    let r267 = 0;
                                    while (true) {
                                      r266[r267] = 0;
                                      r267 = r267 + 1;
                                      if (!(r267 <= 5)) {
                                        const r268 = 1 < length3;
                                        let r269 = 1;
                                        if (r268) {
                                          do {
                                            const r270 = r264[r269];
                                            r266[r270] = r266[r270] + 1;
                                            r269 = r269 + 2;
                                          } while (r269 < length3);
                                        }
                                        const r273 = c1596_0.m;
                                        r266[0] = 0;
                                        let r274 = 1;
                                        let r275 = 0;
                                        while (true) {
                                          const r279 = r275 + r266[r274 - 1] << 1;
                                          r273[r274] = r279;
                                          r274 = r274 + 1;
                                          r275 = r279;
                                          if (!(r274 <= 5)) {
                                            const r280 = 0 < length3;
                                            let r281 = 0;
                                            if (r280) {
                                              do {
                                                const r283 = r264[r281 + 1];
                                                const r284 = r281;
                                                if (r283 != 0) {
                                                  r264[r284] = r273[r283];
                                                  r273[r283] = r273[r283] + 1;
                                                }
                                                r281 = r284 + 2;
                                              } while (r281 < length3);
                                            }
                                            const { t: r288, A: r289 } = c1596_0;
                                            const length4 = r288.length;
                                            const r291 = c1596_0.i;
                                            const r292 = 0 < length4;
                                            let r294 = 0;
                                            if (r292) {
                                              do {
                                                const r295 = r294 + 1;
                                                const r296 = r288[r295];
                                                const r297 = r294;
                                                if (r296 != 0) {
                                                  const r298 = r288[r295];
                                                  const r301 = r297 >> 1 << 4 | r298;
                                                  const r302 = 5 - r298;
                                                  let r304 = r288[r297] << r302;
                                                  const r306 = r304 + (1 << r302);
                                                  while (r304 !== r306) {
                                                    r289[r291[r304] >>> 10] = r301;
                                                    r304 = r304 + 1;
                                                  }
                                                }
                                                r294 = r297 + 2;
                                              } while (r294 < length4);
                                            }
                                            const { t: r309, i: r310 } = c1596_0;
                                            const r312 = 0 < r309.length;
                                            let r313 = 0;
                                            if (r312) {
                                              do {
                                                r309[r313] = r310[r309[r313] << 5 - r309[r313 + 1]] >>> 10;
                                                r313 = r313 + 2;
                                              } while (r313 < r309.length);
                                            }
                                            const r322 = c1596_0.b;
                                            let r323 = 18;
                                            while (true) {
                                              r322.push(0, 0);
                                              const r326 = r323 - 1;
                                              const r327 = r323;
                                              r323 = r326;
                                              if (r327 === 0) {
                                                const r328 = c1596_0.c;
                                                let r329 = 285;
                                                while (true) {
                                                  r328.push(0, 0);
                                                  const r332 = r329 - 1;
                                                  const r333 = r329;
                                                  r329 = r332;
                                                  if (r333 === 0) {
                                                    const r334 = c1596_0.e;
                                                    let r335 = 29;
                                                    while (true) {
                                                      r334.push(0, 0);
                                                      const r338 = r335 - 1;
                                                      const r339 = r335;
                                                      r335 = r338;
                                                      if (r339 === 0) {
                                                        const r340 = c1596_0.a;
                                                        let r341 = 319;
                                                        while (true) {
                                                          r340.push(0, 0);
                                                          const r344 = r341 - 1;
                                                          const r345 = r341;
                                                          r341 = r344;
                                                          if (r345 === 0) {
                                                            let _copyTile2, _bin, _paeth2, c1597_3, dither2, _main2, compressPNG2, compress2, _updateFrame2, quantize2, findNearest2, getKDtree2, getNearest2, vecDot2, stats2, estats2, c1597_16;
                                                            const _paeth = function _paeth(a0, a1, a2) {
                                                              let r0 = a0;
                                                              let r1 = a2;
                                                              const r8 = a0 + a1 - a2;
                                                              const r5 = r8 - a0;
                                                              const r4 = r8 - a1;
                                                              const r9 = r8 - a2;
                                                              if (!(r5 * r5 <= r4 * r4 && r5 * r5 <= r9 * r9)) {
                                                                if (r4 * r4 <= r9 * r9) {
                                                                  r1 = a1;
                                                                }
                                                                r0 = r1;
                                                              }
                                                              return r0;
                                                            };
                                                            c1595_4 = function v(a0, a1) {
                                                              let r18, r30, r31, r32, r43, r44, r45, r141, r142, r143, r144, r158, r159, r160, r285, r286, r316, r317;
                                                              let r59 = a1;
                                                              const r60 = Uint8Array;
                                                              if (a0[0] == 3 && a0[1] == 0) {
                                                                if (!a1) {
                                                                  r59 = new r60(0);
                                                                }
                                                                return r59;
                                                              }
                                                              const r89 = a1 == null;
                                                              let r73 = r89 ? new r60(a0.length >>> 2 << 3) : a1;
                                                              let r71 = void 0;
                                                              let r38 = 0;
                                                              let r39 = 0;
                                                              let r40 = 0;
                                                              let r41 = 0;
                                                              let r70 = void 0;
                                                              while (true) {
                                                                L107: {
                                                                  const r93 = r38 >>> 3;
                                                                  r43 = a0[r93] | a0[1 + r93] << 8;
                                                                  r44 = a0[2 + r93] << 16;
                                                                  const r99 = r38 + 1;
                                                                  const r100 = r99 >>> 3;
                                                                  const r10 = (a0[r100] | a0[1 + r100] << 8 | a0[2 + r100] << 16) >>> (7 & r99) & 3;
                                                                  const r11 = r38 + 3;
                                                                  r45 = r38;
                                                                  const r27 = r39;
                                                                  let r17 = r40;
                                                                  let r111 = r41;
                                                                  let r63 = r71;
                                                                  let r112 = r70;
                                                                  const r69 = r73;
                                                                  if (r10 !== 0) {
                                                                    let r79 = r69;
                                                                    if (r89) {
                                                                      const r145 = r27 + 131072;
                                                                      const length2 = r69.length;
                                                                      let r146 = r69;
                                                                      if (!(r145 <= length2)) {
                                                                        const uint8Array2 = new Uint8Array(Math.max(length2 << 1, r145));
                                                                        uint8Array2.set(r69, 0);
                                                                        r146 = uint8Array2;
                                                                      }
                                                                      r79 = r146;
                                                                    }
                                                                    if (r10 === 1) {
                                                                      r112 = c1596_0.g;
                                                                      r63 = c1596_0.A;
                                                                      r17 = 31;
                                                                      r111 = 511;
                                                                    }
                                                                    L96: {
                                                                      r158 = r11;
                                                                      r159 = r27;
                                                                      r160 = r79;
                                                                      if (r10 === 2) {
                                                                        const r161 = r11 >>> 3;
                                                                        const r9 = a0[r161] | a0[1 + r161] << 8;
                                                                        const r23 = r11 + 5;
                                                                        const r166 = r23 >>> 3;
                                                                        const r2 = a0[r166] | a0[1 + r166] << 8;
                                                                        const r171 = r11 + 10;
                                                                        const r172 = r171 >>> 3;
                                                                        const r177 = a0[r172] | a0[1 + r172] << 8;
                                                                        let r6 = 0;
                                                                        while (true) {
                                                                          c1596_0.b[r6] = 0;
                                                                          c1596_0.b[r6 + 1] = 0;
                                                                          r6 = r6 + 2;
                                                                          if (!(r6 < 38)) {
                                                                            const r184 = (r177 >>> (7 & r171) & 15) + 4;
                                                                            const r185 = r11 + 14;
                                                                            let r1 = 0;
                                                                            let r186 = 1;
                                                                            let r187 = 1;
                                                                            while (r1 < r184) {
                                                                              const r188 = r185 + 3 * r1;
                                                                              const r5 = r188 >>> 3;
                                                                              const r8 = (a0[r5] | a0[1 + r5] << 8) >>> (7 & r188) & 7;
                                                                              c1596_0.b[1 + (c1596_0.d[r1] << 1)] = r8;
                                                                              const r202 = r1;
                                                                              let r203 = r186;
                                                                              if (r203 < r8) {
                                                                                r203 = r8;
                                                                              }
                                                                              r1 = r202 + 1;
                                                                              r186 = r203;
                                                                              r187 = r186;
                                                                            }
                                                                            const r205 = c1596_0.b;
                                                                            const length3 = r205.length;
                                                                            const r207 = c1596_0.v;
                                                                            let r208 = 0;
                                                                            while (r208 <= r187) {
                                                                              r207[r208] = 0;
                                                                              r208 = r208 + 1;
                                                                            }
                                                                            const r57 = 1 < length3;
                                                                            let r209 = 1;
                                                                            if (r57) {
                                                                              do {
                                                                                const r78 = r205[r209];
                                                                                r207[r78] = r207[r78] + 1;
                                                                                r209 = r209 + 2;
                                                                              } while (r209 < length3);
                                                                            }
                                                                            const r213 = c1596_0.m;
                                                                            r207[0] = 0;
                                                                            let r214 = 1;
                                                                            let r215 = 0;
                                                                            while (r214 <= r187) {
                                                                              const r219 = r215 + r207[r214 - 1] << 1;
                                                                              r213[r214] = r219;
                                                                              r214 = r214 + 1;
                                                                              r215 = r219;
                                                                            }
                                                                            const r220 = 0 < length3;
                                                                            let r221 = 0;
                                                                            if (r220) {
                                                                              do {
                                                                                const r223 = r205[r221 + 1];
                                                                                const r224 = r221;
                                                                                if (r223 != 0) {
                                                                                  r205[r224] = r213[r223];
                                                                                  r213[r223] = r213[r223] + 1;
                                                                                }
                                                                                r221 = r224 + 2;
                                                                              } while (r221 < length3);
                                                                            }
                                                                            const { b: r228, C: r229 } = c1596_0;
                                                                            const length4 = r228.length;
                                                                            const r232 = c1596_0.i;
                                                                            const r233 = 0 < length4;
                                                                            const r234 = 15 - r187;
                                                                            let r235 = 0;
                                                                            if (r233) {
                                                                              do {
                                                                                const r236 = r235 + 1;
                                                                                const r237 = r228[r236];
                                                                                const r238 = r235;
                                                                                if (r237 != 0) {
                                                                                  const r239 = r228[r236];
                                                                                  const r7 = r238 >> 1 << 4 | r239;
                                                                                  const r242 = r187 - r239;
                                                                                  let r244 = r228[r238] << r242;
                                                                                  const r246 = r244 + (1 << r242);
                                                                                  while (r244 !== r246) {
                                                                                    r229[r232[r244] >>> r234] = r7;
                                                                                    r244 = r244 + 1;
                                                                                  }
                                                                                }
                                                                                r235 = r238 + 2;
                                                                              } while (r235 < length4);
                                                                            }
                                                                            const r251 = (r9 >>> (7 & r11) & 31) + 257;
                                                                            const r255 = (r2 >>> (7 & r23) & 31) + 1;
                                                                            const r257 = r185 + 3 * r184;
                                                                            const { k: r258, n: r259, C: r260 } = c1596_0;
                                                                            const r262 = (1 << r187) - 1;
                                                                            const r263 = r251 + r255;
                                                                            const r264 = c1596_0.a;
                                                                            let r265 = 0;
                                                                            let r266 = r257;
                                                                            let r267 = r266;
                                                                            while (r265 < r263) {
                                                                              const r268 = r266 >>> 3;
                                                                              const r280 = r260[(a0[r268] | a0[1 + r268] << 8 | a0[2 + r268] << 16) >>> (7 & r266) & r262];
                                                                              const r282 = r266 + (15 & r280);
                                                                              const r283 = r280 >>> 4;
                                                                              const r284 = r265;
                                                                              if (r283 <= 15) {
                                                                                r264[r284] = r283;
                                                                                r317 = r284 + 1;
                                                                                r316 = r282;
                                                                              } else {
                                                                                if (r283 === 16) {
                                                                                  const r304 = r282 >>> 3;
                                                                                  r285 = 3 + ((a0[r304] | a0[1 + r304] << 8) >>> (7 & r282) & 3);
                                                                                  r18 = r282 + 2;
                                                                                  r286 = r264[r284 - 1];
                                                                                } else if (r283 === 17) {
                                                                                  const r295 = r282 >>> 3;
                                                                                  r285 = 3 + ((a0[r295] | a0[1 + r295] << 8) >>> (7 & r282) & 7);
                                                                                  r18 = r282 + 3;
                                                                                  r286 = 0;
                                                                                } else {
                                                                                  r285 = 0;
                                                                                  r286 = 0;
                                                                                  r18 = r282;
                                                                                  if (r283 === 18) {
                                                                                    const r287 = r282 >>> 3;
                                                                                    r285 = 11 + ((a0[r287] | a0[1 + r287] << 8) >>> (7 & r282) & 127);
                                                                                    r18 = r282 + 7;
                                                                                    r286 = 0;
                                                                                  }
                                                                                }
                                                                                const r314 = r284 + r285;
                                                                                let r315 = r284;
                                                                                r316 = r18;
                                                                                r317 = r315;
                                                                                while (r317 < r314) {
                                                                                  r264[r315] = r286;
                                                                                  r315 = r315 + 1;
                                                                                  r316 = r18;
                                                                                  r317 = r315;
                                                                                }
                                                                              }
                                                                              r265 = r317;
                                                                              r266 = r316;
                                                                              r267 = r266;
                                                                            }
                                                                            const { a: r318, c: r319 } = c1596_0;
                                                                            const r321 = r319.length >>> 1;
                                                                            let r322 = 0;
                                                                            let r323 = 0;
                                                                            let r324 = 0;
                                                                            let r325 = 0;
                                                                            while (r324 < r251) {
                                                                              const r82 = r318[r322 + 0];
                                                                              const r327 = r322 << 1;
                                                                              r319[r327] = 0;
                                                                              r319[1 + r327] = r82;
                                                                              const r329 = r322;
                                                                              let r330 = r323;
                                                                              if (r82 > r330) {
                                                                                r330 = r82;
                                                                              }
                                                                              r322 = r329 + 1;
                                                                              r323 = r330;
                                                                              r325 = r323;
                                                                              r324 = r322;
                                                                            }
                                                                            while (r324 < r321) {
                                                                              const r331 = r324 << 1;
                                                                              r319[r331] = 0;
                                                                              r319[1 + r331] = 0;
                                                                              r324 = r324 + 1;
                                                                            }
                                                                            const r333 = 1 << r325;
                                                                            const { a: r334, e: r335 } = c1596_0;
                                                                            const r337 = r335.length >>> 1;
                                                                            let r338 = 0;
                                                                            let r339 = 0;
                                                                            let r340 = 0;
                                                                            let r341 = 0;
                                                                            while (r340 < r255) {
                                                                              const r83 = r334[r338 + r251];
                                                                              const r343 = r338 << 1;
                                                                              r335[r343] = 0;
                                                                              r335[1 + r343] = r83;
                                                                              const r345 = r338;
                                                                              let r346 = r339;
                                                                              if (r83 > r346) {
                                                                                r346 = r83;
                                                                              }
                                                                              r338 = r345 + 1;
                                                                              r339 = r346;
                                                                              r341 = r339;
                                                                              r340 = r338;
                                                                            }
                                                                            while (r340 < r337) {
                                                                              const r347 = r340 << 1;
                                                                              r335[r347] = 0;
                                                                              r335[1 + r347] = 0;
                                                                              r340 = r340 + 1;
                                                                            }
                                                                            const r349 = 1 << r341;
                                                                            const r350 = c1596_0.c;
                                                                            const length5 = r350.length;
                                                                            const r353 = c1596_0.v;
                                                                            const r354 = 0 <= r325;
                                                                            let r355 = 0;
                                                                            if (r354) {
                                                                              do {
                                                                                r353[r355] = 0;
                                                                                r355 = r355 + 1;
                                                                              } while (r355 <= r325);
                                                                            }
                                                                            const r356 = 1 < length5;
                                                                            let r357 = 1;
                                                                            if (r356) {
                                                                              do {
                                                                                const r358 = r350[r357];
                                                                                r353[r358] = r353[r358] + 1;
                                                                                r357 = r357 + 2;
                                                                              } while (r357 < length5);
                                                                            }
                                                                            const r362 = c1596_0.m;
                                                                            r353[0] = 0;
                                                                            const r363 = 1 <= r325;
                                                                            let r364 = 1;
                                                                            let r365 = 0;
                                                                            if (r363) {
                                                                              do {
                                                                                const r369 = r365 + r353[r364 - 1] << 1;
                                                                                r362[r364] = r369;
                                                                                r364 = r364 + 1;
                                                                                r365 = r369;
                                                                              } while (r364 <= r325);
                                                                            }
                                                                            const r370 = 0 < length5;
                                                                            let r371 = 0;
                                                                            if (r370) {
                                                                              do {
                                                                                const r373 = r350[r371 + 1];
                                                                                const r374 = r371;
                                                                                if (r373 != 0) {
                                                                                  r350[r374] = r362[r373];
                                                                                  r362[r373] = r362[r373] + 1;
                                                                                }
                                                                                r371 = r374 + 2;
                                                                              } while (r371 < length5);
                                                                            }
                                                                            const r378 = c1596_0.c;
                                                                            const length6 = r378.length;
                                                                            const r381 = c1596_0.i;
                                                                            const r382 = 0 < length6;
                                                                            let r383 = 0;
                                                                            if (r382) {
                                                                              do {
                                                                                const r384 = r383 + 1;
                                                                                const r385 = r378[r384];
                                                                                const r386 = r383;
                                                                                if (r385 != 0) {
                                                                                  const r387 = r378[r384];
                                                                                  const r390 = r386 >> 1 << 4 | r387;
                                                                                  const r391 = r325 - r387;
                                                                                  let r393 = r378[r386] << r391;
                                                                                  const r395 = r393 + (1 << r391);
                                                                                  while (r393 != r395) {
                                                                                    r258[r381[r393] >>> 15 - r325] = r390;
                                                                                    r393 = r393 + 1;
                                                                                  }
                                                                                }
                                                                                r383 = r386 + 2;
                                                                              } while (r383 < length6);
                                                                            }
                                                                            const r399 = c1596_0.e;
                                                                            const length7 = r399.length;
                                                                            const r402 = c1596_0.v;
                                                                            const r403 = 0 <= r341;
                                                                            let r404 = 0;
                                                                            if (r403) {
                                                                              do {
                                                                                r402[r404] = 0;
                                                                                r404 = r404 + 1;
                                                                              } while (r404 <= r341);
                                                                            }
                                                                            const r405 = 1 < length7;
                                                                            let r406 = 1;
                                                                            if (r405) {
                                                                              do {
                                                                                const r407 = r399[r406];
                                                                                r402[r407] = r402[r407] + 1;
                                                                                r406 = r406 + 2;
                                                                              } while (r406 < length7);
                                                                            }
                                                                            const r411 = c1596_0.m;
                                                                            r402[0] = 0;
                                                                            const r412 = 1 <= r341;
                                                                            let r413 = 1;
                                                                            let r414 = 0;
                                                                            if (r412) {
                                                                              do {
                                                                                const r418 = r414 + r402[r413 - 1] << 1;
                                                                                r411[r413] = r418;
                                                                                r413 = r413 + 1;
                                                                                r414 = r418;
                                                                              } while (r413 <= r341);
                                                                            }
                                                                            const r419 = 0 < length7;
                                                                            let r420 = 0;
                                                                            if (r419) {
                                                                              do {
                                                                                const r422 = r399[r420 + 1];
                                                                                const r423 = r420;
                                                                                if (r422 != 0) {
                                                                                  r399[r423] = r411[r422];
                                                                                  r411[r422] = r411[r422] + 1;
                                                                                }
                                                                                r420 = r423 + 2;
                                                                              } while (r420 < length7);
                                                                            }
                                                                            const r427 = r333 - 1;
                                                                            const r428 = r349 - 1;
                                                                            const r429 = c1596_0.e;
                                                                            const length8 = r429.length;
                                                                            const r432 = c1596_0.i;
                                                                            const r433 = 0 < length8;
                                                                            let r434 = 0;
                                                                            r158 = r267;
                                                                            r159 = r27;
                                                                            r17 = r428;
                                                                            r111 = r427;
                                                                            r63 = r259;
                                                                            r112 = r258;
                                                                            r160 = r79;
                                                                            if (!r433) {
                                                                              break;
                                                                            }
                                                                            while (true) {
                                                                              const r435 = r434 + 1;
                                                                              const r436 = r429[r435];
                                                                              const r437 = r434;
                                                                              if (r436 != 0) {
                                                                                const r438 = r429[r435];
                                                                                const r441 = r437 >> 1 << 4 | r438;
                                                                                const r442 = r341 - r438;
                                                                                let r444 = r429[r437] << r442;
                                                                                const r446 = r444 + (1 << r442);
                                                                                while (r444 != r446) {
                                                                                  r259[r432[r444] >>> 15 - r341] = r441;
                                                                                  r444 = r444 + 1;
                                                                                }
                                                                              }
                                                                              r434 = r437 + 2;
                                                                              r158 = r267;
                                                                              r159 = r27;
                                                                              r17 = r428;
                                                                              r111 = r427;
                                                                              r63 = r259;
                                                                              r112 = r258;
                                                                              r160 = r79;
                                                                              if (!(r434 < length8)) {
                                                                                break L96;
                                                                              }
                                                                            }
                                                                          }
                                                                        }
                                                                      }
                                                                    }
                                                                    loop96: while (true) {
                                                                      const r450 = r158 >>> 3;
                                                                      const r463 = r112[(a0[r450] | a0[1 + r450] << 8 | a0[2 + r450] << 16) >>> (7 & r158) & r111];
                                                                      const r465 = r158 + (15 & r463);
                                                                      const r466 = r463 >>> 4;
                                                                      const r467 = r466 >>> 8;
                                                                      const r468 = r159;
                                                                      const r469 = r17;
                                                                      const r470 = r111;
                                                                      const r471 = r63;
                                                                      const r472 = r112;
                                                                      const r473 = r160;
                                                                      if (r467 === 0) {
                                                                        r159 = r468 + 1;
                                                                        r473[r468] = r466;
                                                                        r158 = r465;
                                                                        r17 = r469;
                                                                        r111 = r470;
                                                                        r63 = r471;
                                                                        r112 = r472;
                                                                        r160 = r473;
                                                                      } else {
                                                                        r30 = r465;
                                                                        r141 = r468;
                                                                        r31 = r469;
                                                                        r32 = r470;
                                                                        r143 = r471;
                                                                        r144 = r472;
                                                                        r142 = r473;
                                                                        if (r466 === 256) {
                                                                          break L107;
                                                                        }
                                                                        let r475 = r468 + r466 - 254;
                                                                        let r476 = r465;
                                                                        if (264 < r466) {
                                                                          const r480 = c1596_0.B[r466 - 257];
                                                                          const r481 = r480 >>> 3;
                                                                          const r482 = 7 & r480;
                                                                          const r483 = r465 >>> 3;
                                                                          r475 = r468 + r481 + ((a0[r483] | a0[1 + r483] << 8) >>> (7 & r465) & (1 << r482) - 1);
                                                                          r476 = r465 + (7 & r480);
                                                                        }
                                                                        const r496 = r476 >>> 3;
                                                                        const r509 = r471[(a0[r496] | a0[1 + r496] << 8 | a0[2 + r496] << 16) >>> (7 & r476) & r469];
                                                                        const r511 = r476 + (15 & r509);
                                                                        const r515 = c1596_0.h[r509 >>> 4];
                                                                        const r516 = r515 >>> 4;
                                                                        const r517 = 15 & r515;
                                                                        const r518 = r511 >>> 3;
                                                                        const r533 = r516 + ((a0[r518] | a0[1 + r518] << 8 | a0[2 + r518] << 16) >>> (7 & r511) & (1 << r517) - 1);
                                                                        const r534 = 15 & r515;
                                                                        let r535 = r473;
                                                                        if (r89) {
                                                                          const r536 = r468 + 131072;
                                                                          const length9 = r473.length;
                                                                          let r538 = r473;
                                                                          if (!(r536 <= length9)) {
                                                                            const uint8Array3 = new Uint8Array(Math.max(length9 << 1, r536));
                                                                            uint8Array3.set(r473, 0);
                                                                            r538 = uint8Array3;
                                                                          }
                                                                          r535 = r538;
                                                                        }
                                                                        const r550 = r511 + r534;
                                                                        r158 = r550;
                                                                        r159 = r475;
                                                                        r17 = r469;
                                                                        r111 = r470;
                                                                        r63 = r471;
                                                                        r112 = r472;
                                                                        r160 = r535;
                                                                        let r551 = r468;
                                                                        if (r468 < r475) {
                                                                          while (true) {
                                                                            const r552 = r551 + 1;
                                                                            r535[r551] = r535[r551 - r533];
                                                                            const r555 = r552 + 1;
                                                                            r535[r552] = r535[r552 - r533];
                                                                            const r558 = r555 + 1;
                                                                            r535[r555] = r535[r555 - r533];
                                                                            r551 = r558 + 1;
                                                                            r535[r558] = r535[r558 - r533];
                                                                            r158 = r550;
                                                                            r17 = r469;
                                                                            r111 = r470;
                                                                            r63 = r471;
                                                                            r112 = r472;
                                                                            r160 = r535;
                                                                            r159 = r475;
                                                                            if (!(r551 < r159)) {
                                                                              continue loop96;
                                                                            }
                                                                          }
                                                                        }
                                                                      }
                                                                    }
                                                                  } else {
                                                                    const r113 = 7 & r11;
                                                                    const r117 = 4 + ((r113 ? r11 + (8 - r113) : r11) >>> 3);
                                                                    const r122 = a0[r117 - 4] | a0[r117 - 3] << 8;
                                                                    let r123 = r69;
                                                                    if (r89) {
                                                                      const r29 = r27 + r122;
                                                                      const length = r69.length;
                                                                      let r124 = r69;
                                                                      if (!(r29 <= length)) {
                                                                        const uint8Array = new Uint8Array(Math.max(length << 1, r29));
                                                                        uint8Array.set(r69, 0);
                                                                        r124 = uint8Array;
                                                                      }
                                                                      r123 = r124;
                                                                    }
                                                                    r123.set(new r60(a0.buffer, a0.byteOffset + r117, r122), r27);
                                                                    r30 = r117 + r122 << 3;
                                                                    r141 = r27 + r122;
                                                                    r142 = r123;
                                                                    r31 = r17;
                                                                    r32 = r111;
                                                                    r143 = r63;
                                                                    r144 = r112;
                                                                  }
                                                                }
                                                                const r566 = (r43 | r44) >>> (7 & r45) & 1;
                                                                r38 = r30;
                                                                r40 = r31;
                                                                r41 = r32;
                                                                r71 = r143;
                                                                r70 = r144;
                                                                r39 = r141;
                                                                r73 = r142;
                                                                if (r566 !== 0) {
                                                                  return r142.length != r141 ? r142.slice(0, r141) : r142;
                                                                }
                                                              }
                                                            };
                                                            const exports2 = {
                                                              decode: function decode(a0) {
                                                                let r53, r55, r56, r91, r92, r177, r201, r295, r307, length;
                                                                const uint8Array = new Uint8Array(a0);
                                                                const { readUshort: readUshort2, readUint: readUint2 } = c1595_0;
                                                                const r74 = {
                                                                  tabs: {},
                                                                  frames: []
                                                                };
                                                                const uint8Array2 = new Uint8Array(uint8Array.length);
                                                                const r6 = [137, 80, 78, 71, 13, 10, 26, 10];
                                                                let r80 = 0;
                                                                while (true) {
                                                                  const r11 = uint8Array[r80];
                                                                  const r10 = r6[r80];
                                                                  const r7 = r80;
                                                                  if (r11 != r10) {
                                                                    throw "The input is not a PNG file!";
                                                                  }
                                                                  r80 = r7 + 1;
                                                                  if (!(r80 < 8)) {
                                                                    const r83 = 8 < uint8Array.length;
                                                                    let r12 = 0;
                                                                    let r84 = 0;
                                                                    let r85 = 8;
                                                                    let r86 = void 0;
                                                                    let r87 = 0;
                                                                    let r88 = void 0;
                                                                    if (r83) {
                                                                      do {
                                                                        L80: {
                                                                          r53 = c1595_0.readUint(uint8Array, r85);
                                                                          const r90 = r85 + 4;
                                                                          const r62 = c1595_0.readASCII(uint8Array, r90, 4);
                                                                          r91 = r90 + 4;
                                                                          const r59 = r12;
                                                                          const r58 = r84;
                                                                          const r57 = r86;
                                                                          if (r62 == "IHDR") {
                                                                            _IHDR(uint8Array, r91, r74);
                                                                            r55 = r59;
                                                                            r56 = r58;
                                                                            r92 = r57;
                                                                          } else if (r62 == "iCCP") {
                                                                            const r291 = uint8Array[r91];
                                                                            let r292 = r91;
                                                                            let r293 = r292;
                                                                            if (r291 != 0) {
                                                                              do {
                                                                                const r294 = r292 + 1;
                                                                                r295 = uint8Array[r294];
                                                                                r292 = r294;
                                                                                r293 = r292;
                                                                              } while (r295 != 0);
                                                                            }
                                                                            c1595_0.readASCII(uint8Array, r91, r293 - r91);
                                                                            uint8Array[r293 + 1];
                                                                            const r304 = uint8Array.slice(r293 + 2, r91 + r53);
                                                                            try {
                                                                              r307 = _inflate(r304);
                                                                            } catch ($e) {
                                                                              r307 = c1595_4(r304);
                                                                            }
                                                                            r74.tabs[r62] = r307;
                                                                            r55 = r59;
                                                                            r56 = r58;
                                                                            r92 = r57;
                                                                          } else if (r62 == "CgBI") {
                                                                            r74.tabs[r62] = uint8Array.slice(r91, r91 + 4);
                                                                            r55 = r59;
                                                                            r56 = r58;
                                                                            r92 = r57;
                                                                          } else if (r62 == "IDAT") {
                                                                            const r282 = 0 < r53;
                                                                            let r283 = 0;
                                                                            if (r282) {
                                                                              do {
                                                                                uint8Array2[r58 + r283] = uint8Array[r91 + r283];
                                                                                r283 = r283 + 1;
                                                                              } while (r283 < r53);
                                                                            }
                                                                            r56 = r58 + r53;
                                                                            r55 = r59;
                                                                            r92 = r57;
                                                                          } else if (r62 == "acTL") {
                                                                            r74.tabs[r62] = {
                                                                              num_frames: readUint2(uint8Array, r91),
                                                                              num_plays: readUint2(uint8Array, r91 + 4)
                                                                            };
                                                                            r92 = new Uint8Array(uint8Array.length);
                                                                            r55 = r59;
                                                                            r56 = r58;
                                                                          } else if (r62 == "fcTL") {
                                                                            let r234 = r59;
                                                                            if (r59 !== 0) {
                                                                              const r239 = r74.frames[r74.frames.length - 1];
                                                                              r239.data = _decompress(r74, r57.slice(0, r59), r239.rect.width, r239.rect.height);
                                                                              r234 = 0;
                                                                            }
                                                                            const rect = {
                                                                              x: readUint2(uint8Array, r91 + 12),
                                                                              y: readUint2(uint8Array, r91 + 16),
                                                                              width: readUint2(uint8Array, r91 + 4),
                                                                              height: readUint2(uint8Array, r91 + 8)
                                                                            };
                                                                            const r257 = readUshort2(uint8Array, r91 + 22);
                                                                            r74.frames.push({
                                                                              rect,
                                                                              delay: 1000 * (readUshort2(uint8Array, r91 + 20) / (r257 == 0 ? 100 : r257)),
                                                                              dispose: uint8Array[r91 + 24],
                                                                              blend: uint8Array[r91 + 25]
                                                                            });
                                                                            r55 = r234;
                                                                            r56 = r58;
                                                                            r92 = r57;
                                                                          } else if (r62 == "fdAT") {
                                                                            const r226 = r53 - 4;
                                                                            let r227 = 0;
                                                                            if (0 < r226) {
                                                                              do {
                                                                                r57[r59 + r227] = uint8Array[r91 + r227 + 4];
                                                                                r227 = r227 + 1;
                                                                              } while (r227 < r53 - 4);
                                                                            }
                                                                            r55 = r59 + (r53 - 4);
                                                                            r56 = r58;
                                                                            r92 = r57;
                                                                          } else if (r62 == "pHYs") {
                                                                            r74.tabs[r62] = [c1595_0.readUint(uint8Array, r91), c1595_0.readUint(uint8Array, r91 + 4), uint8Array[r91 + 8]];
                                                                            r55 = r59;
                                                                            r56 = r58;
                                                                            r92 = r57;
                                                                          } else if (r62 == "cHRM") {
                                                                            r74.tabs[r62] = [];
                                                                            let r208 = 0;
                                                                            do {
                                                                              r74.tabs[r62].push(c1595_0.readUint(uint8Array, r91 + 4 * r208));
                                                                              r208 = r208 + 1;
                                                                              r55 = r59;
                                                                              r56 = r58;
                                                                              r92 = r57;
                                                                            } while (r208 < 8);
                                                                          } else {
                                                                            if (r62 != "tEXt" && r62 != "zTXt") {
                                                                              if (r62 == "iTXt") {
                                                                                if (r74.tabs[r62] == null) {
                                                                                  r74.tabs[r62] = {};
                                                                                }
                                                                                const r148 = c1595_0.nextZero(uint8Array, r91);
                                                                                const r151 = c1595_0.readASCII(uint8Array, r91, r148 - r91);
                                                                                const r152 = r148 + 1;
                                                                                const r153 = uint8Array[r152];
                                                                                uint8Array[r152 + 1];
                                                                                const r66 = r152 + 2;
                                                                                const r157 = c1595_0.nextZero(uint8Array, r66);
                                                                                c1595_0.readASCII(uint8Array, r66, r157 - r66);
                                                                                const r161 = r157 + 1;
                                                                                const r163 = c1595_0.nextZero(uint8Array, r161);
                                                                                c1595_0.readUTF8(uint8Array, r161, r163 - r161);
                                                                                const r167 = r163 + 1;
                                                                                const r169 = r53 - (r167 - r91);
                                                                                if (r153 == 0) {
                                                                                  r177 = c1595_0.readUTF8(uint8Array, r167, r169);
                                                                                } else {
                                                                                  const r174 = _inflate(uint8Array.slice(r167, r167 + r169));
                                                                                  r177 = c1595_0.readUTF8(r174, 0, r174.length);
                                                                                }
                                                                                r74.tabs[r62][r151] = r177;
                                                                                r55 = r59;
                                                                                r56 = r58;
                                                                                r92 = r57;
                                                                                break L80;
                                                                              }
                                                                              if (r62 == "PLTE") {
                                                                                r74.tabs[r62] = c1595_0.readBytes(uint8Array, r91, r53);
                                                                                r55 = r59;
                                                                                r56 = r58;
                                                                                r92 = r57;
                                                                                break L80;
                                                                              }
                                                                              if (r62 != "hIST") {
                                                                                if (r62 == "tRNS") {
                                                                                  if (r74.ctype == 3) {
                                                                                    r74.tabs[r62] = c1595_0.readBytes(uint8Array, r91, r53);
                                                                                    r55 = r59;
                                                                                    r56 = r58;
                                                                                    r92 = r57;
                                                                                    break L80;
                                                                                  }
                                                                                  if (r74.ctype == 0) {
                                                                                    r74.tabs[r62] = readUshort2(uint8Array, r91);
                                                                                    r55 = r59;
                                                                                    r56 = r58;
                                                                                    r92 = r57;
                                                                                    break L80;
                                                                                  }
                                                                                  const ctype2 = r74.ctype;
                                                                                  r55 = r59;
                                                                                  r56 = r58;
                                                                                  r92 = r57;
                                                                                  if (ctype2 != 2) {
                                                                                    break L80;
                                                                                  }
                                                                                  r74.tabs[r62] = [readUshort2(uint8Array, r91), readUshort2(uint8Array, r91 + 2), readUshort2(uint8Array, r91 + 4)];
                                                                                  r55 = r59;
                                                                                  r56 = r58;
                                                                                  r92 = r57;
                                                                                  break L80;
                                                                                }
                                                                                if (r62 == "gAMA") {
                                                                                  r74.tabs[r62] = c1595_0.readUint(uint8Array, r91) / 100000;
                                                                                  r55 = r59;
                                                                                  r56 = r58;
                                                                                  r92 = r57;
                                                                                  break L80;
                                                                                }
                                                                                if (r62 == "sRGB") {
                                                                                  r74.tabs[r62] = uint8Array[r91];
                                                                                  r55 = r59;
                                                                                  r56 = r58;
                                                                                  r92 = r57;
                                                                                  break L80;
                                                                                }
                                                                                if (r62 == "bKGD") {
                                                                                  if (r74.ctype != 0 && r74.ctype != 4) {
                                                                                    if (r74.ctype != 2 && r74.ctype != 6) {
                                                                                      const ctype = r74.ctype;
                                                                                      r55 = r59;
                                                                                      r56 = r58;
                                                                                      r92 = r57;
                                                                                      if (ctype != 3) {
                                                                                        break L80;
                                                                                      }
                                                                                      r74.tabs[r62] = uint8Array[r91];
                                                                                      r55 = r59;
                                                                                      r56 = r58;
                                                                                      r92 = r57;
                                                                                      break L80;
                                                                                    }
                                                                                    r74.tabs[r62] = [readUshort2(uint8Array, r91), readUshort2(uint8Array, r91 + 2), readUshort2(uint8Array, r91 + 4)];
                                                                                    r55 = r59;
                                                                                    r56 = r58;
                                                                                    r92 = r57;
                                                                                    break L80;
                                                                                  }
                                                                                  r74.tabs[r62] = [readUshort2(uint8Array, r91)];
                                                                                  r55 = r59;
                                                                                  r56 = r58;
                                                                                  r92 = r57;
                                                                                  break L80;
                                                                                }
                                                                                r55 = r59;
                                                                                r56 = r58;
                                                                                r92 = r57;
                                                                                r87 = r55;
                                                                                r88 = r92;
                                                                                if (r62 == "IEND") {
                                                                                  break;
                                                                                }
                                                                                break L80;
                                                                              }
                                                                              const r131 = r74.tabs.PLTE.length / 3;
                                                                              r74.tabs[r62] = [];
                                                                              let r134 = 0;
                                                                              r55 = r59;
                                                                              r56 = r58;
                                                                              r92 = r57;
                                                                              if (!(0 < r131)) {
                                                                                break L80;
                                                                              }
                                                                              while (true) {
                                                                                r74.tabs[r62].push(readUshort2(uint8Array, r91 + 2 * r134));
                                                                                r134 = r134 + 1;
                                                                                r55 = r59;
                                                                                r56 = r58;
                                                                                r92 = r57;
                                                                                if (!(r134 < r131)) {
                                                                                  break L80;
                                                                                }
                                                                              }
                                                                            }
                                                                            if (r74.tabs[r62] == null) {
                                                                              r74.tabs[r62] = {};
                                                                            }
                                                                            const r186 = c1595_0.nextZero(uint8Array, r91);
                                                                            const r189 = c1595_0.readASCII(uint8Array, r91, r186 - r91);
                                                                            const r192 = r91 + r53 - r186 - 1;
                                                                            if (r62 == "tEXt") {
                                                                              r201 = c1595_0.readASCII(uint8Array, r186 + 1, r192);
                                                                            } else {
                                                                              const r198 = _inflate(uint8Array.slice(r186 + 2, r186 + 2 + r192));
                                                                              r201 = c1595_0.readUTF8(r198, 0, r198.length);
                                                                            }
                                                                            r74.tabs[r62][r189] = r201;
                                                                            r55 = r59;
                                                                            r56 = r58;
                                                                            r92 = r57;
                                                                          }
                                                                        }
                                                                        const r314 = r91 + r53;
                                                                        c1595_0.readUint(uint8Array, r314);
                                                                        r85 = r314 + 4;
                                                                        length = uint8Array.length;
                                                                        r12 = r55;
                                                                        r84 = r56;
                                                                        r86 = r92;
                                                                        r87 = r12;
                                                                        r88 = r86;
                                                                      } while (r85 < length);
                                                                    }
                                                                    if (r87 !== 0) {
                                                                      const r322 = r74.frames[r74.frames.length - 1];
                                                                      r322.data = _decompress(r74, r88.slice(0, r87), r322.rect.width, r322.rect.height);
                                                                    }
                                                                    r74.data = _decompress(r74, uint8Array2, r74.width, r74.height);
                                                                    delete r74["compress"];
                                                                    delete r74["interlace"];
                                                                    delete r74["filter"];
                                                                    return r74;
                                                                  }
                                                                }
                                                              },
                                                              toRGBA8: function toRGBA8(a0) {
                                                                const { width, height } = a0;
                                                                if (a0.tabs.acTL == null) {
                                                                  return [decodeImage(a0.data, width, height, a0).buffer];
                                                                }
                                                                if (a0.frames[0].data == null) {
                                                                  a0.frames[0].data = a0.data;
                                                                }
                                                                const r42 = [];
                                                                const r5 = width * height * 4;
                                                                const uint8Array = new Uint8Array(r5);
                                                                const uint8Array2 = new Uint8Array(r5);
                                                                const uint8Array3 = new Uint8Array(r5);
                                                                const r9 = 0 < a0.frames.length;
                                                                let r60 = 0;
                                                                if (r9) {
                                                                  do {
                                                                    const r62 = a0.frames[r60];
                                                                    const r22 = r62.rect.x;
                                                                    const r21 = r62.rect.y;
                                                                    const width2 = r62.rect.width;
                                                                    const height2 = r62.rect.height;
                                                                    const r69 = decodeImage(r62.data, width2, height2, a0);
                                                                    const r4 = r60;
                                                                    if (r4 !== 0) {
                                                                      let r0 = 0;
                                                                      while (r0 < r5) {
                                                                        uint8Array3[r0] = uint8Array[r0];
                                                                        r0 = r0 + 1;
                                                                      }
                                                                    }
                                                                    if (r62.blend == 0) {
                                                                      _copyTile(r69, width2, height2, uint8Array, width, height, r22, r21, 0);
                                                                    } else if (r62.blend == 1) {
                                                                      _copyTile(r69, width2, height2, uint8Array, width, height, r22, r21, 1);
                                                                    }
                                                                    r42.push(uint8Array.buffer.slice(0));
                                                                    if (r62.dispose != 0) {
                                                                      if (r62.dispose == 1) {
                                                                        _copyTile(uint8Array2, width2, height2, uint8Array, width, height, r22, r21, 0);
                                                                      } else if (r62.dispose == 2) {
                                                                        let r98 = 0;
                                                                        while (r98 < r5) {
                                                                          uint8Array[r98] = uint8Array3[r98];
                                                                          r98 = r98 + 1;
                                                                        }
                                                                      }
                                                                    }
                                                                    r60 = r4 + 1;
                                                                  } while (r60 < a0.frames.length);
                                                                }
                                                                return r42;
                                                              },
                                                              _paeth,
                                                              _copyTile,
                                                              _bin: c1595_0
                                                            };
                                                            _copyTile2 = void 0;
                                                            _bin = void 0;
                                                            _paeth2 = void 0;
                                                            c1597_3 = void 0;
                                                            c1597_16 = void 0;
                                                            dither2 = function dither(a0, a1, a2, a3, a4, a5, a6) {
                                                              let r130;
                                                              const r31 = a6 == null ? 1 : a6;
                                                              const length = a3.length;
                                                              const r28 = [];
                                                              const r22 = [];
                                                              const r44 = 0 < length;
                                                              let r16 = 0;
                                                              if (r44) {
                                                                do {
                                                                  const r25 = a3[r16];
                                                                  r28.push([r25 >>> 0 & 255, r25 >>> 8 & 255, r25 >>> 16 & 255, r25 >>> 24 & 255]);
                                                                  r16 = r16 + 1;
                                                                } while (r16 < length);
                                                              }
                                                              const r53 = 0 < length;
                                                              let r55 = 0;
                                                              if (r53) {
                                                                do {
                                                                  const r56 = 0 < length;
                                                                  const r57 = r55;
                                                                  let r58 = 0;
                                                                  let r59 = 4294967295;
                                                                  let r60 = 4294967295;
                                                                  if (r56) {
                                                                    do {
                                                                      const r36 = r28[r57];
                                                                      const r61 = r28[r58];
                                                                      const r35 = r36[0] - r61[0];
                                                                      const r64 = r36[1] - r61[1];
                                                                      const r66 = r36[2] - r61[2];
                                                                      const r69 = r36[3] - r61[3];
                                                                      const r76 = r35 * r35 + r64 * r64 + r66 * r66 + r69 * r69;
                                                                      let r77 = r58 !== r57;
                                                                      const r6 = r58;
                                                                      let r78 = r59;
                                                                      if (r6 !== r57) {
                                                                        r77 = r76 < r78;
                                                                      }
                                                                      if (r77) {
                                                                        r78 = r76;
                                                                      }
                                                                      r58 = r6 + 1;
                                                                      r59 = r78;
                                                                      r60 = r59;
                                                                    } while (r58 < length);
                                                                  }
                                                                  const r82 = Math.sqrt(r60) / 2;
                                                                  r22[r57] = ~~(r82 * r82);
                                                                  r55 = r57 + 1;
                                                                } while (r55 < length);
                                                              }
                                                              const uint32Array = new Uint32Array(a4.buffer);
                                                              const int16Array = new Int16Array(a1 * a2 * 4);
                                                              const r101 = [0, 8, 2, 10, 12, 4, 14, 6, 3, 11, 1, 9, 15, 7, 13, 5];
                                                              const r103 = 0 < r101.length;
                                                              let r105 = 0;
                                                              if (r103) {
                                                                do {
                                                                  r101[r105] = 255 * ((r101[r105] + 0.5) / 16 - 0.5);
                                                                  r105 = r105 + 1;
                                                                } while (r105 < r101.length);
                                                              }
                                                              const r112 = 0 < a2;
                                                              let r117 = 0;
                                                              if (r112) {
                                                                do {
                                                                  const r118 = 0 < a1;
                                                                  const r19 = 4 * (3 & r117);
                                                                  const r119 = r117;
                                                                  let r14 = 0;
                                                                  if (r118) {
                                                                    do {
                                                                      const r8 = 4 * (r119 * a1 + r14);
                                                                      const r121 = r14;
                                                                      if (r31 != 2) {
                                                                        const r166 = [Math.max(0, Math.min(255, a0[r8] + int16Array[r8])), , , ,];
                                                                        const r167 = r8 + 1;
                                                                        r166[1] = Math.max(0, Math.min(255, a0[r167] + int16Array[r167]));
                                                                        const r177 = r8 + 2;
                                                                        r166[2] = Math.max(0, Math.min(255, a0[r177] + int16Array[r177]));
                                                                        const r187 = r8 + 3;
                                                                        r166[3] = Math.max(0, Math.min(255, a0[r187] + int16Array[r187]));
                                                                        r130 = r166;
                                                                      } else {
                                                                        const r123 = r101[r19 + (3 & r121)];
                                                                        r130 = [Math.max(0, Math.min(255, a0[r8] + r123)), Math.max(0, Math.min(255, a0[r8 + 1] + r123)), Math.max(0, Math.min(255, a0[r8 + 2] + r123)), Math.max(0, Math.min(255, a0[r8 + 3] + r123))];
                                                                      }
                                                                      const r197 = 0 < length;
                                                                      let r198 = 16777215;
                                                                      let r0 = 0;
                                                                      let r1 = 0;
                                                                      let r199 = 0;
                                                                      if (r197) {
                                                                        do {
                                                                          const r200 = r28[r0];
                                                                          const r203 = r130[0] - r200[0];
                                                                          const r206 = r130[1] - r200[1];
                                                                          const r209 = r130[2] - r200[2];
                                                                          const r212 = r130[3] - r200[3];
                                                                          const r219 = r203 * r203 + r206 * r206 + r209 * r209 + r212 * r212;
                                                                          let r220 = r198;
                                                                          const r3 = r0;
                                                                          let r2 = r1;
                                                                          if (r219 < r220) {
                                                                            r220 = r219;
                                                                            r2 = r3;
                                                                          }
                                                                          r0 = r3 + 1;
                                                                          r198 = r220;
                                                                          r1 = r2;
                                                                          r199 = r1;
                                                                        } while (r0 < length);
                                                                      }
                                                                      const r221 = r28[r199];
                                                                      const r225 = [r130[0] - r221[0], r130[1] - r221[1], r130[2] - r221[2], r130[3] - r221[3]];
                                                                      if (r31 == 1) {
                                                                        if (r121 !== a1 - 1) {
                                                                          const r236 = r8 + 4;
                                                                          int16Array[r236] = int16Array[r236] + (r225[0] * 7 >> 4);
                                                                          const r242 = r236 + 1;
                                                                          int16Array[r242] = int16Array[r242] + (r225[1] * 7 >> 4);
                                                                          const r248 = r236 + 2;
                                                                          int16Array[r248] = int16Array[r248] + (r225[2] * 7 >> 4);
                                                                          const r254 = r236 + 3;
                                                                          int16Array[r254] = int16Array[r254] + (r225[3] * 7 >> 4);
                                                                        }
                                                                        if (r119 !== a2 - 1) {
                                                                          if (r121 !== 0) {
                                                                            const r263 = r8 + 4 * a1 - 4;
                                                                            int16Array[r263] = int16Array[r263] + (r225[0] * 3 >> 4);
                                                                            const r269 = r263 + 1;
                                                                            int16Array[r269] = int16Array[r269] + (r225[1] * 3 >> 4);
                                                                            const r275 = r263 + 2;
                                                                            int16Array[r275] = int16Array[r275] + (r225[2] * 3 >> 4);
                                                                            const r281 = r263 + 3;
                                                                            int16Array[r281] = int16Array[r281] + (r225[3] * 3 >> 4);
                                                                          }
                                                                          const r288 = r8 + 4 * a1;
                                                                          int16Array[r288] = int16Array[r288] + (r225[0] * 5 >> 4);
                                                                          const r294 = r288 + 1;
                                                                          int16Array[r294] = int16Array[r294] + (r225[1] * 5 >> 4);
                                                                          const r300 = r288 + 2;
                                                                          int16Array[r300] = int16Array[r300] + (r225[2] * 5 >> 4);
                                                                          const r306 = r288 + 3;
                                                                          int16Array[r306] = int16Array[r306] + (r225[3] * 5 >> 4);
                                                                          if (r121 !== a1 - 1) {
                                                                            const r315 = r8 + 4 * a1 + 4;
                                                                            int16Array[r315] = int16Array[r315] + (r225[0] * 1 >> 4);
                                                                            const r321 = r315 + 1;
                                                                            int16Array[r321] = int16Array[r321] + (r225[1] * 1 >> 4);
                                                                            const r327 = r315 + 2;
                                                                            int16Array[r327] = int16Array[r327] + (r225[2] * 1 >> 4);
                                                                            const r333 = r315 + 3;
                                                                            int16Array[r333] = int16Array[r333] + (r225[3] * 1 >> 4);
                                                                          }
                                                                        }
                                                                      }
                                                                      const r339 = r8 >> 2;
                                                                      a5[r339] = r199;
                                                                      uint32Array[r339] = a3[r199];
                                                                      r14 = r121 + 1;
                                                                    } while (r14 < a1);
                                                                  }
                                                                  r117 = r119 + 1;
                                                                } while (r117 < a2);
                                                              }
                                                            };
                                                            _main2 = function _main(a0, a1, a2, a3, a4) {
                                                              let length2, length5;
                                                              const r30 = a4 == null ? {} : a4;
                                                              const crc2 = c1597_3.crc;
                                                              const { writeUint: writeUint2, writeUshort: writeUshort2, writeASCII: writeASCII2 } = _bin;
                                                              const r22 = a0.frames.length > 1;
                                                              const r0 = 33 + (r22 ? 20 : 0);
                                                              const r4 = r30.sRGB != null ? r0 + 13 : r0;
                                                              const r52 = r30.pHYs != null ? r4 + 21 : r4;
                                                              const r20 = r30.iCCP != null;
                                                              let r27 = r52;
                                                              let r25 = void 0;
                                                              if (r20) {
                                                                const r57 = pako.deflate(r30.iCCP);
                                                                r27 = r52 + (21 + r57.length + 4);
                                                                r25 = r57;
                                                              }
                                                              const r17 = a0.ctype == 3;
                                                              let r64 = r27;
                                                              let r65 = false;
                                                              if (r17) {
                                                                const length = a0.plte.length;
                                                                const r16 = 0 < length;
                                                                let r70 = 0;
                                                                let r71 = false;
                                                                let r18 = false;
                                                                if (r16) {
                                                                  do {
                                                                    const r9 = a0.plte[r70] >>> 24;
                                                                    const r6 = r70;
                                                                    const r74 = r9 !== 255 ? true : r71;
                                                                    r70 = r6 + 1;
                                                                    r71 = r74;
                                                                    r18 = r71;
                                                                  } while (r70 < length);
                                                                }
                                                                r64 = r27 + (8 + 3 * length + 4 + (r18 ? 8 + 1 * length + 4 : 0));
                                                                r65 = r18;
                                                              }
                                                              const r88 = 0 < a0.frames.length;
                                                              let r92 = r64;
                                                              let r93 = 0;
                                                              let r94 = r92;
                                                              if (r88) {
                                                                do {
                                                                  const r95 = r93;
                                                                  const r96 = r92;
                                                                  const r103 = (r22 ? r96 + 38 : r96) + (a0.frames[r95].cimg.length + 12);
                                                                  const r104 = r95 !== 0 ? r103 + 4 : r103;
                                                                  r93 = r95 + 1;
                                                                  length2 = a0.frames.length;
                                                                  r92 = r104;
                                                                  r94 = r92;
                                                                } while (r93 < length2);
                                                              }
                                                              const uint8Array = new Uint8Array(r94 + 12);
                                                              const r112 = [137, 80, 78, 71, 13, 10, 26, 10];
                                                              let r113 = 0;
                                                              while (true) {
                                                                uint8Array[r113] = r112[r113];
                                                                r113 = r113 + 1;
                                                                if (!(r113 < 8)) {
                                                                  writeUint2(uint8Array, 8, 13);
                                                                  writeASCII2(uint8Array, 12, "IHDR");
                                                                  writeUint2(uint8Array, 16, a1);
                                                                  writeUint2(uint8Array, 20, a2);
                                                                  uint8Array[24] = a0.depth;
                                                                  uint8Array[25] = a0.ctype;
                                                                  uint8Array[26] = 0;
                                                                  uint8Array[27] = 0;
                                                                  uint8Array[28] = 0;
                                                                  writeUint2(uint8Array, 29, crc2(uint8Array, 12, 17));
                                                                  const r135 = r30.sRGB != null;
                                                                  let r136 = 33;
                                                                  if (r135) {
                                                                    writeUint2(uint8Array, 33, 1);
                                                                    writeASCII2(uint8Array, 37, "sRGB");
                                                                    uint8Array[41] = r30.sRGB;
                                                                    writeUint2(uint8Array, 42, crc2(uint8Array, 37, 5));
                                                                    r136 = 46;
                                                                  }
                                                                  const iCCP = r30.iCCP;
                                                                  let r147 = r136;
                                                                  if (iCCP != null) {
                                                                    const r149 = 13 + r25.length;
                                                                    writeUint2(uint8Array, r136, r149);
                                                                    const r151 = r136 + 4;
                                                                    writeASCII2(uint8Array, r151, "iCCP");
                                                                    const r154 = r151 + 4;
                                                                    writeASCII2(uint8Array, r154, "ICC profile");
                                                                    const r160 = r154 + 11 + 2;
                                                                    uint8Array.set(r25, r160);
                                                                    const r164 = r160 + r25.length;
                                                                    const r165 = r149 + 4;
                                                                    writeUint2(uint8Array, r164, crc2(uint8Array, r164 - r165, r165));
                                                                    r147 = r164 + 4;
                                                                  }
                                                                  const pHYs = r30.pHYs;
                                                                  let r170 = r147;
                                                                  if (pHYs != null) {
                                                                    writeUint2(uint8Array, r147, 9);
                                                                    const r173 = r147 + 4;
                                                                    writeASCII2(uint8Array, r173, "pHYs");
                                                                    const r176 = r173 + 4;
                                                                    writeUint2(uint8Array, r176, r30.pHYs[0]);
                                                                    const r180 = r176 + 4;
                                                                    writeUint2(uint8Array, r180, r30.pHYs[1]);
                                                                    const r184 = r180 + 4;
                                                                    uint8Array[r184] = r30.pHYs[2];
                                                                    const r187 = r184 + 1;
                                                                    writeUint2(uint8Array, r187, crc2(uint8Array, r187 - 13, 13));
                                                                    r170 = r187 + 4;
                                                                  }
                                                                  let r191 = r170;
                                                                  if (r22) {
                                                                    writeUint2(uint8Array, r170, 8);
                                                                    const r193 = r170 + 4;
                                                                    writeASCII2(uint8Array, r193, "acTL");
                                                                    const r196 = r193 + 4;
                                                                    writeUint2(uint8Array, r196, a0.frames.length);
                                                                    const r202 = r30.loop != null ? r30.loop : 0;
                                                                    const r203 = r196 + 4;
                                                                    writeUint2(uint8Array, r203, r202);
                                                                    const r205 = r203 + 4;
                                                                    writeUint2(uint8Array, r205, crc2(uint8Array, r205 - 12, 12));
                                                                    r191 = r205 + 4;
                                                                  }
                                                                  const ctype = a0.ctype;
                                                                  let r210 = r191;
                                                                  if (ctype == 3) {
                                                                    const length3 = a0.plte.length;
                                                                    writeUint2(uint8Array, r191, 3 * length3);
                                                                    const r215 = r191 + 4;
                                                                    writeASCII2(uint8Array, r215, "PLTE");
                                                                    const r218 = r215 + 4;
                                                                    const r219 = 0 < length3;
                                                                    let r222 = 0;
                                                                    if (r219) {
                                                                      do {
                                                                        const r224 = a0.plte[r222];
                                                                        const r13 = 255 & r224;
                                                                        const r225 = r224 >>> 8;
                                                                        const r226 = r224 >>> 16;
                                                                        const r227 = r218 + 3 * r222;
                                                                        uint8Array[r227 + 0] = r13;
                                                                        uint8Array[r227 + 1] = r225 & 255;
                                                                        uint8Array[r227 + 2] = r226 & 255;
                                                                        r222 = r222 + 1;
                                                                      } while (r222 < length3);
                                                                    }
                                                                    const r234 = r218 + 3 * length3;
                                                                    writeUint2(uint8Array, r234, crc2(uint8Array, r234 - 3 * length3 - 4, 3 * length3 + 4));
                                                                    const r242 = r234 + 4;
                                                                    r210 = r242;
                                                                    if (r65) {
                                                                      writeUint2(uint8Array, r242, length3);
                                                                      const r244 = r242 + 4;
                                                                      writeASCII2(uint8Array, r244, "tRNS");
                                                                      const r247 = r244 + 4;
                                                                      const r248 = 0 < length3;
                                                                      let r249 = 0;
                                                                      if (r248) {
                                                                        do {
                                                                          uint8Array[r247 + r249] = a0.plte[r249] >>> 24 & 255;
                                                                          r249 = r249 + 1;
                                                                        } while (r249 < length3);
                                                                      }
                                                                      const r255 = r247 + length3;
                                                                      writeUint2(uint8Array, r255, crc2(uint8Array, r255 - length3 - 4, length3 + 4));
                                                                      r210 = r255 + 4;
                                                                    }
                                                                  }
                                                                  const r263 = 0 < a0.frames.length;
                                                                  let r269 = r210;
                                                                  let r270 = 0;
                                                                  let r271 = 0;
                                                                  let r272 = r269;
                                                                  if (r263) {
                                                                    do {
                                                                      const r274 = a0.frames[r271];
                                                                      const r275 = r270;
                                                                      const r276 = r271;
                                                                      const r37 = r269;
                                                                      let r277 = r275;
                                                                      let r36 = r37;
                                                                      if (r22) {
                                                                        writeUint2(uint8Array, r37, 26);
                                                                        const r278 = r37 + 4;
                                                                        writeASCII2(uint8Array, r278, "fcTL");
                                                                        const r280 = r278 + 4;
                                                                        r277 = r275 + 1;
                                                                        writeUint2(uint8Array, r280, r275);
                                                                        const r282 = r280 + 4;
                                                                        writeUint2(uint8Array, r282, r274.rect.width);
                                                                        const r286 = r282 + 4;
                                                                        writeUint2(uint8Array, r286, r274.rect.height);
                                                                        const r290 = r286 + 4;
                                                                        writeUint2(uint8Array, r290, r274.rect.x);
                                                                        const r294 = r290 + 4;
                                                                        writeUint2(uint8Array, r294, r274.rect.y);
                                                                        const r298 = r294 + 4;
                                                                        writeUshort2(uint8Array, r298, a3[r276]);
                                                                        const r301 = r298 + 2;
                                                                        writeUshort2(uint8Array, r301, 1000);
                                                                        const r303 = r301 + 2;
                                                                        uint8Array[r303] = r274.dispose;
                                                                        const r305 = r303 + 1;
                                                                        uint8Array[r305] = r274.blend;
                                                                        const r307 = r305 + 1;
                                                                        writeUint2(uint8Array, r307, crc2(uint8Array, r307 - 30, 30));
                                                                        r36 = r307 + 4;
                                                                      }
                                                                      const cimg = r274.cimg;
                                                                      const length4 = cimg.length;
                                                                      writeUint2(uint8Array, r36, length4 + (r276 === 0 ? 0 : 4));
                                                                      const r315 = r276 === 0 ? "IDAT" : "fdAT";
                                                                      const r316 = r36 + 4;
                                                                      writeASCII2(uint8Array, r316, r315);
                                                                      const r318 = r316 + 4;
                                                                      let r319 = r277;
                                                                      let r320 = r318;
                                                                      if (r276 !== 0) {
                                                                        r319 = r277 + 1;
                                                                        writeUint2(uint8Array, r318, r277);
                                                                        r320 = r318 + 4;
                                                                      }
                                                                      uint8Array.set(cimg, r320);
                                                                      const r323 = r320 + length4;
                                                                      writeUint2(uint8Array, r323, crc2(uint8Array, r316, r323 - r316));
                                                                      r269 = r323 + 4;
                                                                      r271 = r276 + 1;
                                                                      length5 = a0.frames.length;
                                                                      r270 = r319;
                                                                      r272 = r269;
                                                                    } while (r271 < length5);
                                                                  }
                                                                  writeUint2(uint8Array, r272, 0);
                                                                  const r330 = r272 + 4;
                                                                  writeASCII2(uint8Array, r330, "IEND");
                                                                  const r333 = r330 + 4;
                                                                  writeUint2(uint8Array, r333, crc2(uint8Array, r333 - 4, 4));
                                                                  return uint8Array.buffer;
                                                                }
                                                              }
                                                            };
                                                            compressPNG2 = function compressPNG(a0, a1, a2) {
                                                              let length2;
                                                              const r24 = 0 < a0.frames.length;
                                                              let r13 = 0;
                                                              if (r24) {
                                                                do {
                                                                  const r34 = a0.frames[r13];
                                                                  r34.rect.width;
                                                                  const height = r34.rect.height;
                                                                  const uint8Array = new Uint8Array(height * r34.bpl + height);
                                                                  const { img, bpp, bpl } = r34;
                                                                  const r14 = r13;
                                                                  const r39 = a1 != -1 ? [a1] : height * bpl > 500000 || bpp == 1 ? [0] : [0, 1, 2, 3, 4];
                                                                  const r38 = a2 ? {
                                                                    level: 0
                                                                  } : void 0;
                                                                  const r69 = uint8Array.length > 10000000 && window.UZIP != null ? window.UZIP : pako;
                                                                  const r71 = [];
                                                                  Date.now();
                                                                  const r75 = 0 < r39.length;
                                                                  let r12 = 0;
                                                                  if (r75) {
                                                                    do {
                                                                      const r76 = 0 < height;
                                                                      const r11 = r12;
                                                                      let r9 = 0;
                                                                      if (r76) {
                                                                        do {
                                                                          const r77 = r39[r11];
                                                                          const r2 = r9 * bpl;
                                                                          const r10 = r2 + r9;
                                                                          uint8Array[r10] = r77;
                                                                          const r3 = r10 + 1;
                                                                          const r78 = r9;
                                                                          if (r77 == 0) {
                                                                            if (bpl < 500) {
                                                                              const r192 = 0 < bpl;
                                                                              let r193 = 0;
                                                                              if (r192) {
                                                                                do {
                                                                                  uint8Array[r3 + r193] = img[r2 + r193];
                                                                                  r193 = r193 + 1;
                                                                                } while (r193 < bpl);
                                                                              }
                                                                            } else {
                                                                              uint8Array.set(new Uint8Array(img.buffer, r2, bpl), r3);
                                                                            }
                                                                          } else if (r77 == 1) {
                                                                            const r169 = 0 < bpp;
                                                                            let r170 = 0;
                                                                            if (r169) {
                                                                              do {
                                                                                uint8Array[r3 + r170] = img[r2 + r170];
                                                                                r170 = r170 + 1;
                                                                              } while (r170 < bpp);
                                                                            }
                                                                            let r174 = bpp;
                                                                            while (r174 < bpl) {
                                                                              uint8Array[r3 + r174] = img[r2 + r174] - img[r2 + r174 - bpp] + 256 & 255;
                                                                              r174 = r174 + 1;
                                                                            }
                                                                          } else if (r78 === 0) {
                                                                            const r137 = 0 < bpp;
                                                                            let r138 = 0;
                                                                            if (r137) {
                                                                              do {
                                                                                uint8Array[r3 + r138] = img[r2 + r138];
                                                                                r138 = r138 + 1;
                                                                              } while (r138 < bpp);
                                                                            }
                                                                            if (r77 == 2) {
                                                                              let r142 = bpp;
                                                                              while (r142 < bpl) {
                                                                                uint8Array[r3 + r142] = img[r2 + r142];
                                                                                r142 = r142 + 1;
                                                                              }
                                                                            }
                                                                            if (r77 == 3) {
                                                                              let r146 = bpp;
                                                                              while (r146 < bpl) {
                                                                                uint8Array[r3 + r146] = img[r2 + r146] - (img[r2 + r146 - bpp] >> 1) + 256 & 255;
                                                                                r146 = r146 + 1;
                                                                              }
                                                                            }
                                                                            if (r77 == 4) {
                                                                              let r157 = bpp;
                                                                              while (r157 < bpl) {
                                                                                uint8Array[r3 + r157] = img[r2 + r157] - _paeth2(img[r2 + r157 - bpp], 0, 0) + 256 & 255;
                                                                                r157 = r157 + 1;
                                                                              }
                                                                            }
                                                                          } else {
                                                                            if (r77 == 2) {
                                                                              const r79 = 0 < bpl;
                                                                              let r0 = 0;
                                                                              if (r79) {
                                                                                do {
                                                                                  const r1 = r2 + r0;
                                                                                  uint8Array[r3 + r0] = img[r1] + 256 - img[r1 - bpl] & 255;
                                                                                  r0 = r0 + 1;
                                                                                } while (r0 < bpl);
                                                                              }
                                                                            }
                                                                            if (r77 == 3) {
                                                                              const r85 = 0 < bpp;
                                                                              let r86 = 0;
                                                                              if (r85) {
                                                                                do {
                                                                                  const r87 = r2 + r86;
                                                                                  uint8Array[r3 + r86] = img[r87] + 256 - (img[r87 - bpl] >> 1) & 255;
                                                                                  r86 = r86 + 1;
                                                                                } while (r86 < bpp);
                                                                              }
                                                                              let r96 = bpp;
                                                                              while (r96 < bpl) {
                                                                                uint8Array[r3 + r96] = img[r2 + r96] + 256 - (img[r2 + r96 - bpl] + img[r2 + r96 - bpp] >> 1) & 255;
                                                                                r96 = r96 + 1;
                                                                              }
                                                                            }
                                                                            if (r77 == 4) {
                                                                              const r108 = 0 < bpp;
                                                                              let r109 = 0;
                                                                              if (r108) {
                                                                                do {
                                                                                  const r110 = r2 + r109;
                                                                                  uint8Array[r3 + r109] = img[r110] + 256 - _paeth2(0, img[r110 - bpl], 0) & 255;
                                                                                  r109 = r109 + 1;
                                                                                } while (r109 < bpp);
                                                                              }
                                                                              let r120 = bpp;
                                                                              while (r120 < bpl) {
                                                                                uint8Array[r3 + r120] = img[r2 + r120] + 256 - _paeth2(img[r2 + r120 - bpp], img[r2 + r120 - bpl], img[r2 + r120 - bpp - bpl]) & 255;
                                                                                r120 = r120 + 1;
                                                                              }
                                                                            }
                                                                          }
                                                                          r9 = r78 + 1;
                                                                        } while (r9 < height);
                                                                      }
                                                                      r71.push(r69.deflate(uint8Array, r38));
                                                                      r12 = r11 + 1;
                                                                    } while (r12 < r39.length);
                                                                  }
                                                                  const r25 = 0 < r71.length;
                                                                  let r203 = 1000000000;
                                                                  let r26 = void 0;
                                                                  let r204 = 0;
                                                                  let r205 = void 0;
                                                                  if (r25) {
                                                                    do {
                                                                      const length = r71[r204].length;
                                                                      let r208 = r203;
                                                                      let r209 = r26;
                                                                      const r210 = r204;
                                                                      if (length < r208) {
                                                                        r208 = r71[r210].length;
                                                                        r209 = r210;
                                                                      }
                                                                      r204 = r210 + 1;
                                                                      length2 = r71.length;
                                                                      r203 = r208;
                                                                      r26 = r209;
                                                                      r205 = r26;
                                                                    } while (r204 < length2);
                                                                  }
                                                                  r34.cimg = r71[r205];
                                                                  r13 = r14 + 1;
                                                                } while (r13 < a0.frames.length);
                                                              }
                                                            };
                                                            compress2 = function compress(a0, a1, a2, a3, a4) {
                                                              let r58, r59, r326, r471, r486, r491, bpl, bpp, height2, img2, img3, length10, length2, length6, width3;
                                                              const r42 = a4[0];
                                                              const r45 = a4[1];
                                                              const r52 = a4[2];
                                                              const r49 = a4[3];
                                                              const r47 = a4[4];
                                                              const r50 = a4[5];
                                                              const r38 = 0 < a0.length;
                                                              let r20 = 0;
                                                              let r29 = 255;
                                                              let r34 = 255;
                                                              if (r38) {
                                                                do {
                                                                  const uint8Array2 = new Uint8Array(a0[r20]);
                                                                  const length = uint8Array2.length;
                                                                  const r100 = 0 < length;
                                                                  const r25 = r20;
                                                                  let r28 = r29;
                                                                  let r22 = 0;
                                                                  let r32 = r28;
                                                                  if (r100) {
                                                                    do {
                                                                      r28 = r28 & uint8Array2[r22 + 3];
                                                                      r22 = r22 + 4;
                                                                      r32 = r28;
                                                                    } while (r22 < length);
                                                                  }
                                                                  r20 = r25 + 1;
                                                                  length2 = a0.length;
                                                                  r29 = r32;
                                                                  r34 = r29;
                                                                } while (r20 < length2);
                                                              }
                                                              const r105 = r34 !== 255;
                                                              const frames = [];
                                                              const r36 = 0 < a0.length;
                                                              let r110 = 0;
                                                              if (r36) {
                                                                do {
                                                                  const uint8Array = new Uint8Array(a0[r110]);
                                                                  const uint32Array = new Uint32Array(uint8Array.buffer);
                                                                  const r119 = r110;
                                                                  let blend2 = r42 ? 1 : 0;
                                                                  if (r119 !== 0) {
                                                                    const r26 = !r52 && !r42 && r119 !== 1 ? frames[r119 - 2].dispose != 0 ? 1 : 2 : 1;
                                                                    const r127 = r119 - 1;
                                                                    let r31 = 0;
                                                                    let r33 = 1000000000;
                                                                    let r128 = 0;
                                                                    let r64 = a2;
                                                                    let r63 = a1;
                                                                    let r62 = 0;
                                                                    let r129 = 0;
                                                                    let r130 = 0;
                                                                    let r61 = a2;
                                                                    let r60 = a1;
                                                                    let r55 = 0;
                                                                    let r131 = 0;
                                                                    while (r31 < r26) {
                                                                      const r69 = Uint8Array;
                                                                      const r27 = r127 - r31;
                                                                      new r69(a0[r27]);
                                                                      const uint32Array2 = new Uint32Array(a0[r27]);
                                                                      const r138 = 0 < a2;
                                                                      const r139 = r31;
                                                                      let r18 = r33;
                                                                      let r9 = r128;
                                                                      let r70 = r64;
                                                                      let r140 = r63;
                                                                      let r141 = r62;
                                                                      let r142 = r129;
                                                                      let r19 = 0;
                                                                      let r17 = -1;
                                                                      let r15 = -1;
                                                                      let r72 = a2;
                                                                      let r71 = a1;
                                                                      let r8 = -1;
                                                                      let r16 = -1;
                                                                      let r75 = a2;
                                                                      let r74 = a1;
                                                                      if (r138) {
                                                                        do {
                                                                          const r143 = 0 < a1;
                                                                          const r10 = r19;
                                                                          let r3 = r17;
                                                                          let r4 = r15;
                                                                          let r79 = r72;
                                                                          let r78 = r71;
                                                                          let r5 = 0;
                                                                          let r13 = r3;
                                                                          let r14 = r4;
                                                                          let r77 = r79;
                                                                          let r76 = r78;
                                                                          if (r143) {
                                                                            do {
                                                                              const r144 = r10 * a1 + r5;
                                                                              const r85 = uint32Array[r144];
                                                                              const r82 = uint32Array2[r144];
                                                                              const r145 = r5;
                                                                              const r11 = r3;
                                                                              const r0 = r4;
                                                                              const r84 = r79;
                                                                              const r83 = r78;
                                                                              let r6 = r11;
                                                                              let r7 = r0;
                                                                              let r81 = r84;
                                                                              let r80 = r83;
                                                                              if (r85 != r82) {
                                                                                const r146 = r145 < r83 ? r145 : r83;
                                                                                const r2 = r0 < r145 ? r145 : r0;
                                                                                const r147 = r10 < r84 ? r10 : r84;
                                                                                r6 = r11 < r10 ? r10 : r11;
                                                                                r7 = r2;
                                                                                r81 = r147;
                                                                                r80 = r146;
                                                                              }
                                                                              r5 = r145 + 1;
                                                                              r3 = r6;
                                                                              r4 = r7;
                                                                              r79 = r81;
                                                                              r78 = r80;
                                                                              r13 = r3;
                                                                              r14 = r4;
                                                                              r77 = r79;
                                                                              r76 = r78;
                                                                            } while (r5 < a1);
                                                                          }
                                                                          r19 = r10 + 1;
                                                                          r17 = r13;
                                                                          r15 = r14;
                                                                          r72 = r77;
                                                                          r71 = r76;
                                                                          r8 = r17;
                                                                          r16 = r15;
                                                                          r75 = r72;
                                                                          r74 = r71;
                                                                        } while (r19 < a2);
                                                                      }
                                                                      if (r16 === -1) {
                                                                        r8 = 0;
                                                                        r16 = 0;
                                                                        r75 = 0;
                                                                        r74 = 0;
                                                                      }
                                                                      let r149 = r75;
                                                                      let r150 = r74;
                                                                      if (r45) {
                                                                        const r153 = 1 & ~r74 ? r74 : r74 - 1;
                                                                        r149 = 1 & ~r75 ? r75 : r75 - 1;
                                                                        r150 = r153;
                                                                      }
                                                                      const r161 = (r16 - r150 + 1) * (r8 - r149 + 1);
                                                                      if (r161 < r18) {
                                                                        r140 = r16 - r150 + 1;
                                                                        r70 = r8 - r149 + 1;
                                                                        r18 = r161;
                                                                        r9 = r139;
                                                                        r141 = r149;
                                                                        r142 = r150;
                                                                      }
                                                                      r31 = r139 + 1;
                                                                      r33 = r18;
                                                                      r128 = r9;
                                                                      r64 = r70;
                                                                      r63 = r140;
                                                                      r62 = r141;
                                                                      r129 = r142;
                                                                      r130 = r128;
                                                                      r61 = r64;
                                                                      r60 = r63;
                                                                      r55 = r62;
                                                                      r131 = r129;
                                                                    }
                                                                    const uint8Array3 = new Uint8Array(a0[r127 - r130]);
                                                                    if (r130 === 1) {
                                                                      frames[r127].dispose = 2;
                                                                    }
                                                                    const uint8Array4 = new Uint8Array(r60 * r61 * 4);
                                                                    _copyTile2(uint8Array3, a1, a2, uint8Array4, r60, r61, -r131, -r55, 0);
                                                                    const r193 = _copyTile2(uint8Array, a1, a2, uint8Array4, r60, r61, -r131, -r55, 3) ? 1 : 0;
                                                                    if (r193 === 1) {
                                                                      _copyTile2(uint8Array, a1, a2, uint8Array4, r60, r61, -r131, -r55, 2);
                                                                      blend2 = r193;
                                                                      height2 = r61;
                                                                      width3 = r60;
                                                                      r58 = r55;
                                                                      r59 = r131;
                                                                      img2 = uint8Array4;
                                                                    } else {
                                                                      _copyTile2(uint8Array, a1, a2, uint8Array4, r60, r61, -r131, -r55, 0);
                                                                      blend2 = r193;
                                                                      height2 = r61;
                                                                      width3 = r60;
                                                                      r58 = r55;
                                                                      r59 = r131;
                                                                      img2 = uint8Array4;
                                                                    }
                                                                  } else {
                                                                    img2 = uint8Array.slice(0);
                                                                    height2 = a2;
                                                                    width3 = a1;
                                                                    r58 = 0;
                                                                    r59 = 0;
                                                                  }
                                                                  frames.push({
                                                                    rect: {
                                                                      x: r59,
                                                                      y: r58,
                                                                      width: width3,
                                                                      height: height2
                                                                    },
                                                                    img: img2,
                                                                    blend: blend2,
                                                                    dispose: 0
                                                                  });
                                                                  r110 = r119 + 1;
                                                                } while (r110 < a0.length);
                                                              }
                                                              if (r42) {
                                                                const r222 = 0 < frames.length;
                                                                let r223 = 0;
                                                                if (r222) {
                                                                  do {
                                                                    const r224 = frames[r223];
                                                                    const blend = r224.blend;
                                                                    const r226 = r223;
                                                                    if (blend != 1) {
                                                                      const rect = r224.rect;
                                                                      const r228 = r226 - 1;
                                                                      const rect2 = frames[r228].rect;
                                                                      const r235 = Math.min(rect.x, rect2.x);
                                                                      const r240 = Math.min(rect.y, rect2.y);
                                                                      const r251 = {
                                                                        x: r235,
                                                                        y: r240,
                                                                        width: Math.max(rect.x + rect.width, rect2.x + rect2.width) - r235,
                                                                        height: Math.max(rect.y + rect.height, rect2.y + rect2.height) - r240
                                                                      };
                                                                      frames[r228].dispose = 1;
                                                                      if (r228 !== 0) {
                                                                        _updateFrame2(a0, a1, a2, frames, r228, r251, r45);
                                                                      }
                                                                      _updateFrame2(a0, a1, a2, frames, r226, r251, r45);
                                                                    }
                                                                    r223 = r226 + 1;
                                                                  } while (r223 < frames.length);
                                                                }
                                                              }
                                                              if (a0.length != 1) {
                                                                const r286 = 0 < frames.length;
                                                                let r287 = 0;
                                                                if (r286) {
                                                                  do {
                                                                    const r288 = frames[r287];
                                                                    r288.rect.width * r288.rect.height;
                                                                    r287 = r287 + 1;
                                                                  } while (r287 < frames.length);
                                                                }
                                                              }
                                                              const r296 = {};
                                                              const plte = [];
                                                              const r298 = [];
                                                              if (a3 != 0) {
                                                                const r340 = [];
                                                                const r342 = 0 < frames.length;
                                                                let r343 = 0;
                                                                if (r342) {
                                                                  do {
                                                                    r340.push(frames[r343].img.buffer);
                                                                    r343 = r343 + 1;
                                                                  } while (r343 < frames.length);
                                                                }
                                                                const r351 = 0 < r340.length;
                                                                let r352 = 0;
                                                                let r353 = 0;
                                                                let r354 = 0;
                                                                if (r351) {
                                                                  do {
                                                                    r353 = r353 + r340[r352].byteLength;
                                                                    r352 = r352 + 1;
                                                                    length6 = r340.length;
                                                                    r354 = r353;
                                                                  } while (r352 < length6);
                                                                }
                                                                const uint8Array6 = new Uint8Array(r354);
                                                                const r365 = 0 < r340.length;
                                                                let r366 = 0;
                                                                let r367 = 0;
                                                                if (r365) {
                                                                  do {
                                                                    const uint8Array7 = new Uint8Array(r340[r367]);
                                                                    const length7 = uint8Array7.length;
                                                                    const r375 = 0 < length7;
                                                                    const r376 = r366;
                                                                    const r377 = r367;
                                                                    let r378 = 0;
                                                                    if (r375) {
                                                                      do {
                                                                        let r379 = uint8Array7[r378];
                                                                        let r381 = uint8Array7[r378 + 1];
                                                                        let r383 = uint8Array7[r378 + 2];
                                                                        const r385 = uint8Array7[r378 + 3];
                                                                        const r386 = r378;
                                                                        if (r385 == 0) {
                                                                          r383 = 0;
                                                                          r381 = 0;
                                                                          r379 = 0;
                                                                        }
                                                                        const r387 = r376 + r386;
                                                                        uint8Array6[r387] = r379;
                                                                        uint8Array6[r387 + 1] = r381;
                                                                        uint8Array6[r387 + 2] = r383;
                                                                        uint8Array6[r387 + 3] = r385;
                                                                        r378 = r386 + 4;
                                                                      } while (r378 < length7);
                                                                    }
                                                                    r366 = r376 + length7;
                                                                    r367 = r377 + 1;
                                                                  } while (r367 < r340.length);
                                                                }
                                                                const r394 = quantize2(uint8Array6.buffer, a3);
                                                                const r397 = 0 < r394.plte.length;
                                                                let r398 = 0;
                                                                if (r397) {
                                                                  do {
                                                                    plte.push(r394.plte[r398].est.rgba);
                                                                    r398 = r398 + 1;
                                                                  } while (r398 < r394.plte.length);
                                                                }
                                                                const r408 = 0 < frames.length;
                                                                let r409 = 0;
                                                                let r410 = 0;
                                                                if (r408) {
                                                                  do {
                                                                    const r411 = frames[r410];
                                                                    const length8 = r411.img.length;
                                                                    const uint8Array8 = new Uint8Array(r394.inds.buffer, r409 >> 2, length8 >> 2);
                                                                    r298.push(uint8Array8);
                                                                    const uint8Array9 = new Uint8Array(r394.abuf, r409, length8);
                                                                    const r433 = r409;
                                                                    const r434 = r410;
                                                                    if (r50) {
                                                                      dither2(r411.img, r411.rect.width, r411.rect.height, plte, uint8Array9, uint8Array8);
                                                                    }
                                                                    r411.img.set(uint8Array9);
                                                                    r409 = r433 + length8;
                                                                    r410 = r434 + 1;
                                                                  } while (r410 < frames.length);
                                                                }
                                                              } else {
                                                                const r39 = 0 < frames.length;
                                                                let r302 = 0;
                                                                if (r39) {
                                                                  do {
                                                                    const r303 = frames[r302];
                                                                    const uint32Array3 = new Uint32Array(r303.img.buffer);
                                                                    const width = r303.rect.width;
                                                                    const length3 = uint32Array3.length;
                                                                    const uint8Array5 = new Uint8Array(length3);
                                                                    r298.push(uint8Array5);
                                                                    const r322 = 0 < length3;
                                                                    const r323 = r302;
                                                                    let r324 = 0;
                                                                    if (r322) {
                                                                      do {
                                                                        L70: {
                                                                          const r325 = uint32Array3[r324];
                                                                          r326 = r324;
                                                                          if (r326 !== 0) {
                                                                            const r327 = r326 - 1;
                                                                            if (r325 == uint32Array3[r327]) {
                                                                              uint8Array5[r326] = uint8Array5[r327];
                                                                              break L70;
                                                                            }
                                                                          }
                                                                          if (r326 > width && r325 == uint32Array3[r326 - width]) {
                                                                            uint8Array5[r326] = uint8Array5[r326 - width];
                                                                          } else {
                                                                            let r331 = r296[r325];
                                                                            if (r331 == null) {
                                                                              const length4 = plte.length;
                                                                              r296[r325] = length4;
                                                                              plte.push(r325);
                                                                              const length5 = plte.length;
                                                                              r331 = length4;
                                                                              if (length5 >= 300) {
                                                                                break;
                                                                              }
                                                                            }
                                                                            uint8Array5[r326] = r331;
                                                                          }
                                                                        }
                                                                        r324 = r326 + 1;
                                                                      } while (r324 < length3);
                                                                    }
                                                                    r302 = r323 + 1;
                                                                  } while (r302 < frames.length);
                                                                }
                                                              }
                                                              const length9 = plte.length;
                                                              const depth = length9 <= 256 && r47 == 0 ? Math.max(length9 <= 2 ? 1 : length9 <= 4 ? 2 : length9 <= 16 ? 4 : 8, r49) : 8;
                                                              const r465 = 0 < frames.length;
                                                              let r468 = 0;
                                                              let r469 = 6;
                                                              let ctype = 6;
                                                              if (r465) {
                                                                do {
                                                                  L124: {
                                                                    r471 = frames[r468];
                                                                    r471.rect.x;
                                                                    r471.rect.y;
                                                                    const width2 = r471.rect.width;
                                                                    const height = r471.rect.height;
                                                                    const img = r471.img;
                                                                    new Uint32Array(img.buffer);
                                                                    const r485 = 4 * width2;
                                                                    r486 = r468;
                                                                    const r487 = r469;
                                                                    if (length9 <= 256 && r47 == 0) {
                                                                      const r516 = Math.ceil(depth * width2 / 8);
                                                                      const uint8Array11 = new Uint8Array(r516 * height);
                                                                      const r523 = r298[r486];
                                                                      const r524 = 0 < height;
                                                                      let r525 = 0;
                                                                      bpp = 1;
                                                                      bpl = r516;
                                                                      img3 = uint8Array11;
                                                                      r491 = 3;
                                                                      if (!r524) {
                                                                        break L124;
                                                                      }
                                                                      while (true) {
                                                                        const r526 = r525 * r516;
                                                                        const r527 = r525 * width2;
                                                                        const r528 = r525;
                                                                        if (depth == 8) {
                                                                          const r565 = 0 < width2;
                                                                          let r566 = 0;
                                                                          if (r565) {
                                                                            do {
                                                                              uint8Array11[r526 + r566] = r523[r527 + r566];
                                                                              r566 = r566 + 1;
                                                                            } while (r566 < width2);
                                                                          }
                                                                        } else if (depth == 4) {
                                                                          const r553 = 0 < width2;
                                                                          let r554 = 0;
                                                                          if (r553) {
                                                                            do {
                                                                              const r556 = r526 + (r554 >> 1);
                                                                              uint8Array11[r556] = uint8Array11[r556] | r523[r527 + r554] << 4 - 4 * (1 & r554);
                                                                              r554 = r554 + 1;
                                                                            } while (r554 < width2);
                                                                          }
                                                                        } else if (depth == 2) {
                                                                          const r541 = 0 < width2;
                                                                          let r542 = 0;
                                                                          if (r541) {
                                                                            do {
                                                                              const r544 = r526 + (r542 >> 2);
                                                                              uint8Array11[r544] = uint8Array11[r544] | r523[r527 + r542] << 6 - 2 * (3 & r542);
                                                                              r542 = r542 + 1;
                                                                            } while (r542 < width2);
                                                                          }
                                                                        } else if (depth == 1) {
                                                                          const r529 = 0 < width2;
                                                                          let r530 = 0;
                                                                          if (r529) {
                                                                            do {
                                                                              const r532 = r526 + (r530 >> 3);
                                                                              uint8Array11[r532] = uint8Array11[r532] | r523[r527 + r530] << 7 - 1 * (7 & r530);
                                                                              r530 = r530 + 1;
                                                                            } while (r530 < width2);
                                                                          }
                                                                        }
                                                                        const r570 = r528 + 1;
                                                                        const r571 = r570 < height;
                                                                        r525 = r570;
                                                                        bpp = 1;
                                                                        bpl = r516;
                                                                        img3 = uint8Array11;
                                                                        r491 = 3;
                                                                        if (!r571) {
                                                                          break L124;
                                                                        }
                                                                      }
                                                                    }
                                                                    bpp = 4;
                                                                    bpl = r485;
                                                                    img3 = img;
                                                                    r491 = r487;
                                                                    if (r105 == 0) {
                                                                      const r493 = frames.length == 1;
                                                                      bpp = 4;
                                                                      bpl = r485;
                                                                      img3 = img;
                                                                      r491 = r487;
                                                                      if (r493) {
                                                                        const uint8Array10 = new Uint8Array(width2 * height * 3);
                                                                        const r501 = width2 * height;
                                                                        let r502 = 0;
                                                                        while (r502 < r501) {
                                                                          const r503 = 3 * r502;
                                                                          const r504 = 4 * r502;
                                                                          uint8Array10[r503] = img[r504];
                                                                          uint8Array10[r503 + 1] = img[r504 + 1];
                                                                          uint8Array10[r503 + 2] = img[r504 + 2];
                                                                          r502 = r502 + 1;
                                                                        }
                                                                        bpl = 3 * width2;
                                                                        bpp = 3;
                                                                        img3 = uint8Array10;
                                                                        r491 = 2;
                                                                      }
                                                                    }
                                                                  }
                                                                  r471.img = img3;
                                                                  r471.bpl = bpl;
                                                                  r471.bpp = bpp;
                                                                  r468 = r486 + 1;
                                                                  length10 = frames.length;
                                                                  r469 = r491;
                                                                  ctype = r469;
                                                                } while (r468 < length10);
                                                              }
                                                              return {
                                                                ctype,
                                                                depth,
                                                                plte,
                                                                frames
                                                              };
                                                            };
                                                            _updateFrame2 = function _updateFrame(a0, a1, a2, a3, a4, a5, a6) {
                                                              let height, width;
                                                              const r21 = Uint8Array;
                                                              const r17 = Uint32Array;
                                                              const r18 = new r21(a0[a4 - 1]);
                                                              const r35 = new r17(a0[a4 - 1]);
                                                              const r34 = a4 + 1 < a0.length ? new r21(a0[a4 + 1]) : null;
                                                              const r79 = new r21(a0[a4]);
                                                              const r32 = new r17(r79.buffer);
                                                              const r86 = 0 < a5.height;
                                                              let r8 = 0;
                                                              let r31 = -1;
                                                              let r30 = -1;
                                                              let r27 = a2;
                                                              let r87 = a1;
                                                              let r26 = -1;
                                                              let r28 = -1;
                                                              let r29 = a2;
                                                              let r88 = a1;
                                                              if (r86) {
                                                                do {
                                                                  const r90 = 0 < a5.width;
                                                                  const r5 = r8;
                                                                  let r43 = r31;
                                                                  let r42 = r30;
                                                                  let r41 = r27;
                                                                  let r40 = r87;
                                                                  let r0 = 0;
                                                                  let r39 = r43;
                                                                  let r38 = r42;
                                                                  let r37 = r41;
                                                                  let r36 = r40;
                                                                  if (r90) {
                                                                    do {
                                                                      const r48 = a5.x + r0;
                                                                      const r51 = a5.y + r5;
                                                                      const r93 = r51 * a1 + r48;
                                                                      const r45 = r32[r93];
                                                                      let r94 = r45 == 0;
                                                                      const r95 = r0;
                                                                      const r52 = r43;
                                                                      const r53 = r42;
                                                                      const r50 = r41;
                                                                      const r49 = r40;
                                                                      if (!r94) {
                                                                        r94 = a3[a4 - 1].dispose == 0 && r35[r93] == r45 && (r34 == null || r34[4 * r93 + 3] != 0);
                                                                      }
                                                                      let r47 = r52;
                                                                      let r46 = r53;
                                                                      let r101 = r50;
                                                                      let r102 = r49;
                                                                      if (!r94) {
                                                                        const r103 = r48 < r49 ? r48 : r49;
                                                                        const r104 = r48 > r53 ? r48 : r53;
                                                                        const r105 = r51 < r50 ? r51 : r50;
                                                                        r47 = r51 > r52 ? r51 : r52;
                                                                        r46 = r104;
                                                                        r101 = r105;
                                                                        r102 = r103;
                                                                      }
                                                                      r0 = r95 + 1;
                                                                      width = a5.width;
                                                                      r43 = r47;
                                                                      r42 = r46;
                                                                      r41 = r101;
                                                                      r40 = r102;
                                                                      r39 = r43;
                                                                      r38 = r42;
                                                                      r37 = r41;
                                                                      r36 = r40;
                                                                    } while (r0 < width);
                                                                  }
                                                                  r8 = r5 + 1;
                                                                  height = a5.height;
                                                                  r31 = r39;
                                                                  r30 = r38;
                                                                  r27 = r37;
                                                                  r87 = r36;
                                                                  r26 = r31;
                                                                  r28 = r30;
                                                                  r29 = r27;
                                                                  r88 = r87;
                                                                } while (r8 < height);
                                                              }
                                                              if (r28 == -1) {
                                                                r26 = 0;
                                                                r28 = 0;
                                                                r29 = 0;
                                                                r88 = 0;
                                                              }
                                                              let r110 = r29;
                                                              let r111 = r88;
                                                              if (a6) {
                                                                const r114 = 1 & ~r88 ? r88 : r88 - 1;
                                                                r110 = 1 & ~r29 ? r29 : r29 - 1;
                                                                r111 = r114;
                                                              }
                                                              const rect = {
                                                                x: r111,
                                                                y: r110,
                                                                width: r28 - r111 + 1,
                                                                height: r26 - r110 + 1
                                                              };
                                                              const r124 = a3[a4];
                                                              r124.rect = rect;
                                                              r124.blend = 1;
                                                              r124.img = new Uint8Array(rect.width * rect.height * 4);
                                                              if (a3[a4 - 1].dispose == 0) {
                                                                _copyTile2(r18, a1, a2, r124.img, rect.width, rect.height, -rect.x, -rect.y, 0);
                                                                _copyTile2(r79, a1, a2, r124.img, rect.width, rect.height, -rect.x, -rect.y, 2);
                                                              } else {
                                                                _copyTile2(r79, a1, a2, r124.img, rect.width, rect.height, -rect.x, -rect.y, 0);
                                                              }
                                                            };
                                                            quantize2 = function quantize(a0, a1, a2) {
                                                              let left2;
                                                              Date.now();
                                                              const uint8Array = new Uint8Array(a0);
                                                              const r21 = uint8Array.slice(0);
                                                              const uint32Array = new Uint32Array(r21.buffer);
                                                              const kDtree2 = getKDtree2(r21, a1);
                                                              const r29 = kDtree2[0];
                                                              const plte = kDtree2[1];
                                                              const length = plte.length;
                                                              const uint32Array2 = new Uint32Array(length);
                                                              const uint8Array2 = new Uint8Array(uint32Array2.buffer);
                                                              const r17 = 0 < length;
                                                              let r6 = 0;
                                                              if (r17) {
                                                                do {
                                                                  uint32Array2[r6] = plte[r6].est.rgba;
                                                                  r6 = r6 + 1;
                                                                } while (r6 < length);
                                                              }
                                                              const length2 = uint8Array.length;
                                                              const uint8Array3 = new Uint8Array(length2 >> 2);
                                                              if (length <= 60) {
                                                                findNearest2(uint8Array, uint8Array3, uint8Array2);
                                                                const r125 = 0 < uint8Array3.length;
                                                                let r126 = 0;
                                                                if (r125) {
                                                                  do {
                                                                    uint32Array[r126] = uint32Array2[uint8Array3[r126]];
                                                                    r126 = r126 + 1;
                                                                  } while (r126 < uint8Array3.length);
                                                                }
                                                              } else if (uint8Array.length < 32000000) {
                                                                const r102 = 0 < length2;
                                                                let r106 = 0;
                                                                if (r102) {
                                                                  do {
                                                                    const nearest2 = getNearest2(r29, 0.00392156862745098 * uint8Array[r106], 0.00392156862745098 * uint8Array[r106 + 1], 0.00392156862745098 * uint8Array[r106 + 2], 0.00392156862745098 * uint8Array[r106 + 3]);
                                                                    const r118 = r106 >> 2;
                                                                    uint8Array3[r118] = nearest2.ind;
                                                                    uint32Array[r118] = nearest2.est.rgba;
                                                                    r106 = r106 + 4;
                                                                  } while (r106 < length2);
                                                                }
                                                              } else {
                                                                const r76 = 0 < length2;
                                                                let r77 = 0;
                                                                if (r76) {
                                                                  do {
                                                                    const r3 = 0.00392156862745098 * uint8Array[r77];
                                                                    const r2 = 0.00392156862745098 * uint8Array[r77 + 1];
                                                                    const r8 = 0.00392156862745098 * uint8Array[r77 + 2];
                                                                    const r4 = 0.00392156862745098 * uint8Array[r77 + 3];
                                                                    const left = r29.left;
                                                                    const r84 = r77;
                                                                    let r32 = r29;
                                                                    let r85 = r32;
                                                                    if (left) {
                                                                      do {
                                                                        const est = r32.est;
                                                                        const r33 = est.e;
                                                                        const r94 = r33[0] * r3 + r33[1] * r2 + r33[2] * r8 + r33[3] * r4 - est.eMq;
                                                                        const r95 = r32;
                                                                        const r96 = r94 <= 0 ? r95.left : r95.right;
                                                                        left2 = r96.left;
                                                                        r32 = r96;
                                                                        r85 = r32;
                                                                      } while (left2);
                                                                    }
                                                                    const r98 = r84 >> 2;
                                                                    uint8Array3[r98] = r85.ind;
                                                                    uint32Array[r98] = r85.est.rgba;
                                                                    r77 = r84 + 4;
                                                                  } while (r77 < length2);
                                                                }
                                                              }
                                                              L29: {
                                                                let r132 = 1000000000;
                                                                let r133 = 0;
                                                                if (!a2) {
                                                                  const r135 = uint8Array.length * length;
                                                                  r132 = 1000000000;
                                                                  r133 = 0;
                                                                  if (!(r135 < 40000000)) {
                                                                    break L29;
                                                                  }
                                                                }
                                                                while (true) {
                                                                  const r138 = uint8Array2.length >>> 2;
                                                                  const uint32Array3 = new Uint32Array(4 * r138);
                                                                  const uint32Array4 = new Uint32Array(r138);
                                                                  const r153 = 0 < uint8Array.length;
                                                                  const r155 = r132;
                                                                  const r156 = r133;
                                                                  let r157 = 0;
                                                                  if (r153) {
                                                                    do {
                                                                      const r159 = uint8Array3[r157 >>> 2];
                                                                      const r160 = 4 * r159;
                                                                      uint32Array4[r159] = uint32Array4[r159] + 1;
                                                                      uint32Array3[r160] = uint32Array3[r160] + uint8Array[r157];
                                                                      const r166 = r160 + 1;
                                                                      uint32Array3[r166] = uint32Array3[r166] + uint8Array[r157 + 1];
                                                                      const r171 = r160 + 2;
                                                                      uint32Array3[r171] = uint32Array3[r171] + uint8Array[r157 + 2];
                                                                      const r176 = r160 + 3;
                                                                      uint32Array3[r176] = uint32Array3[r176] + uint8Array[r157 + 3];
                                                                      r157 = r157 + 4;
                                                                    } while (r157 < uint8Array.length);
                                                                  }
                                                                  const r183 = 0 < uint8Array2.length;
                                                                  let r184 = 0;
                                                                  if (r183) {
                                                                    do {
                                                                      uint8Array2[r184] = Math.round(uint32Array3[r184] / uint32Array4[r184 >>> 2]);
                                                                      r184 = r184 + 1;
                                                                    } while (r184 < uint8Array2.length);
                                                                  }
                                                                  const r194 = findNearest2(uint8Array, uint8Array3, uint8Array2);
                                                                  if (!(0.997 < r194 / r155)) {
                                                                    r133 = r156 + 1;
                                                                    r132 = r194;
                                                                    if (r133 < 10) {
                                                                      continue;
                                                                    }
                                                                  }
                                                                  const r198 = 0 < length;
                                                                  let r199 = 0;
                                                                  if (r198) {
                                                                    do {
                                                                      plte[r199].est.rgba = uint32Array2[r199];
                                                                      r199 = r199 + 1;
                                                                    } while (r199 < length);
                                                                  }
                                                                  const r204 = 0 < uint8Array3.length;
                                                                  let r205 = 0;
                                                                  if (!r204) {
                                                                    break;
                                                                  }
                                                                  while (true) {
                                                                    uint32Array[r205] = uint32Array2[uint8Array3[r205]];
                                                                    r205 = r205 + 1;
                                                                    if (!(r205 < uint8Array3.length)) {
                                                                      break L29;
                                                                    }
                                                                  }
                                                                }
                                                              }
                                                              return {
                                                                abuf: r21.buffer,
                                                                inds: uint8Array3,
                                                                plte
                                                              };
                                                            };
                                                            findNearest2 = function findNearest(a0, a1, a2) {
                                                              let length;
                                                              const r14 = a2.length >>> 2;
                                                              const r18 = [];
                                                              let r11 = 0;
                                                              while (r11 < r14) {
                                                                const r6 = 4 * r11;
                                                                const r25 = a2[r6];
                                                                const r24 = a2[r6 + 1];
                                                                const r23 = a2[r6 + 2];
                                                                const r21 = a2[r6 + 3];
                                                                const r35 = r11;
                                                                let r36 = 0;
                                                                let r17 = 1000000000;
                                                                let r22 = 1000000000;
                                                                while (r36 < r14) {
                                                                  const r5 = r36;
                                                                  const r28 = r17;
                                                                  let r26 = r28;
                                                                  if (r35 !== r5) {
                                                                    const r1 = 4 * r5;
                                                                    const r37 = r25 - a2[r1];
                                                                    const r29 = r37 * r37;
                                                                    const r39 = r24 - a2[r1 + 1];
                                                                    const r41 = r29 + r39 * r39;
                                                                    const r44 = r23 - a2[r1 + 2];
                                                                    const r46 = r41 + r44 * r44;
                                                                    const r49 = r21 - a2[r1 + 3];
                                                                    const r51 = r46 + r49 * r49;
                                                                    r26 = r28;
                                                                    if (r51 < r26) {
                                                                      r26 = r51;
                                                                    }
                                                                  }
                                                                  r36 = r5 + 1;
                                                                  r17 = r26;
                                                                  r22 = r17;
                                                                }
                                                                r18[r35] = 0.5 * Math.sqrt(r22);
                                                                r18[r35] = r18[r35] * r18[r35];
                                                                r11 = r35 + 1;
                                                              }
                                                              const r15 = 0 < a0.length;
                                                              let r61 = 0;
                                                              let r62 = 0;
                                                              let r63 = 0;
                                                              if (r15) {
                                                                do {
                                                                  const r64 = a0[r61];
                                                                  const r66 = a0[r61 + 1];
                                                                  const r68 = a0[r61 + 2];
                                                                  const r70 = a0[r61 + 3];
                                                                  const r71 = r61 >>> 2;
                                                                  const r72 = a1[r71];
                                                                  const r73 = 4 * r72;
                                                                  const r75 = r64 - a2[r73];
                                                                  const r76 = r75 * r75;
                                                                  const r79 = r66 - a2[r73 + 1];
                                                                  const r81 = r76 + r79 * r79;
                                                                  const r84 = r68 - a2[r73 + 2];
                                                                  const r86 = r81 + r84 * r84;
                                                                  const r89 = r70 - a2[r73 + 3];
                                                                  const r91 = r86 + r89 * r89;
                                                                  const r92 = r18[r72];
                                                                  const r93 = r61;
                                                                  const r94 = r62;
                                                                  let r95 = r72;
                                                                  let r96 = r91;
                                                                  if (r96 > r92) {
                                                                    let r97 = 0;
                                                                    let r98 = r91;
                                                                    let r99 = r72;
                                                                    r96 = r98;
                                                                    r95 = r99;
                                                                    while (r97 < r14) {
                                                                      const r100 = 4 * r97;
                                                                      const r102 = r64 - a2[r100];
                                                                      const r103 = r102 * r102;
                                                                      const r105 = r66 - a2[r100 + 1];
                                                                      const r107 = r103 + r105 * r105;
                                                                      const r110 = r68 - a2[r100 + 2];
                                                                      const r112 = r107 + r110 * r110;
                                                                      const r115 = r70 - a2[r100 + 3];
                                                                      const r31 = r112 + r115 * r115;
                                                                      const r117 = r97;
                                                                      let r118 = r98;
                                                                      let r119 = r99;
                                                                      if (r31 < r118) {
                                                                        const r30 = r18[r117];
                                                                        r118 = r31;
                                                                        r119 = r117;
                                                                        r95 = r119;
                                                                        r96 = r118;
                                                                        if (r96 < r30) {
                                                                          break;
                                                                        }
                                                                      }
                                                                      r97 = r117 + 1;
                                                                      r98 = r118;
                                                                      r99 = r119;
                                                                      r96 = r98;
                                                                      r95 = r99;
                                                                    }
                                                                  }
                                                                  a1[r71] = r95;
                                                                  r62 = r94 + r96;
                                                                  r61 = r93 + 4;
                                                                  length = a0.length;
                                                                  r63 = r62;
                                                                } while (r61 < length);
                                                              }
                                                              return r63 / (a0.length >>> 2);
                                                            };
                                                            getKDtree2 = function getKDtree(a0, a1, a2) {
                                                              let r101, r122, r166, length;
                                                              const r21 = a2 == null ? 0.0001 : a2;
                                                              const uint32Array = new Uint32Array(a0.buffer);
                                                              const r40 = {
                                                                i0: 0,
                                                                i1: a0.length,
                                                                bst: null,
                                                                est: null,
                                                                tdst: 0,
                                                                left: null,
                                                                right: null
                                                              };
                                                              r40.bst = stats2(a0, r40.i0, r40.i1);
                                                              r40.est = estats2(r40.bst);
                                                              const r48 = [r40];
                                                              while (r48.length < a1) {
                                                                const r13 = 0 < r48.length;
                                                                let r4 = 0;
                                                                let r0 = 0;
                                                                let r23 = 0;
                                                                let r10 = 0;
                                                                let r51 = 0;
                                                                if (r13) {
                                                                  do {
                                                                    const r54 = r48[r4].est.L;
                                                                    const r1 = r4;
                                                                    let r2 = r0;
                                                                    let r24 = r23;
                                                                    if (r54 > r24) {
                                                                      r24 = r48[r1].est.L;
                                                                      r2 = r1;
                                                                    }
                                                                    r4 = r1 + 1;
                                                                    length = r48.length;
                                                                    r0 = r2;
                                                                    r23 = r24;
                                                                    r10 = r0;
                                                                    r51 = r23;
                                                                  } while (r4 < length);
                                                                }
                                                                if (r51 < r21) {
                                                                  break;
                                                                }
                                                                const r58 = r48[r10];
                                                                const { i0, i1 } = r58;
                                                                const r26 = r58.est.e;
                                                                const eMq255 = r58.est.eMq255;
                                                                let r63 = i1 - 4;
                                                                let r64 = i0;
                                                                let r65 = r64;
                                                                while (r65 < r63) {
                                                                  const r81 = a0[r64] * r26[0] + a0[r64 + 1] * r26[1] + a0[r64 + 2] * r26[2] + a0[r64 + 3] * r26[3];
                                                                  const r82 = r63;
                                                                  let r83 = r64;
                                                                  let r84 = r83;
                                                                  if (r81 <= eMq255) {
                                                                    do {
                                                                      const r31 = r83 + 4;
                                                                      r101 = a0[r31] * r26[0] + a0[r31 + 1] * r26[1] + a0[r31 + 2] * r26[2] + a0[r31 + 3] * r26[3];
                                                                      r83 = r31;
                                                                      r84 = r83;
                                                                    } while (r101 <= eMq255);
                                                                  }
                                                                  const r102 = vecDot2(a0, r82, r26);
                                                                  let r103 = r82;
                                                                  let r104 = r103;
                                                                  if (r102 > eMq255) {
                                                                    do {
                                                                      const r105 = r103 - 4;
                                                                      r122 = a0[r105] * r26[0] + a0[r105 + 1] * r26[1] + a0[r105 + 2] * r26[2] + a0[r105 + 3] * r26[3];
                                                                      r103 = r105;
                                                                      r104 = r103;
                                                                    } while (r122 > eMq255);
                                                                  }
                                                                  r65 = r84;
                                                                  if (r65 >= r104) {
                                                                    break;
                                                                  }
                                                                  const r124 = uint32Array[r84 >> 2];
                                                                  const r125 = r84 >> 2;
                                                                  const r126 = r104 >> 2;
                                                                  uint32Array[r125] = uint32Array[r126];
                                                                  uint32Array[r126] = r124;
                                                                  r64 = r84 + 4;
                                                                  r63 = r104 - 4;
                                                                  r65 = r64;
                                                                }
                                                                const r145 = a0[r65] * r26[0] + a0[r65 + 1] * r26[1] + a0[r65 + 2] * r26[2] + a0[r65 + 3] * r26[3];
                                                                let r146 = r65;
                                                                let r147 = r146;
                                                                if (r145 > eMq255) {
                                                                  do {
                                                                    const r148 = r146 - 4;
                                                                    r166 = a0[r148] * r26[0] + a0[r148 + 1] * r26[1] + a0[r148 + 2] * r26[2] + a0[r148 + 3] * r26[3];
                                                                    r146 = r148;
                                                                    r147 = r146;
                                                                  } while (r166 > eMq255);
                                                                }
                                                                L24: {
                                                                  const i12 = r147 + 4;
                                                                  if (!(r58.i0 >= i12) && !(r58.i1 <= i12)) {
                                                                    const left = {
                                                                      i0: r58.i0,
                                                                      i1: i12,
                                                                      bst: null,
                                                                      est: null,
                                                                      tdst: 0,
                                                                      left: null,
                                                                      right: null
                                                                    };
                                                                    left.bst = stats2(a0, left.i0, left.i1);
                                                                    left.est = estats2(left.bst);
                                                                    const right = {
                                                                      i0: i12,
                                                                      i1: r58.i1,
                                                                      bst: {
                                                                        R: [],
                                                                        m: [],
                                                                        N: r58.bst.N - left.bst.N
                                                                      },
                                                                      est: null,
                                                                      tdst: 0,
                                                                      left: null,
                                                                      right: null
                                                                    };
                                                                    let r189 = 0;
                                                                    while (true) {
                                                                      right.bst.R[r189] = r58.bst.R[r189] - left.bst.R[r189];
                                                                      r189 = r189 + 1;
                                                                      let r199 = 0;
                                                                      if (!(r189 < 16)) {
                                                                        while (true) {
                                                                          right.bst.m[r199] = r58.bst.m[r199] - left.bst.m[r199];
                                                                          r199 = r199 + 1;
                                                                          if (!(r199 < 4)) {
                                                                            right.est = estats2(right.bst);
                                                                            r58.left = left;
                                                                            r58.right = right;
                                                                            r48[r10] = left;
                                                                            r48.push(right);
                                                                            break L24;
                                                                          }
                                                                        }
                                                                      }
                                                                    }
                                                                  }
                                                                  r58.est.L = 0;
                                                                }
                                                              }
                                                              r48.sort(function(a, b) {
                                                                return b.bst.N - a.bst.N;
                                                              });
                                                              const r220 = 0 < r48.length;
                                                              let ind = 0;
                                                              if (r220) {
                                                                do {
                                                                  r48[ind].ind = ind;
                                                                  ind = ind + 1;
                                                                } while (ind < r48.length);
                                                              }
                                                              return [r40, r48];
                                                            };
                                                            getNearest2 = function getNearest(a0, a1, a2, a3, a4) {
                                                              if (a0.left == null) {
                                                                const r47 = a0.est.q;
                                                                const r49 = a1 - r47[0];
                                                                const r51 = a2 - r47[1];
                                                                const r53 = a3 - r47[2];
                                                                const r55 = a4 - r47[3];
                                                                a0.tdst = r49 * r49 + r51 * r51 + r53 * r53 + r55 * r55;
                                                                return a0;
                                                              }
                                                              const est = a0.est;
                                                              const r4 = est.e;
                                                              const r29 = r4[0] * a1 + r4[1] * a2 + r4[2] * a3 + r4[3] * a4 - est.eMq;
                                                              let left = a0.left;
                                                              let right = a0.right;
                                                              if (r29 > 0) {
                                                                left = a0.right;
                                                                right = a0.left;
                                                              }
                                                              const nearest2 = getNearest2(left, a1, a2, a3, a4);
                                                              if (nearest2.tdst <= r29 * r29) {
                                                                return nearest2;
                                                              }
                                                              const nearest22 = getNearest2(right, a1, a2, a3, a4);
                                                              return nearest22.tdst < nearest2.tdst ? nearest22 : nearest2;
                                                            };
                                                            vecDot2 = function vecDot(a0, a1, a2) {
                                                              return a0[a1] * a2[0] + a0[a1 + 1] * a2[1] + a0[a1 + 2] * a2[2] + a0[a1 + 3] * a2[3];
                                                            };
                                                            stats2 = function stats(a0, a1, a2) {
                                                              let r21 = a1;
                                                              const r20 = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
                                                              const r19 = [0, 0, 0, 0];
                                                              const r17 = a2 - a1 >> 2;
                                                              if (a1 < a2) {
                                                                do {
                                                                  const r0 = 0.00392156862745098 * a0[r21];
                                                                  const r1 = 0.00392156862745098 * a0[r21 + 1];
                                                                  const r2 = 0.00392156862745098 * a0[r21 + 2];
                                                                  const r3 = 0.00392156862745098 * a0[r21 + 3];
                                                                  r19[0] = r19[0] + r0;
                                                                  r19[1] = r19[1] + r1;
                                                                  r19[2] = r19[2] + r2;
                                                                  r19[3] = r19[3] + r3;
                                                                  r20[0] = r20[0] + r0 * r0;
                                                                  r20[1] = r20[1] + r0 * r1;
                                                                  r20[2] = r20[2] + r0 * r2;
                                                                  r20[3] = r20[3] + r0 * r3;
                                                                  r20[5] = r20[5] + r1 * r1;
                                                                  r20[6] = r20[6] + r1 * r2;
                                                                  r20[7] = r20[7] + r1 * r3;
                                                                  r20[10] = r20[10] + r2 * r2;
                                                                  r20[11] = r20[11] + r2 * r3;
                                                                  r20[15] = r20[15] + r3 * r3;
                                                                  r21 = r21 + 4;
                                                                } while (r21 < a2);
                                                              }
                                                              r20[4] = r20[1];
                                                              r20[8] = r20[2];
                                                              r20[9] = r20[6];
                                                              r20[12] = r20[3];
                                                              r20[13] = r20[7];
                                                              r20[14] = r20[11];
                                                              return {
                                                                R: r20,
                                                                m: r19,
                                                                N: r17
                                                              };
                                                            };
                                                            estats2 = function estats({ R: r13, m: r9, N: r11 }) {
                                                              const r12 = r9[0];
                                                              const r17 = r9[1];
                                                              const r16 = r9[2];
                                                              const r26 = r9[3];
                                                              const r1 = r11 == 0 ? 0 : 1 / r11;
                                                              const Cov = [r13[0] - r12 * r12 * r1, r13[1] - r12 * r17 * r1, r13[2] - r12 * r16 * r1, r13[3] - r12 * r26 * r1, r13[4] - r17 * r12 * r1, r13[5] - r17 * r17 * r1, r13[6] - r17 * r16 * r1, r13[7] - r17 * r26 * r1, r13[8] - r16 * r12 * r1, r13[9] - r16 * r17 * r1, r13[10] - r16 * r16 * r1, r13[11] - r16 * r26 * r1, r13[12] - r26 * r12 * r1, r13[13] - r26 * r17 * r1, r13[14] - r26 * r16 * r1, r13[15] - r26 * r26 * r1];
                                                              const r19 = [Math.random(), Math.random(), Math.random(), Math.random()];
                                                              const r104 = r11 != 0;
                                                              let r105 = 0;
                                                              let r106 = r19;
                                                              if (r104) {
                                                                const r20 = c1597_16.multVec(Cov, r19);
                                                                const r111 = Math.sqrt(c1597_16.dot(r20, r20));
                                                                const r114 = c1597_16.sml(1 / r111, r20);
                                                                let r115 = 0;
                                                                let r116 = r111;
                                                                let r117 = r114;
                                                                while (true) {
                                                                  const r2 = r115 + 1;
                                                                  const r22 = r116;
                                                                  const r118 = r117;
                                                                  r105 = r22;
                                                                  r106 = r118;
                                                                  if (!(r2 < 16)) {
                                                                    break;
                                                                  }
                                                                  const r120 = c1597_16.multVec(Cov, r118);
                                                                  const r123 = Math.sqrt(c1597_16.dot(r120, r120));
                                                                  const r125 = c1597_16.sml(1 / r123, r120);
                                                                  r115 = r2;
                                                                  r116 = r123;
                                                                  r117 = r125;
                                                                  if (r2 !== 0) {
                                                                    const r128 = Math.abs(r123 - r22);
                                                                    r115 = r2;
                                                                    r116 = r123;
                                                                    r117 = r125;
                                                                    r105 = r22;
                                                                    r106 = r117;
                                                                    if (r128 < 1e-9) {
                                                                      break;
                                                                    }
                                                                  }
                                                                }
                                                              }
                                                              const r130 = [r12 * r1, r17 * r1, r16 * r1, r26 * r1];
                                                              return {
                                                                Cov,
                                                                q: r130,
                                                                e: r106,
                                                                L: r105,
                                                                eMq255: c1597_16.dot(c1597_16.sml(255, r130), r106),
                                                                eMq: c1597_16.dot(r106, r130),
                                                                rgba: (Math.round(255 * r130[3]) << 24 | Math.round(255 * r130[2]) << 16 | Math.round(255 * r130[1]) << 8 | Math.round(255 * r130[0])) >>> 0
                                                              };
                                                            };
                                                            _copyTile2 = exports2._copyTile;
                                                            _bin = exports2._bin;
                                                            _paeth2 = exports2._paeth;
                                                            const uint32Array = new Uint32Array(256);
                                                            let r375 = 0;
                                                            loop56: while (true) {
                                                              const r376 = r375;
                                                              let r377 = 0;
                                                              let r378 = r376;
                                                              while (true) {
                                                                const r379 = r378 >>> 1;
                                                                const r380 = 1 & r378;
                                                                const r381 = r377;
                                                                const r382 = r380 ? 3988292384 ^ r379 : r379;
                                                                r377 = r381 + 1;
                                                                r378 = r382;
                                                                if (!(r377 < 8)) {
                                                                  uint32Array[r376] = r382;
                                                                  r375 = r376 + 1;
                                                                  if (r375 < 256) {
                                                                    continue loop56;
                                                                  }
                                                                  c1597_3 = {
                                                                    table: uint32Array,
                                                                    update: function update(a0, a1, a2, a3) {
                                                                      let r8 = a0;
                                                                      let r0 = 0;
                                                                      const r6 = 0 < a3;
                                                                      let r7 = a0;
                                                                      if (r6) {
                                                                        do {
                                                                          r8 = c1597_3.table[255 & (r8 ^ a1[a2 + r0])] ^ r8 >>> 8;
                                                                          r0 = r0 + 1;
                                                                          r7 = r8;
                                                                        } while (r0 < a3);
                                                                      }
                                                                      return r7;
                                                                    },
                                                                    crc: function crc(a0, a1, a2) {
                                                                      return 4294967295 ^ c1597_3.update(4294967295, a0, a1, a2);
                                                                    }
                                                                  };
                                                                  c1597_16 = {
                                                                    multVec: function multVec(a0, a1) {
                                                                      return [a0[0] * a1[0] + a0[1] * a1[1] + a0[2] * a1[2] + a0[3] * a1[3], a0[4] * a1[0] + a0[5] * a1[1] + a0[6] * a1[2] + a0[7] * a1[3], a0[8] * a1[0] + a0[9] * a1[1] + a0[10] * a1[2] + a0[11] * a1[3], a0[12] * a1[0] + a0[13] * a1[1] + a0[14] * a1[2] + a0[15] * a1[3]];
                                                                    },
                                                                    dot: function dot(a0, a1) {
                                                                      return a0[0] * a1[0] + a0[1] * a1[1] + a0[2] * a1[2] + a0[3] * a1[3];
                                                                    },
                                                                    sml: function sml(a0, a1) {
                                                                      return [a0 * a1[0], a0 * a1[1], a0 * a1[2], a0 * a1[3]];
                                                                    }
                                                                  };
                                                                  exports2.encode = function encode(a0, a1, a2, a3, a4, a5, a6) {
                                                                    const r21 = compress2(a0, a1, a2, a3 == null ? 0 : a3, [false, false, false, 0, a6 == null ? false : a6, false]);
                                                                    compressPNG2(r21, -1);
                                                                    return _main2(r21, a1, a2, a4, a5);
                                                                  };
                                                                  exports2.encodeLL = function encodeLL(a0, a1, a2, a3, a4, a5, a6, a7) {
                                                                    const r10 = {
                                                                      ctype: 0 + (a3 == 1 ? 0 : 2) + (a4 == 0 ? 0 : 4),
                                                                      depth: a5,
                                                                      frames: []
                                                                    };
                                                                    Date.now();
                                                                    const r32 = (a3 + a4) * a5;
                                                                    const r33 = r32 * a1;
                                                                    const r35 = 0 < a0.length;
                                                                    let r37 = 0;
                                                                    if (r35) {
                                                                      do {
                                                                        r10.frames.push({
                                                                          rect: {
                                                                            x: 0,
                                                                            y: 0,
                                                                            width: a1,
                                                                            height: a2
                                                                          },
                                                                          img: new Uint8Array(a0[r37]),
                                                                          blend: 0,
                                                                          dispose: 1,
                                                                          bpp: Math.ceil(r32 / 8),
                                                                          bpl: Math.ceil(r33 / 8)
                                                                        });
                                                                        r37 = r37 + 1;
                                                                      } while (r37 < a0.length);
                                                                    }
                                                                    compressPNG2(r10, 0, true);
                                                                    return _main2(r10, a1, a2, a6, a7);
                                                                  };
                                                                  exports2.encode.compress = compress2;
                                                                  exports2.encode.dither = dither2;
                                                                  exports2.quantize = quantize2;
                                                                  exports2.quantize.findNearest = findNearest2;
                                                                  exports2.quantize.getKDtree = getKDtree2;
                                                                  exports2.quantize.getNearest = getNearest2;
                                                                  module.exports = exports2;
                                                                  return void 0;
                                                                }
                                                              }
                                                            }
                                                          }
                                                        }
                                                      }
                                                    }
                                                  }
                                                }
                                              }
                                            }
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
}