2788 lines
145 KiB
JavaScript
2788 lines
145 KiB
JavaScript
// Metro module 12722 (f12723).
|
|
import { Buf16, Buf32, Buf8, arraySet } from "./Module12712";
|
|
import * as _inflate_table from "./inflate_table";
|
|
import * as _Module12719 from "./Module12719";
|
|
import * as _inflate_fast from "./inflate_fast";
|
|
import * as _adler32 from "./adler32";
|
|
let inflateReset, inflateInit2, lencode, distcode, c8766_7, updatewindow;
|
|
const InflateState = function InflateState() {
|
|
this.mode = 0;
|
|
this.last = false;
|
|
this.wrap = 0;
|
|
this.havedict = false;
|
|
this.flags = 0;
|
|
this.dmax = 0;
|
|
this.check = 0;
|
|
this.total = 0;
|
|
this.head = null;
|
|
this.wbits = 0;
|
|
this.wsize = 0;
|
|
this.whave = 0;
|
|
this.wnext = 0;
|
|
this.window = null;
|
|
this.hold = 0;
|
|
this.bits = 0;
|
|
this.length = 0;
|
|
this.offset = 0;
|
|
this.extra = 0;
|
|
this.lencode = null;
|
|
this.distcode = null;
|
|
this.lenbits = 0;
|
|
this.distbits = 0;
|
|
this.ncode = 0;
|
|
this.nlen = 0;
|
|
this.ndist = 0;
|
|
this.have = 0;
|
|
this.next = null;
|
|
this.lens = new Buf16(320);
|
|
this.work = new Buf16(288);
|
|
this.lendyn = null;
|
|
this.distdyn = null;
|
|
this.sane = 0;
|
|
this.back = 0;
|
|
this.was = 0;
|
|
};
|
|
inflateReset = function inflateReset(a0) {
|
|
let r1 = -2;
|
|
if (a0) {
|
|
const state = a0.state;
|
|
r1 = -2;
|
|
if (state) {
|
|
const state2 = a0.state;
|
|
state2.wsize = 0;
|
|
state2.whave = 0;
|
|
state2.wnext = 0;
|
|
let r2 = -2;
|
|
if (a0) {
|
|
const state3 = a0.state;
|
|
r2 = -2;
|
|
if (state3) {
|
|
const state4 = a0.state;
|
|
state4.total = 0;
|
|
a0.total_out = 0;
|
|
a0.total_in = 0;
|
|
a0.msg = "";
|
|
if (state4.wrap) {
|
|
a0.adler = 1 & state4.wrap;
|
|
}
|
|
state4.mode = 1;
|
|
state4.last = 0;
|
|
state4.havedict = 0;
|
|
state4.dmax = 32768;
|
|
state4.head = null;
|
|
state4.hold = 0;
|
|
state4.bits = 0;
|
|
const buf32 = new Buf32(852);
|
|
state4.lendyn = buf32;
|
|
state4.lencode = buf32;
|
|
const buf322 = new Buf32(592);
|
|
state4.distdyn = buf322;
|
|
state4.distcode = buf322;
|
|
state4.sane = 1;
|
|
state4.back = -1;
|
|
r2 = 0;
|
|
}
|
|
}
|
|
r1 = r2;
|
|
}
|
|
}
|
|
return r1;
|
|
};
|
|
inflateInit2 = function inflateInit2(strm, windowBits) {
|
|
let r27, wbits, wrap;
|
|
let r3 = -2;
|
|
if (strm) {
|
|
const state3 = {
|
|
__proto__: InflateState.prototype
|
|
};
|
|
new InflateState();
|
|
strm.state = state3;
|
|
state3.window = null;
|
|
let r2 = -2;
|
|
if (strm) {
|
|
const state = strm.state;
|
|
r2 = -2;
|
|
if (state) {
|
|
const state2 = strm.state;
|
|
if (windowBits < 0) {
|
|
wbits = -windowBits;
|
|
wrap = 0;
|
|
} else {
|
|
wrap = 1 + (windowBits >> 4);
|
|
wbits = windowBits;
|
|
if (windowBits < 48) {
|
|
wbits = windowBits & 15;
|
|
wrap = wrap;
|
|
}
|
|
}
|
|
L15: {
|
|
if (wbits) {
|
|
const r7 = wbits < 8;
|
|
r27 = -2;
|
|
if (r7) {
|
|
break L15;
|
|
}
|
|
const r29 = wbits > 15;
|
|
r27 = -2;
|
|
if (r29) {
|
|
break L15;
|
|
}
|
|
}
|
|
if (state2.window !== null && state2.wbits !== wbits) {
|
|
state2.window = null;
|
|
}
|
|
state2.wrap = wrap;
|
|
state2.wbits = wbits;
|
|
r27 = inflateReset(strm);
|
|
}
|
|
r2 = r27;
|
|
}
|
|
}
|
|
r3 = r2;
|
|
if (r2 !== 0) {
|
|
strm.state = null;
|
|
r3 = r2;
|
|
}
|
|
}
|
|
return r3;
|
|
};
|
|
updatewindow = function updatewindow({ state }, output, a2, length) {
|
|
if (state.window === null) {
|
|
state.wsize = 1 << state.wbits;
|
|
state.wnext = 0;
|
|
state.whave = 0;
|
|
state.window = new Buf8(state.wsize);
|
|
}
|
|
if (length >= state.wsize) {
|
|
arraySet(state.window, output, a2 - state.wsize, state.wsize, 0);
|
|
state.wnext = 0;
|
|
state.whave = state.wsize;
|
|
} else {
|
|
let r9 = state.wsize - state.wnext;
|
|
if (r9 > length) {
|
|
r9 = length;
|
|
}
|
|
arraySet(state.window, output, a2 - length, r9, state.wnext);
|
|
const wnext = length - r9;
|
|
const r43 = r9;
|
|
if (wnext) {
|
|
arraySet(state.window, output, a2 - wnext, wnext, 0);
|
|
state.wnext = wnext;
|
|
state.whave = state.wsize;
|
|
} else {
|
|
state.wnext = state.wnext + r43;
|
|
if (state.wnext === state.wsize) {
|
|
state.wnext = 0;
|
|
}
|
|
if (state.whave < state.wsize) {
|
|
state.whave = state.whave + r43;
|
|
}
|
|
}
|
|
}
|
|
return 0;
|
|
};
|
|
c8766_7 = true;
|
|
export { inflateReset };
|
|
export function inflateReset2(a0, a1) {
|
|
let r19, wbits, wrap;
|
|
let r2 = -2;
|
|
if (a0) {
|
|
const state = a0.state;
|
|
r2 = -2;
|
|
if (state) {
|
|
const state2 = a0.state;
|
|
if (a1 < 0) {
|
|
wbits = -a1;
|
|
wrap = 0;
|
|
} else {
|
|
wrap = 1 + (a1 >> 4);
|
|
wbits = a1;
|
|
if (a1 < 48) {
|
|
wbits = a1 & 15;
|
|
wrap = wrap;
|
|
}
|
|
}
|
|
L14: {
|
|
if (wbits) {
|
|
const r7 = wbits < 8;
|
|
r19 = -2;
|
|
if (r7) {
|
|
break L14;
|
|
}
|
|
const r21 = wbits > 15;
|
|
r19 = -2;
|
|
if (r21) {
|
|
break L14;
|
|
}
|
|
}
|
|
if (state2.window !== null && state2.wbits !== wbits) {
|
|
state2.window = null;
|
|
}
|
|
state2.wrap = wrap;
|
|
state2.wbits = wbits;
|
|
r19 = inflateReset(a0);
|
|
}
|
|
r2 = r19;
|
|
}
|
|
}
|
|
return r2;
|
|
}
|
|
export function inflateResetKeep(a0) {
|
|
let r0 = -2;
|
|
if (a0) {
|
|
const state = a0.state;
|
|
r0 = -2;
|
|
if (state) {
|
|
const state2 = a0.state;
|
|
state2.total = 0;
|
|
a0.total_out = 0;
|
|
a0.total_in = 0;
|
|
a0.msg = "";
|
|
if (state2.wrap) {
|
|
a0.adler = 1 & state2.wrap;
|
|
}
|
|
state2.mode = 1;
|
|
state2.last = 0;
|
|
state2.havedict = 0;
|
|
state2.dmax = 32768;
|
|
state2.head = null;
|
|
state2.hold = 0;
|
|
state2.bits = 0;
|
|
const buf32 = new Buf32(852);
|
|
state2.lendyn = buf32;
|
|
state2.lencode = buf32;
|
|
const buf322 = new Buf32(592);
|
|
state2.distdyn = buf322;
|
|
state2.distcode = buf322;
|
|
state2.sane = 1;
|
|
state2.back = -1;
|
|
r0 = 0;
|
|
}
|
|
}
|
|
return r0;
|
|
}
|
|
export function inflateInit(a0) {
|
|
return inflateInit2(a0, 15);
|
|
}
|
|
export { inflateInit2 };
|
|
export function inflate(a0, a1) {
|
|
let r68, r69, r70, r120, r129, r132, r139, r140, r141, r142, r143, r144, r145, r146, r147, r148, r149, r150, r151, r152, r153, r154, r155, r156, r157, r158, r159, r160, r161, r162, r163, r164, r165, r166, r167, r168, r169, r170, r171, r172, r173, r174, r177, r178, r179, r180, r181, r182, r183, r184, r185, r186, r187, r188, r190, r191, r192, r193, r194, r196, r201, r202, r203, r204, r205, r206, r207, r208, r209, r210, r211, r212, r213, r214, r215, r216, r217, r218, r219, r220, r221, r222, r223, r224, r225, r226, r228, r229, r230, r231, r232, r233, r234, r235, r244, r474, r475, r485, r532, r533, r534, r535, r540, r548, r666, r784, r830, r831, r839, r840, r1133, r1134, r1135, r1136, r1228, r1229, r1261, r1262, avail_in3, avail_in4, avail_in5, avail_out3, bits3, bits4, bits5, have2, have4, hold3, hold4, hold5, ncode2, next_in3, next_in4, next_in5, next_out3, window2;
|
|
L5: {
|
|
const buf8 = new Buf8(4);
|
|
const r114 = [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15];
|
|
if (a0 && a0.state && a0.output) {
|
|
if (!a0.input && a0.avail_in !== 0) {
|
|
break L5;
|
|
}
|
|
const state = a0.state;
|
|
if (state.mode === 12) {
|
|
state.mode = 13;
|
|
}
|
|
let next_out = a0.next_out;
|
|
let output = a0.output;
|
|
let avail_out = a0.avail_out;
|
|
let next_in = a0.next_in;
|
|
let input = a0.input;
|
|
const avail_in = a0.avail_in;
|
|
let hold = state.hold;
|
|
let bits = state.bits;
|
|
let r86 = 0;
|
|
let r272 = avail_out;
|
|
let r273 = avail_in;
|
|
loop9: while (true) {
|
|
L349: {
|
|
const mode = state.mode;
|
|
const r128 = r86;
|
|
const r127 = avail_out;
|
|
const r126 = bits;
|
|
const r125 = hold;
|
|
avail_out3 = r272;
|
|
const r123 = r273;
|
|
next_out3 = next_out;
|
|
const r121 = next_in;
|
|
r120 = output;
|
|
if (mode === 1) {
|
|
if (state.wrap === 0) {
|
|
state.mode = 13;
|
|
r86 = r128;
|
|
avail_out = r127;
|
|
bits = r126;
|
|
hold = r125;
|
|
r272 = avail_out3;
|
|
r273 = r123;
|
|
next_out = next_out3;
|
|
next_in = r121;
|
|
output = r120;
|
|
input = input;
|
|
continue;
|
|
}
|
|
let r1321 = r126;
|
|
let r1322 = r125;
|
|
let r1323 = r123;
|
|
let r1324 = r121;
|
|
let r1325 = r1321;
|
|
let r1326 = r1322;
|
|
let r1327 = r1323;
|
|
let r1328 = r1324;
|
|
while (r1325 < 16) {
|
|
const r1329 = r1321;
|
|
const r1330 = r1322;
|
|
const r1331 = r1323;
|
|
const r1332 = r1324;
|
|
r129 = r128;
|
|
r132 = r127;
|
|
bits3 = r1329;
|
|
hold3 = r1330;
|
|
next_in3 = r1332;
|
|
avail_in3 = r1331;
|
|
if (avail_in3 === 0) {
|
|
break L349;
|
|
}
|
|
r1323 = r1331 - 1;
|
|
const r1333 = +r1332;
|
|
r1324 = r1333 + 1;
|
|
r1322 = r1330 + (input[r1333] << r1329);
|
|
r1321 = r1329 + 8;
|
|
r1326 = r1322;
|
|
r1327 = r1323;
|
|
r1328 = r1324;
|
|
r1325 = r1321;
|
|
}
|
|
if (2 & state.wrap && r1326 === 35615) {
|
|
state.check = 0;
|
|
buf8[0] = 255 & r1326;
|
|
buf8[1] = r1326 >>> 8 & 255;
|
|
state.check = _Module12719(state.check, buf8, 2, 0);
|
|
state.mode = 2;
|
|
r86 = r128;
|
|
avail_out = r127;
|
|
bits = 0;
|
|
hold = 0;
|
|
r272 = avail_out3;
|
|
r273 = r1327;
|
|
next_out = next_out3;
|
|
next_in = r1328;
|
|
output = r120;
|
|
input = input;
|
|
continue;
|
|
}
|
|
state.flags = 0;
|
|
if (state.head) {
|
|
state.head.done = false;
|
|
}
|
|
if (1 & state.wrap && !((((255 & r1326) << 8) + (r1326 >> 8)) % 31)) {
|
|
if ((15 & r1326) !== 8) {
|
|
a0.msg = "unknown compression method";
|
|
state.mode = 30;
|
|
r86 = r128;
|
|
avail_out = r127;
|
|
bits = r1325;
|
|
hold = r1326;
|
|
r272 = avail_out3;
|
|
r273 = r1327;
|
|
next_out = next_out3;
|
|
next_in = r1328;
|
|
output = r120;
|
|
input = input;
|
|
continue;
|
|
}
|
|
const r1348 = r1325 - 4;
|
|
const r1349 = r1326 >>> 4;
|
|
const wbits = 8 + (15 & r1349);
|
|
if (state.wbits === 0) {
|
|
state.wbits = wbits;
|
|
} else if (wbits > state.wbits) {
|
|
a0.msg = "invalid window size";
|
|
state.mode = 30;
|
|
r86 = r128;
|
|
avail_out = r127;
|
|
bits = r1348;
|
|
hold = r1349;
|
|
r272 = avail_out3;
|
|
r273 = r1327;
|
|
next_out = next_out3;
|
|
next_in = r1328;
|
|
output = r120;
|
|
input = input;
|
|
continue;
|
|
}
|
|
state.dmax = 1 << wbits;
|
|
state.check = 1;
|
|
a0.adler = 1;
|
|
state.mode = 512 & r1349 ? 10 : 12;
|
|
r86 = r128;
|
|
avail_out = r127;
|
|
bits = 0;
|
|
hold = 0;
|
|
r272 = avail_out3;
|
|
r273 = r1327;
|
|
next_out = next_out3;
|
|
next_in = r1328;
|
|
output = r120;
|
|
input = input;
|
|
continue;
|
|
}
|
|
a0.msg = "incorrect header check";
|
|
state.mode = 30;
|
|
r86 = r128;
|
|
avail_out = r127;
|
|
bits = r1325;
|
|
hold = r1326;
|
|
r272 = avail_out3;
|
|
r273 = r1327;
|
|
next_out = next_out3;
|
|
next_in = r1328;
|
|
output = r120;
|
|
input = input;
|
|
continue;
|
|
}
|
|
L317: {
|
|
L301: {
|
|
L285: {
|
|
L272: {
|
|
L261: {
|
|
L253: {
|
|
if (mode === 2) {
|
|
let r1019 = r126;
|
|
let r1020 = r125;
|
|
let r1021 = r123;
|
|
let r1022 = r121;
|
|
let r1023 = r1019;
|
|
let flags2 = r1020;
|
|
let r1025 = r1021;
|
|
let r1026 = r1022;
|
|
while (r1023 < 16) {
|
|
const r1027 = r1019;
|
|
const r1028 = r1020;
|
|
const r1029 = r1021;
|
|
const r1030 = r1022;
|
|
r129 = r128;
|
|
r132 = r127;
|
|
bits3 = r1027;
|
|
hold3 = r1028;
|
|
next_in3 = r1030;
|
|
avail_in3 = r1029;
|
|
if (avail_in3 === 0) {
|
|
break L349;
|
|
}
|
|
r1021 = r1029 - 1;
|
|
const r1031 = +r1030;
|
|
r1022 = r1031 + 1;
|
|
r1020 = r1028 + (input[r1031] << r1027);
|
|
r1019 = r1027 + 8;
|
|
flags2 = r1020;
|
|
r1025 = r1021;
|
|
r1026 = r1022;
|
|
r1023 = r1019;
|
|
}
|
|
state.flags = flags2;
|
|
if ((255 & state.flags) !== 8) {
|
|
a0.msg = "unknown compression method";
|
|
state.mode = 30;
|
|
r86 = r128;
|
|
avail_out = r127;
|
|
bits = r1023;
|
|
hold = flags2;
|
|
r272 = avail_out3;
|
|
r273 = r1025;
|
|
next_out = next_out3;
|
|
next_in = r1026;
|
|
output = r120;
|
|
input = input;
|
|
continue;
|
|
}
|
|
if (57344 & state.flags) {
|
|
a0.msg = "unknown header flags set";
|
|
state.mode = 30;
|
|
r86 = r128;
|
|
avail_out = r127;
|
|
bits = r1023;
|
|
hold = flags2;
|
|
r272 = avail_out3;
|
|
r273 = r1025;
|
|
next_out = next_out3;
|
|
next_in = r1026;
|
|
output = r120;
|
|
input = input;
|
|
continue;
|
|
}
|
|
if (state.head) {
|
|
state.head.text = flags2 >> 8 & 1;
|
|
}
|
|
if (512 & state.flags) {
|
|
buf8[0] = 255 & flags2;
|
|
buf8[1] = flags2 >>> 8 & 255;
|
|
state.check = _Module12719(state.check, buf8, 2, 0);
|
|
}
|
|
state.mode = 3;
|
|
r169 = 0;
|
|
r163 = 0;
|
|
r162 = r1025;
|
|
r157 = r1026;
|
|
} else {
|
|
r169 = r126;
|
|
r163 = r125;
|
|
r162 = r123;
|
|
r157 = r121;
|
|
if (mode !== 3) {
|
|
r164 = r126;
|
|
r156 = r125;
|
|
r143 = r123;
|
|
r142 = r121;
|
|
if (mode === 4) {
|
|
break L253;
|
|
}
|
|
r166 = r126;
|
|
r161 = r125;
|
|
r160 = r123;
|
|
r159 = r121;
|
|
if (mode === 5) {
|
|
break L261;
|
|
}
|
|
r154 = r126;
|
|
r150 = r125;
|
|
r158 = r123;
|
|
r155 = r121;
|
|
if (mode === 6) {
|
|
break L272;
|
|
}
|
|
r149 = r126;
|
|
r146 = r125;
|
|
r153 = r123;
|
|
r152 = r121;
|
|
if (mode === 7) {
|
|
break L285;
|
|
}
|
|
r145 = r126;
|
|
r144 = r125;
|
|
r148 = r123;
|
|
r147 = r121;
|
|
if (mode === 8) {
|
|
break L301;
|
|
}
|
|
r151 = r126;
|
|
r141 = r125;
|
|
r140 = r123;
|
|
r139 = r121;
|
|
if (mode === 9) {
|
|
break L317;
|
|
}
|
|
L207: {
|
|
L205: {
|
|
if (mode === 10) {
|
|
let r903 = r126;
|
|
let r904 = r125;
|
|
let r905 = r123;
|
|
let r906 = r121;
|
|
let r907 = r904;
|
|
let r908 = r905;
|
|
let r909 = r906;
|
|
while (r903 < 32) {
|
|
const r910 = r903;
|
|
const r911 = r904;
|
|
const r912 = r905;
|
|
const r913 = r906;
|
|
r129 = r128;
|
|
r132 = r127;
|
|
bits3 = r910;
|
|
hold3 = r911;
|
|
next_in3 = r913;
|
|
avail_in3 = r912;
|
|
if (avail_in3 === 0) {
|
|
break L349;
|
|
}
|
|
r905 = r912 - 1;
|
|
const r914 = +r913;
|
|
r906 = r914 + 1;
|
|
r904 = r911 + (input[r914] << r910);
|
|
r903 = r910 + 8;
|
|
r907 = r904;
|
|
r908 = r905;
|
|
r909 = r906;
|
|
}
|
|
const check3 = (r907 >>> 24 & 255) + (r907 >>> 8 & 65280) + ((65280 & r907) << 8) + ((255 & r907) << 24);
|
|
state.check = check3;
|
|
a0.adler = check3;
|
|
state.mode = 11;
|
|
avail_in4 = r908;
|
|
next_in4 = r909;
|
|
bits4 = 0;
|
|
hold4 = 0;
|
|
} else {
|
|
bits4 = r126;
|
|
hold4 = r125;
|
|
avail_in4 = r123;
|
|
next_in4 = r121;
|
|
if (mode !== 11) {
|
|
r174 = r126;
|
|
r173 = r125;
|
|
r172 = r123;
|
|
r171 = r121;
|
|
if (mode === 12) {
|
|
break L205;
|
|
}
|
|
r168 = r126;
|
|
r170 = r125;
|
|
r167 = r123;
|
|
r165 = r121;
|
|
if (mode === 13) {
|
|
break L207;
|
|
}
|
|
L190: {
|
|
if (mode === 14) {
|
|
let r869 = r125 >>> (7 & r126);
|
|
let r871 = r126 - (7 & r126);
|
|
let r872 = r123;
|
|
let r873 = r121;
|
|
let r874 = r869;
|
|
let r875 = r872;
|
|
let r876 = r873;
|
|
let r877 = r871;
|
|
while (r877 < 32) {
|
|
const r878 = r871;
|
|
const r879 = r869;
|
|
const r880 = r872;
|
|
const r881 = r873;
|
|
r129 = r128;
|
|
r132 = r127;
|
|
bits3 = r878;
|
|
hold3 = r879;
|
|
next_in3 = r881;
|
|
avail_in3 = r880;
|
|
if (avail_in3 === 0) {
|
|
break L349;
|
|
}
|
|
r872 = r880 - 1;
|
|
const r882 = +r881;
|
|
r873 = r882 + 1;
|
|
r869 = r879 + (input[r882] << r878);
|
|
r871 = r878 + 8;
|
|
r874 = r869;
|
|
r875 = r872;
|
|
r876 = r873;
|
|
r877 = r871;
|
|
}
|
|
const length6 = 65535 & r874;
|
|
if (length6 !== (r874 >>> 16 ^ 65535)) {
|
|
a0.msg = "invalid stored block lengths";
|
|
state.mode = 30;
|
|
r86 = r128;
|
|
avail_out = r127;
|
|
bits = r877;
|
|
hold = r874;
|
|
r272 = avail_out3;
|
|
r273 = r875;
|
|
next_out = next_out3;
|
|
next_in = r876;
|
|
output = r120;
|
|
input = input;
|
|
continue;
|
|
}
|
|
state.length = length6;
|
|
state.mode = 15;
|
|
r184 = 0;
|
|
r183 = 0;
|
|
r180 = r875;
|
|
r179 = r876;
|
|
r129 = r128;
|
|
r132 = r127;
|
|
bits3 = 0;
|
|
hold3 = 0;
|
|
avail_in3 = r180;
|
|
next_in3 = r179;
|
|
if (a1 === 6) {
|
|
break L349;
|
|
}
|
|
} else {
|
|
r184 = r126;
|
|
r183 = r125;
|
|
r180 = r123;
|
|
r179 = r121;
|
|
if (mode !== 15) {
|
|
r182 = r126;
|
|
r181 = r125;
|
|
r178 = r123;
|
|
r177 = r121;
|
|
if (mode === 16) {
|
|
break L190;
|
|
}
|
|
L154: {
|
|
L147: {
|
|
L137: {
|
|
L131: {
|
|
L116: {
|
|
L115: {
|
|
L82: {
|
|
L73: {
|
|
if (mode === 17) {
|
|
let r339 = r126;
|
|
let r340 = r125;
|
|
let r341 = r123;
|
|
let r342 = r121;
|
|
let r343 = r339;
|
|
let r344 = r340;
|
|
let r345 = r341;
|
|
let r346 = r342;
|
|
while (r343 < 14) {
|
|
const r347 = r339;
|
|
const r348 = r340;
|
|
const r349 = r341;
|
|
const r350 = r342;
|
|
r129 = r128;
|
|
r132 = r127;
|
|
bits3 = r347;
|
|
hold3 = r348;
|
|
next_in3 = r350;
|
|
avail_in3 = r349;
|
|
if (avail_in3 === 0) {
|
|
break L349;
|
|
}
|
|
r341 = r349 - 1;
|
|
const r351 = +r350;
|
|
r342 = r351 + 1;
|
|
r340 = r348 + (input[r351] << r347);
|
|
r339 = r347 + 8;
|
|
r344 = r340;
|
|
r345 = r341;
|
|
r346 = r342;
|
|
r343 = r339;
|
|
}
|
|
state.nlen = 257 + (31 & r344);
|
|
const r356 = r344 >>> 5;
|
|
const r357 = r343 - 5;
|
|
state.ndist = 1 + (31 & r356);
|
|
const r360 = r356 >>> 5;
|
|
state.ncode = 4 + (15 & r360);
|
|
const r363 = r360 >>> 4;
|
|
const r365 = r357 - 5 - 4;
|
|
if (!(state.nlen > 286) && !(state.ndist > 30)) {
|
|
state.have = 0;
|
|
state.mode = 18;
|
|
r188 = r365;
|
|
r187 = r363;
|
|
r186 = r345;
|
|
r185 = r346;
|
|
break L73;
|
|
}
|
|
a0.msg = "too many length or distance symbols";
|
|
state.mode = 30;
|
|
r86 = r128;
|
|
avail_out = r127;
|
|
bits = r365;
|
|
hold = r363;
|
|
r272 = avail_out3;
|
|
r273 = r345;
|
|
next_out = next_out3;
|
|
next_in = r346;
|
|
output = r120;
|
|
input = input;
|
|
continue;
|
|
}
|
|
r188 = r126;
|
|
r187 = r125;
|
|
r186 = r123;
|
|
r185 = r121;
|
|
if (mode !== 18) {
|
|
r194 = r128;
|
|
r193 = r126;
|
|
r192 = r125;
|
|
r191 = r123;
|
|
r190 = r121;
|
|
if (mode === 19) {
|
|
break L82;
|
|
}
|
|
r207 = r128;
|
|
r204 = r126;
|
|
r203 = r125;
|
|
r202 = r123;
|
|
r201 = r121;
|
|
if (mode === 20) {
|
|
break L115;
|
|
}
|
|
r205 = r128;
|
|
bits5 = r126;
|
|
hold5 = r125;
|
|
avail_in5 = r123;
|
|
next_in5 = r121;
|
|
if (mode === 21) {
|
|
break L116;
|
|
}
|
|
r222 = r128;
|
|
r233 = r126;
|
|
r228 = r125;
|
|
r224 = r123;
|
|
r223 = r121;
|
|
if (mode === 22) {
|
|
break L131;
|
|
}
|
|
r206 = r128;
|
|
r219 = r126;
|
|
r220 = r125;
|
|
r210 = r123;
|
|
r209 = r121;
|
|
if (mode === 23) {
|
|
break L137;
|
|
}
|
|
r211 = r128;
|
|
r226 = r126;
|
|
r221 = r125;
|
|
r218 = r123;
|
|
r217 = r121;
|
|
if (mode === 24) {
|
|
break L147;
|
|
}
|
|
r216 = r128;
|
|
r215 = r126;
|
|
r214 = r125;
|
|
r213 = r123;
|
|
r212 = r121;
|
|
if (mode === 25) {
|
|
break L154;
|
|
}
|
|
if (mode === 26) {
|
|
r129 = r128;
|
|
r132 = r127;
|
|
bits3 = r126;
|
|
hold3 = r125;
|
|
avail_in3 = r123;
|
|
next_in3 = r121;
|
|
if (avail_out3 === 0) {
|
|
break L349;
|
|
}
|
|
const r337 = +next_out3;
|
|
next_out = r337 + 1;
|
|
r120[r337] = state.length;
|
|
r272 = avail_out3 - 1;
|
|
state.mode = 21;
|
|
r86 = r128;
|
|
avail_out = r127;
|
|
bits = r126;
|
|
hold = r125;
|
|
r273 = r123;
|
|
next_in = r121;
|
|
output = r120;
|
|
input = input;
|
|
continue;
|
|
}
|
|
L62: {
|
|
if (mode === 27) {
|
|
const wrap = state.wrap;
|
|
let r239 = r127;
|
|
let r238 = r126;
|
|
let r237 = r125;
|
|
let r236 = r123;
|
|
let r227 = r121;
|
|
if (wrap) {
|
|
let r243 = r126;
|
|
let r242 = r125;
|
|
let r241 = r123;
|
|
let r240 = r121;
|
|
let r195 = r243;
|
|
let r189 = r242;
|
|
let r176 = r241;
|
|
let r277 = r240;
|
|
while (r195 < 32) {
|
|
const r245 = r243;
|
|
const r249 = r242;
|
|
const r247 = r241;
|
|
const r246 = r240;
|
|
r129 = r128;
|
|
r132 = r127;
|
|
bits3 = r245;
|
|
hold3 = r249;
|
|
next_in3 = r246;
|
|
avail_in3 = r247;
|
|
if (avail_in3 === 0) {
|
|
break L349;
|
|
}
|
|
r241 = r247 - 1;
|
|
const r248 = +r246;
|
|
r240 = r248 + 1;
|
|
r242 = r249 | input[r248] << r245;
|
|
r243 = r245 + 8;
|
|
r189 = r242;
|
|
r176 = r241;
|
|
r277 = r240;
|
|
r195 = r243;
|
|
}
|
|
const r280 = r127 - avail_out3;
|
|
a0.total_out = a0.total_out + r280;
|
|
state.total = state.total + r280;
|
|
if (r280) {
|
|
const check2 = state.flags ? _Module12719(state.check, r120, r280, next_out3 - r280) : _adler32(state.check, r120, r280, next_out3 - r280);
|
|
state.check = check2;
|
|
a0.adler = check2;
|
|
}
|
|
const r304 = state.flags ? r189 : (r189 >>> 24 & 255) + (r189 >>> 8 & 65280) + ((65280 & r189) << 8) + ((255 & r189) << 24);
|
|
const check = state.check;
|
|
r239 = avail_out3;
|
|
r238 = 0;
|
|
r237 = 0;
|
|
r236 = r176;
|
|
r227 = r277;
|
|
if (r304 !== check) {
|
|
a0.msg = "incorrect data check";
|
|
state.mode = 30;
|
|
r86 = r128;
|
|
avail_out = avail_out3;
|
|
bits = r195;
|
|
hold = r189;
|
|
r272 = avail_out;
|
|
r273 = r176;
|
|
next_out = next_out3;
|
|
next_in = r277;
|
|
output = r120;
|
|
input = input;
|
|
continue;
|
|
}
|
|
}
|
|
state.mode = 28;
|
|
r229 = r239;
|
|
r244 = r238;
|
|
r225 = r237;
|
|
r208 = r236;
|
|
r196 = r227;
|
|
} else {
|
|
r229 = r127;
|
|
r244 = r126;
|
|
r225 = r125;
|
|
r208 = r123;
|
|
r196 = r121;
|
|
if (mode !== 28) {
|
|
r235 = r127;
|
|
r234 = r126;
|
|
r232 = r125;
|
|
r231 = r123;
|
|
r230 = r121;
|
|
if (mode === 29) {
|
|
break L62;
|
|
}
|
|
r129 = -3;
|
|
r132 = r127;
|
|
bits3 = r126;
|
|
hold3 = r125;
|
|
avail_in3 = r123;
|
|
next_in3 = r121;
|
|
if (mode === 30) {
|
|
break L349;
|
|
}
|
|
if (mode === 31) {
|
|
return -4;
|
|
}
|
|
return -2;
|
|
}
|
|
}
|
|
const wrap2 = state.wrap;
|
|
let r314 = r244;
|
|
let r315 = r225;
|
|
let r316 = r208;
|
|
let r317 = r196;
|
|
if (wrap2) {
|
|
const flags = state.flags;
|
|
r314 = r244;
|
|
r315 = r225;
|
|
r316 = r208;
|
|
r317 = r196;
|
|
if (flags) {
|
|
let r319 = r244;
|
|
let r320 = r225;
|
|
let r321 = r208;
|
|
let r322 = r196;
|
|
let r323 = r319;
|
|
let r324 = r320;
|
|
let r325 = r321;
|
|
let r326 = r322;
|
|
while (r323 < 32) {
|
|
const r327 = r319;
|
|
const r328 = r320;
|
|
const r329 = r321;
|
|
const r330 = r322;
|
|
r129 = r128;
|
|
r132 = r229;
|
|
bits3 = r327;
|
|
hold3 = r328;
|
|
next_in3 = r330;
|
|
avail_in3 = r329;
|
|
if (avail_in3 === 0) {
|
|
break L349;
|
|
}
|
|
r321 = r329 - 1;
|
|
const r331 = +r330;
|
|
r322 = r331 + 1;
|
|
r320 = r328 + (input[r331] << r327);
|
|
r319 = r327 + 8;
|
|
r324 = r320;
|
|
r325 = r321;
|
|
r326 = r322;
|
|
r323 = r319;
|
|
}
|
|
const r335 = 4294967295 & state.total;
|
|
r314 = 0;
|
|
r315 = 0;
|
|
r316 = r325;
|
|
r317 = r326;
|
|
if (r324 !== r335) {
|
|
a0.msg = "incorrect length check";
|
|
state.mode = 30;
|
|
r86 = r128;
|
|
avail_out = r229;
|
|
bits = r323;
|
|
hold = r324;
|
|
r272 = avail_out3;
|
|
r273 = r325;
|
|
next_out = next_out3;
|
|
next_in = r326;
|
|
output = r120;
|
|
input = input;
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
state.mode = 29;
|
|
r234 = r314;
|
|
r232 = r315;
|
|
r231 = r316;
|
|
r230 = r317;
|
|
r235 = r229;
|
|
}
|
|
r132 = r235;
|
|
bits3 = r234;
|
|
hold3 = r232;
|
|
avail_in3 = r231;
|
|
next_in3 = r230;
|
|
r129 = 1;
|
|
break L349;
|
|
}
|
|
}
|
|
const { have, ncode } = state;
|
|
let r370 = r188;
|
|
let r371 = r187;
|
|
let r372 = r186;
|
|
let r373 = r185;
|
|
let r374 = r370;
|
|
let r375 = r371;
|
|
let r376 = r372;
|
|
let r377 = r373;
|
|
if (have < ncode) {
|
|
do {
|
|
let r378 = r370;
|
|
let r379 = r371;
|
|
let r380 = r372;
|
|
let r381 = r373;
|
|
let r382 = r379;
|
|
let r383 = r380;
|
|
let r384 = r381;
|
|
let r385 = r378;
|
|
while (r385 < 3) {
|
|
const r386 = r378;
|
|
const r387 = r379;
|
|
const r388 = r380;
|
|
const r389 = r381;
|
|
r129 = r128;
|
|
r132 = r127;
|
|
bits3 = r386;
|
|
hold3 = r387;
|
|
next_in3 = r389;
|
|
avail_in3 = r388;
|
|
if (avail_in3 === 0) {
|
|
break L349;
|
|
}
|
|
r380 = r388 - 1;
|
|
const r390 = +r389;
|
|
r381 = r390 + 1;
|
|
r379 = r387 + (input[r390] << r386);
|
|
r378 = r386 + 8;
|
|
r382 = r379;
|
|
r383 = r380;
|
|
r384 = r381;
|
|
r385 = r378;
|
|
}
|
|
const lens = state.lens;
|
|
const r395 = +state.have;
|
|
state.have = r395 + 1;
|
|
lens[r114[r395]] = 7 & r382;
|
|
r371 = r382 >>> 3;
|
|
r370 = r385 - 3;
|
|
have2 = state.have;
|
|
ncode2 = state.ncode;
|
|
r372 = r383;
|
|
r373 = r384;
|
|
r374 = r370;
|
|
r375 = r371;
|
|
r376 = r372;
|
|
r377 = r373;
|
|
} while (have2 < ncode2);
|
|
}
|
|
while (state.have < 19) {
|
|
const lens2 = state.lens;
|
|
const r404 = +state.have;
|
|
state.have = r404 + 1;
|
|
lens2[r114[r404]] = 0;
|
|
}
|
|
state.lencode = state.lendyn;
|
|
state.lenbits = 7;
|
|
const r410 = {
|
|
bits: state.lenbits
|
|
};
|
|
const r423 = _inflate_table(0, state.lens, 0, 19, state.lencode, 0, state.work, r410);
|
|
state.lenbits = r410.bits;
|
|
if (r423) {
|
|
a0.msg = "invalid code lengths set";
|
|
state.mode = 30;
|
|
r86 = r423;
|
|
avail_out = r127;
|
|
bits = r374;
|
|
hold = r375;
|
|
r272 = avail_out3;
|
|
r273 = r376;
|
|
next_out = next_out3;
|
|
next_in = r377;
|
|
output = r120;
|
|
input = input;
|
|
continue;
|
|
}
|
|
state.have = 0;
|
|
state.mode = 19;
|
|
r194 = r423;
|
|
r193 = r374;
|
|
r192 = r375;
|
|
r191 = r376;
|
|
r190 = r377;
|
|
}
|
|
const have3 = state.have;
|
|
const r428 = state.nlen + state.ndist;
|
|
let r429 = r193;
|
|
let r430 = r192;
|
|
let r431 = r191;
|
|
let r432 = r190;
|
|
let r433 = r429;
|
|
let r434 = r430;
|
|
let r435 = r431;
|
|
let r436 = r432;
|
|
if (have3 < r428) {
|
|
do {
|
|
const r442 = state.lencode[r430 & (1 << state.lenbits) - 1];
|
|
r442 >>> 16;
|
|
let r66 = 65535 & r442;
|
|
let r65 = r442 >>> 24;
|
|
let r444 = r429;
|
|
let r445 = r430;
|
|
let r446 = r431;
|
|
let r447 = r432;
|
|
let r448 = r445;
|
|
let r449 = r446;
|
|
let r450 = r447;
|
|
let r451 = r444;
|
|
while (!(r65 <= r451)) {
|
|
const r452 = r444;
|
|
const r453 = r445;
|
|
const r454 = r446;
|
|
const r455 = r447;
|
|
r129 = r194;
|
|
r132 = r127;
|
|
bits3 = r452;
|
|
hold3 = r453;
|
|
next_in3 = r455;
|
|
avail_in3 = r454;
|
|
if (avail_in3 === 0) {
|
|
break L349;
|
|
}
|
|
r446 = r454 - 1;
|
|
const r456 = +r455;
|
|
r447 = r456 + 1;
|
|
const r459 = r453 + (input[r456] << r452);
|
|
r444 = r452 + 8;
|
|
const r465 = state.lencode[r459 & (1 << state.lenbits) - 1];
|
|
r465 >>> 16;
|
|
r66 = 65535 & r465;
|
|
r65 = r465 >>> 24;
|
|
r445 = r459;
|
|
r448 = r445;
|
|
r449 = r446;
|
|
r450 = r447;
|
|
r451 = r444;
|
|
}
|
|
if (r66 < 16) {
|
|
r533 = r448 >>> r65;
|
|
r532 = r451 - r65;
|
|
const lens4 = state.lens;
|
|
const r543 = +state.have;
|
|
state.have = r543 + 1;
|
|
lens4[r543] = r66;
|
|
r534 = r449;
|
|
r535 = r450;
|
|
} else {
|
|
if (r66 === 16) {
|
|
const r505 = r65 + 2;
|
|
let r506 = r451;
|
|
let r507 = r448;
|
|
let r508 = r449;
|
|
let r509 = r450;
|
|
let r510 = r507;
|
|
let r511 = r508;
|
|
let r512 = r509;
|
|
let r513 = r506;
|
|
while (r513 < r505) {
|
|
const r514 = r506;
|
|
const r515 = r507;
|
|
const r516 = r508;
|
|
const r517 = r509;
|
|
r129 = r194;
|
|
r132 = r127;
|
|
bits3 = r514;
|
|
hold3 = r515;
|
|
next_in3 = r517;
|
|
avail_in3 = r516;
|
|
if (avail_in3 === 0) {
|
|
break L349;
|
|
}
|
|
r508 = r516 - 1;
|
|
const r518 = +r517;
|
|
r509 = r518 + 1;
|
|
r507 = r515 + (input[r518] << r514);
|
|
r506 = r514 + 8;
|
|
r510 = r507;
|
|
r511 = r508;
|
|
r512 = r509;
|
|
r513 = r506;
|
|
}
|
|
const r521 = r510 >>> r65;
|
|
const r67 = r513 - r65;
|
|
if (state.have === 0) {
|
|
a0.msg = "invalid bit length repeat";
|
|
state.mode = 30;
|
|
r433 = r67;
|
|
r434 = r521;
|
|
r435 = r511;
|
|
r436 = r512;
|
|
break;
|
|
}
|
|
r485 = state.lens[state.have - 1];
|
|
r70 = 3 + (3 & r521);
|
|
r68 = r521 >>> 2;
|
|
r69 = r67 - 2;
|
|
r474 = r511;
|
|
r475 = r512;
|
|
} else if (r66 === 17) {
|
|
const r486 = r65 + 3;
|
|
let r487 = r451;
|
|
let r488 = r448;
|
|
let r489 = r449;
|
|
let r490 = r450;
|
|
let r491 = r487;
|
|
let r492 = r488;
|
|
let r493 = r489;
|
|
let r494 = r490;
|
|
while (r491 < r486) {
|
|
const r495 = r487;
|
|
const r496 = r488;
|
|
const r497 = r489;
|
|
const r498 = r490;
|
|
r129 = r194;
|
|
r132 = r127;
|
|
bits3 = r495;
|
|
hold3 = r496;
|
|
next_in3 = r498;
|
|
avail_in3 = r497;
|
|
if (avail_in3 === 0) {
|
|
break L349;
|
|
}
|
|
r489 = r497 - 1;
|
|
const r499 = +r498;
|
|
r490 = r499 + 1;
|
|
r488 = r496 + (input[r499] << r495);
|
|
r487 = r495 + 8;
|
|
r492 = r488;
|
|
r493 = r489;
|
|
r494 = r490;
|
|
r491 = r487;
|
|
}
|
|
const r502 = r491 - r65;
|
|
const r503 = r492 >>> r65;
|
|
r70 = 3 + (7 & r503);
|
|
r68 = r503 >>> 3;
|
|
r69 = r502 - 3;
|
|
r474 = r493;
|
|
r475 = r494;
|
|
r485 = 0;
|
|
} else {
|
|
const r467 = r65 + 7;
|
|
let r468 = r451;
|
|
let r469 = r448;
|
|
let r470 = r449;
|
|
let r471 = r450;
|
|
let r472 = r468;
|
|
let r473 = r469;
|
|
r474 = r470;
|
|
r475 = r471;
|
|
while (r472 < r467) {
|
|
const r476 = r468;
|
|
const r477 = r469;
|
|
const r478 = r470;
|
|
const r479 = r471;
|
|
r129 = r194;
|
|
r132 = r127;
|
|
bits3 = r476;
|
|
hold3 = r477;
|
|
next_in3 = r479;
|
|
avail_in3 = r478;
|
|
if (avail_in3 === 0) {
|
|
break L349;
|
|
}
|
|
r470 = r478 - 1;
|
|
const r480 = +r479;
|
|
r471 = r480 + 1;
|
|
r469 = r477 + (input[r480] << r476);
|
|
r468 = r476 + 8;
|
|
r473 = r469;
|
|
r474 = r470;
|
|
r475 = r471;
|
|
r472 = r468;
|
|
}
|
|
const r483 = r472 - r65;
|
|
const r484 = r473 >>> r65;
|
|
r70 = 11 + (127 & r484);
|
|
r68 = r484 >>> 7;
|
|
r69 = r483 - 7;
|
|
r485 = 0;
|
|
}
|
|
if (state.have + r70 > state.nlen + state.ndist) {
|
|
a0.msg = "invalid bit length repeat";
|
|
state.mode = 30;
|
|
r433 = r69;
|
|
r434 = r68;
|
|
r435 = r474;
|
|
r436 = r475;
|
|
break;
|
|
}
|
|
let r71 = r70 - 1;
|
|
r532 = r69;
|
|
r533 = r68;
|
|
r534 = r474;
|
|
r535 = r475;
|
|
if (r70) {
|
|
do {
|
|
const lens3 = state.lens;
|
|
const r538 = +state.have;
|
|
state.have = r538 + 1;
|
|
lens3[r538] = r485;
|
|
const r72 = r71 - 1;
|
|
r540 = r71;
|
|
r71 = r72;
|
|
r532 = r69;
|
|
r533 = r68;
|
|
r534 = r474;
|
|
r535 = r475;
|
|
} while (r540);
|
|
}
|
|
}
|
|
have4 = state.have;
|
|
r548 = state.nlen + state.ndist;
|
|
r429 = r532;
|
|
r430 = r533;
|
|
r431 = r534;
|
|
r432 = r535;
|
|
r433 = r429;
|
|
r434 = r430;
|
|
r435 = r431;
|
|
r436 = r432;
|
|
} while (have4 < r548);
|
|
}
|
|
const mode2 = state.mode;
|
|
r86 = r194;
|
|
avail_out = r127;
|
|
bits = r433;
|
|
hold = r434;
|
|
r272 = avail_out3;
|
|
r273 = r435;
|
|
next_out = next_out3;
|
|
next_in = r436;
|
|
output = r120;
|
|
input = input;
|
|
if (mode2 === 30) {
|
|
continue;
|
|
}
|
|
if (state.lens[256] === 0) {
|
|
a0.msg = "invalid code -- missing end-of-block";
|
|
state.mode = 30;
|
|
r86 = r194;
|
|
avail_out = r127;
|
|
bits = r433;
|
|
hold = r434;
|
|
r272 = avail_out3;
|
|
r273 = r435;
|
|
next_out = next_out3;
|
|
next_in = r436;
|
|
output = r120;
|
|
input = input;
|
|
continue;
|
|
}
|
|
state.lenbits = 9;
|
|
const r553 = {
|
|
bits: state.lenbits
|
|
};
|
|
const r569 = _inflate_table(1, state.lens, 0, state.nlen, state.lencode, 0, state.work, r553);
|
|
state.lenbits = r553.bits;
|
|
if (r569) {
|
|
a0.msg = "invalid literal/lengths set";
|
|
state.mode = 30;
|
|
r86 = r569;
|
|
avail_out = r127;
|
|
bits = r433;
|
|
hold = r434;
|
|
r272 = avail_out3;
|
|
r273 = r435;
|
|
next_out = next_out3;
|
|
next_in = r436;
|
|
output = r120;
|
|
input = input;
|
|
continue;
|
|
}
|
|
state.distbits = 6;
|
|
state.distcode = state.distdyn;
|
|
const r573 = {
|
|
bits: state.distbits
|
|
};
|
|
const r587 = _inflate_table(2, state.lens, state.nlen, state.ndist, state.distcode, 0, state.work, r573);
|
|
state.distbits = r573.bits;
|
|
if (r587) {
|
|
a0.msg = "invalid distances set";
|
|
state.mode = 30;
|
|
r86 = r587;
|
|
avail_out = r127;
|
|
bits = r433;
|
|
hold = r434;
|
|
r272 = avail_out3;
|
|
r273 = r435;
|
|
next_out = next_out3;
|
|
next_in = r436;
|
|
output = r120;
|
|
input = input;
|
|
continue;
|
|
}
|
|
state.mode = 20;
|
|
r207 = r587;
|
|
r204 = r433;
|
|
r203 = r434;
|
|
r202 = r435;
|
|
r201 = r436;
|
|
r129 = r207;
|
|
r132 = r127;
|
|
bits3 = r204;
|
|
hold3 = r203;
|
|
avail_in3 = r202;
|
|
next_in3 = r201;
|
|
if (a1 === 6) {
|
|
break L349;
|
|
}
|
|
}
|
|
state.mode = 21;
|
|
r205 = r207;
|
|
bits5 = r204;
|
|
hold5 = r203;
|
|
avail_in5 = r202;
|
|
next_in5 = r201;
|
|
}
|
|
if (avail_in5 >= 6 && avail_out3 >= 258) {
|
|
a0.next_out = next_out3;
|
|
a0.avail_out = avail_out3;
|
|
a0.next_in = next_in5;
|
|
a0.avail_in = avail_in5;
|
|
state.hold = hold5;
|
|
state.bits = bits5;
|
|
_inflate_fast(a0, r127);
|
|
const { next_out: next_out2, output: output2, avail_out: avail_out2, next_in: next_in2, input: input2, avail_in: avail_in2 } = a0;
|
|
const { hold: hold2, bits: bits2, mode: mode3 } = state;
|
|
r86 = r205;
|
|
avail_out = r127;
|
|
bits = bits2;
|
|
hold = hold2;
|
|
r272 = avail_out2;
|
|
r273 = avail_in2;
|
|
next_out = next_out2;
|
|
next_in = next_in2;
|
|
output = output2;
|
|
input = input2;
|
|
if (mode3 !== 12) {
|
|
continue;
|
|
}
|
|
state.back = -1;
|
|
r86 = r205;
|
|
avail_out = r127;
|
|
bits = bits2;
|
|
hold = hold2;
|
|
r272 = avail_out2;
|
|
r273 = avail_in2;
|
|
next_out = next_out2;
|
|
next_in = next_in2;
|
|
output = output2;
|
|
input = input2;
|
|
continue;
|
|
}
|
|
state.back = 0;
|
|
const r594 = state.lencode[hold5 & (1 << state.lenbits) - 1];
|
|
let r596 = r594 >>> 16 & 255;
|
|
let r597 = 65535 & r594;
|
|
let r598 = r594 >>> 24;
|
|
let r599 = bits5;
|
|
let r600 = hold5;
|
|
let r601 = avail_in5;
|
|
let r602 = next_in5;
|
|
let r603 = r600;
|
|
let r604 = r601;
|
|
let r605 = r602;
|
|
let r606 = r599;
|
|
while (!(r598 <= r606)) {
|
|
const r607 = r599;
|
|
const r608 = r600;
|
|
const r609 = r601;
|
|
const r610 = r602;
|
|
r129 = r205;
|
|
r132 = r127;
|
|
bits3 = r607;
|
|
hold3 = r608;
|
|
next_in3 = r610;
|
|
avail_in3 = r609;
|
|
if (avail_in3 === 0) {
|
|
break L349;
|
|
}
|
|
r601 = r609 - 1;
|
|
const r611 = +r610;
|
|
r602 = r611 + 1;
|
|
const r614 = r608 + (input[r611] << r607);
|
|
r599 = r607 + 8;
|
|
const r620 = state.lencode[r614 & (1 << state.lenbits) - 1];
|
|
r596 = r620 >>> 16 & 255;
|
|
r597 = 65535 & r620;
|
|
r598 = r620 >>> 24;
|
|
r600 = r614;
|
|
r603 = r600;
|
|
r604 = r601;
|
|
r605 = r602;
|
|
r606 = r599;
|
|
}
|
|
let length5 = r597;
|
|
let r623 = r596;
|
|
let r624 = r598;
|
|
let r625 = r606;
|
|
let r626 = r603;
|
|
let r627 = r604;
|
|
let r628 = r605;
|
|
if (r596) {
|
|
const r629 = 240 & r596;
|
|
length5 = r597;
|
|
r623 = r596;
|
|
r624 = r598;
|
|
r625 = r606;
|
|
r626 = r603;
|
|
r627 = r604;
|
|
r628 = r605;
|
|
if (!r629) {
|
|
const lencode2 = state.lencode;
|
|
const r633 = (1 << r598 + r596) - 1;
|
|
const r637 = lencode2[r597 + ((r603 & r633) >> r598)];
|
|
let r639 = r637 >>> 16 & 255;
|
|
let r640 = 65535 & r637;
|
|
let r641 = r637 >>> 24;
|
|
const r642 = r598 + r641;
|
|
let r643 = r606;
|
|
let r644 = r603;
|
|
let r645 = r604;
|
|
let r646 = r605;
|
|
let r647 = r643;
|
|
let r648 = r644;
|
|
let r649 = r645;
|
|
let r650 = r646;
|
|
if (!(r642 <= r606)) {
|
|
do {
|
|
const r651 = r643;
|
|
const r652 = r644;
|
|
const r653 = r645;
|
|
const r654 = r646;
|
|
r129 = r205;
|
|
r132 = r127;
|
|
bits3 = r651;
|
|
hold3 = r652;
|
|
next_in3 = r654;
|
|
avail_in3 = r653;
|
|
if (avail_in3 === 0) {
|
|
break L349;
|
|
}
|
|
r645 = r653 - 1;
|
|
const r655 = +r654;
|
|
r646 = r655 + 1;
|
|
const r658 = r652 + (input[r655] << r651);
|
|
r643 = r651 + 8;
|
|
const r663 = state.lencode[r597 + ((r658 & r633) >> r598)];
|
|
r639 = r663 >>> 16 & 255;
|
|
r640 = 65535 & r663;
|
|
const r665 = r663 >>> 24;
|
|
r666 = r598 + r665;
|
|
r644 = r658;
|
|
r641 = r665;
|
|
r648 = r644;
|
|
r649 = r645;
|
|
r650 = r646;
|
|
r647 = r643;
|
|
} while (!(r666 <= r647));
|
|
}
|
|
r626 = r648 >>> r598;
|
|
r625 = r647 - r598;
|
|
state.back = state.back + r598;
|
|
length5 = r640;
|
|
r623 = r639;
|
|
r624 = r641;
|
|
r627 = r649;
|
|
r628 = r650;
|
|
}
|
|
}
|
|
const r669 = r626 >>> r624;
|
|
const r670 = r625 - r624;
|
|
state.back = state.back + r624;
|
|
state.length = length5;
|
|
if (r623 === 0) {
|
|
state.mode = 26;
|
|
r86 = r205;
|
|
avail_out = r127;
|
|
bits = r670;
|
|
hold = r669;
|
|
r272 = avail_out3;
|
|
r273 = r627;
|
|
next_out = next_out3;
|
|
next_in = r628;
|
|
output = r120;
|
|
input = input;
|
|
continue;
|
|
}
|
|
if (32 & r623) {
|
|
state.back = -1;
|
|
state.mode = 12;
|
|
r86 = r205;
|
|
avail_out = r127;
|
|
bits = r670;
|
|
hold = r669;
|
|
r272 = avail_out3;
|
|
r273 = r627;
|
|
next_out = next_out3;
|
|
next_in = r628;
|
|
output = r120;
|
|
input = input;
|
|
continue;
|
|
}
|
|
if (64 & r623) {
|
|
a0.msg = "invalid literal/length code";
|
|
state.mode = 30;
|
|
r86 = r205;
|
|
avail_out = r127;
|
|
bits = r670;
|
|
hold = r669;
|
|
r272 = avail_out3;
|
|
r273 = r627;
|
|
next_out = next_out3;
|
|
next_in = r628;
|
|
output = r120;
|
|
input = input;
|
|
continue;
|
|
}
|
|
state.extra = 15 & r623;
|
|
state.mode = 22;
|
|
r222 = r205;
|
|
r233 = r670;
|
|
r228 = r669;
|
|
r224 = r627;
|
|
r223 = r628;
|
|
}
|
|
const extra = state.extra;
|
|
let r677 = r233;
|
|
let r678 = r228;
|
|
let r679 = r224;
|
|
let r680 = r223;
|
|
if (extra) {
|
|
const extra2 = state.extra;
|
|
let r682 = r233;
|
|
let r683 = r228;
|
|
let r684 = r224;
|
|
let r685 = r223;
|
|
let r686 = r682;
|
|
let r687 = r683;
|
|
let r688 = r684;
|
|
let r689 = r685;
|
|
while (r686 < extra2) {
|
|
const r690 = r682;
|
|
const r691 = r683;
|
|
const r692 = r684;
|
|
const r693 = r685;
|
|
r129 = r222;
|
|
r132 = r127;
|
|
bits3 = r690;
|
|
hold3 = r691;
|
|
next_in3 = r693;
|
|
avail_in3 = r692;
|
|
if (avail_in3 === 0) {
|
|
break L349;
|
|
}
|
|
r684 = r692 - 1;
|
|
const r694 = +r693;
|
|
r685 = r694 + 1;
|
|
r683 = r691 + (input[r694] << r690);
|
|
r682 = r690 + 8;
|
|
r687 = r683;
|
|
r688 = r684;
|
|
r689 = r685;
|
|
r686 = r682;
|
|
}
|
|
state.length = state.length + (r687 & (1 << state.extra) - 1);
|
|
r678 = r687 >>> state.extra;
|
|
r677 = r686 - state.extra;
|
|
state.back = state.back + state.extra;
|
|
r679 = r688;
|
|
r680 = r689;
|
|
}
|
|
state.was = state.length;
|
|
state.mode = 23;
|
|
r219 = r677;
|
|
r220 = r678;
|
|
r210 = r679;
|
|
r209 = r680;
|
|
r206 = r222;
|
|
}
|
|
const r714 = state.distcode[r220 & (1 << state.distbits) - 1];
|
|
let r716 = r714 >>> 16 & 255;
|
|
let r73 = 65535 & r714;
|
|
let r717 = r714 >>> 24;
|
|
let r718 = r219;
|
|
let r719 = r220;
|
|
let r720 = r210;
|
|
let r721 = r209;
|
|
let r722 = r719;
|
|
let r723 = r720;
|
|
let r724 = r721;
|
|
let r725 = r718;
|
|
while (!(r717 <= r725)) {
|
|
const r726 = r718;
|
|
const r727 = r719;
|
|
const r728 = r720;
|
|
const r729 = r721;
|
|
r129 = r206;
|
|
r132 = r127;
|
|
bits3 = r726;
|
|
hold3 = r727;
|
|
next_in3 = r729;
|
|
avail_in3 = r728;
|
|
if (avail_in3 === 0) {
|
|
break L349;
|
|
}
|
|
r720 = r728 - 1;
|
|
const r730 = +r729;
|
|
r721 = r730 + 1;
|
|
const r733 = r727 + (input[r730] << r726);
|
|
r718 = r726 + 8;
|
|
const r739 = state.distcode[r733 & (1 << state.distbits) - 1];
|
|
r716 = r739 >>> 16 & 255;
|
|
r73 = 65535 & r739;
|
|
r717 = r739 >>> 24;
|
|
r719 = r733;
|
|
r722 = r719;
|
|
r723 = r720;
|
|
r724 = r721;
|
|
r725 = r718;
|
|
}
|
|
const r741 = 240 & r716;
|
|
let offset = r73;
|
|
let r743 = r716;
|
|
let r744 = r717;
|
|
let r745 = r725;
|
|
let r746 = r722;
|
|
let r747 = r723;
|
|
let r748 = r724;
|
|
if (!r741) {
|
|
const distcode2 = state.distcode;
|
|
const r752 = (1 << r717 + r716) - 1;
|
|
const r756 = distcode2[r73 + ((r722 & r752) >> r717)];
|
|
let r758 = r756 >>> 16 & 255;
|
|
let r759 = 65535 & r756;
|
|
let r760 = r756 >>> 24;
|
|
const r761 = r717 + r760;
|
|
let r762 = r725;
|
|
let r763 = r722;
|
|
let r764 = r723;
|
|
let r765 = r724;
|
|
let r766 = r762;
|
|
let r767 = r763;
|
|
let r768 = r764;
|
|
let r769 = r765;
|
|
if (!(r761 <= r725)) {
|
|
do {
|
|
const r770 = r762;
|
|
const r771 = r763;
|
|
const r772 = r764;
|
|
const r773 = r765;
|
|
r129 = r206;
|
|
r132 = r127;
|
|
bits3 = r770;
|
|
hold3 = r771;
|
|
next_in3 = r773;
|
|
avail_in3 = r772;
|
|
if (avail_in3 === 0) {
|
|
break L349;
|
|
}
|
|
r764 = r772 - 1;
|
|
const r774 = +r773;
|
|
r765 = r774 + 1;
|
|
const r777 = r771 + (input[r774] << r770);
|
|
r762 = r770 + 8;
|
|
const r782 = state.distcode[r73 + ((r777 & r752) >> r717)];
|
|
r758 = r782 >>> 16 & 255;
|
|
r759 = 65535 & r782;
|
|
const r74 = r782 >>> 24;
|
|
r784 = r717 + r74;
|
|
r763 = r777;
|
|
r760 = r74;
|
|
r767 = r763;
|
|
r768 = r764;
|
|
r769 = r765;
|
|
r766 = r762;
|
|
} while (!(r784 <= r766));
|
|
}
|
|
r746 = r767 >>> r717;
|
|
r745 = r766 - r717;
|
|
state.back = state.back + r717;
|
|
offset = r759;
|
|
r743 = r758;
|
|
r744 = r760;
|
|
r747 = r768;
|
|
r748 = r769;
|
|
}
|
|
const r787 = r746 >>> r744;
|
|
const r788 = r745 - r744;
|
|
state.back = state.back + r744;
|
|
if (64 & r743) {
|
|
a0.msg = "invalid distance code";
|
|
state.mode = 30;
|
|
r86 = r206;
|
|
avail_out = r127;
|
|
bits = r788;
|
|
hold = r787;
|
|
r272 = avail_out3;
|
|
r273 = r747;
|
|
next_out = next_out3;
|
|
next_in = r748;
|
|
output = r120;
|
|
input = input;
|
|
continue;
|
|
}
|
|
state.offset = offset;
|
|
state.extra = 15 & r743;
|
|
state.mode = 24;
|
|
r211 = r206;
|
|
r226 = r788;
|
|
r221 = r787;
|
|
r218 = r747;
|
|
r217 = r748;
|
|
}
|
|
const extra3 = state.extra;
|
|
let r794 = r226;
|
|
let r795 = r221;
|
|
let r796 = r218;
|
|
let r797 = r217;
|
|
if (extra3) {
|
|
const extra4 = state.extra;
|
|
let r799 = r226;
|
|
let r800 = r221;
|
|
let r801 = r218;
|
|
let r802 = r217;
|
|
let r803 = r799;
|
|
let r804 = r800;
|
|
let r805 = r801;
|
|
let r806 = r802;
|
|
while (r803 < extra4) {
|
|
const r807 = r799;
|
|
const r808 = r800;
|
|
const r809 = r801;
|
|
const r810 = r802;
|
|
r129 = r211;
|
|
r132 = r127;
|
|
bits3 = r807;
|
|
hold3 = r808;
|
|
next_in3 = r810;
|
|
avail_in3 = r809;
|
|
if (avail_in3 === 0) {
|
|
break L349;
|
|
}
|
|
r801 = r809 - 1;
|
|
const r811 = +r810;
|
|
r802 = r811 + 1;
|
|
r800 = r808 + (input[r811] << r807);
|
|
r799 = r807 + 8;
|
|
r804 = r800;
|
|
r805 = r801;
|
|
r806 = r802;
|
|
r803 = r799;
|
|
}
|
|
state.offset = state.offset + (r804 & (1 << state.extra) - 1);
|
|
r795 = r804 >>> state.extra;
|
|
r794 = r803 - state.extra;
|
|
state.back = state.back + state.extra;
|
|
r796 = r805;
|
|
r797 = r806;
|
|
}
|
|
if (state.offset > state.dmax) {
|
|
a0.msg = "invalid distance too far back";
|
|
state.mode = 30;
|
|
r86 = r211;
|
|
avail_out = r127;
|
|
bits = r794;
|
|
hold = r795;
|
|
r272 = avail_out3;
|
|
r273 = r796;
|
|
next_out = next_out3;
|
|
next_in = r797;
|
|
output = r120;
|
|
input = input;
|
|
continue;
|
|
}
|
|
state.mode = 25;
|
|
r216 = r211;
|
|
r215 = r794;
|
|
r214 = r795;
|
|
r213 = r796;
|
|
r212 = r797;
|
|
}
|
|
r129 = r216;
|
|
r132 = r127;
|
|
bits3 = r215;
|
|
hold3 = r214;
|
|
avail_in3 = r213;
|
|
next_in3 = r212;
|
|
if (avail_out3 === 0) {
|
|
break L349;
|
|
}
|
|
const r827 = r127 - avail_out3;
|
|
if (state.offset > r827) {
|
|
const r834 = state.offset - r827;
|
|
if (r834 > state.whave && state.sane) {
|
|
a0.msg = "invalid distance too far back";
|
|
state.mode = 30;
|
|
r86 = r216;
|
|
avail_out = r127;
|
|
bits = r215;
|
|
hold = r214;
|
|
r272 = avail_out3;
|
|
r273 = r213;
|
|
next_out = next_out3;
|
|
next_in = r212;
|
|
output = r120;
|
|
input = input;
|
|
continue;
|
|
}
|
|
if (r834 > state.wnext) {
|
|
const r842 = r834 - state.wnext;
|
|
r839 = state.wsize - r842;
|
|
r840 = r842;
|
|
} else {
|
|
r839 = state.wnext - r834;
|
|
r840 = r834;
|
|
}
|
|
if (r840 > state.length) {
|
|
r840 = state.length;
|
|
}
|
|
window2 = state.window;
|
|
r831 = r840;
|
|
r830 = r839;
|
|
} else {
|
|
r830 = next_out3 - state.offset;
|
|
r831 = state.length;
|
|
window2 = r120;
|
|
}
|
|
if (r831 > avail_out3) {
|
|
r831 = avail_out3;
|
|
}
|
|
const r845 = avail_out3 - r831;
|
|
state.length = state.length - r831;
|
|
let r848 = next_out3;
|
|
while (true) {
|
|
const r849 = +r848;
|
|
const r850 = r849 + 1;
|
|
const r851 = +r830;
|
|
r830 = r851 + 1;
|
|
r120[r849] = window2[r851];
|
|
r831 = r831 - 1;
|
|
r848 = r850;
|
|
if (!r831) {
|
|
const length = state.length;
|
|
r86 = r216;
|
|
avail_out = r127;
|
|
bits = r215;
|
|
hold = r214;
|
|
r272 = r845;
|
|
r273 = r213;
|
|
next_out = r850;
|
|
next_in = r212;
|
|
output = r120;
|
|
input = input;
|
|
if (length !== 0) {
|
|
continue loop9;
|
|
}
|
|
state.mode = 21;
|
|
r86 = r216;
|
|
avail_out = r127;
|
|
bits = r215;
|
|
hold = r214;
|
|
r272 = r845;
|
|
r273 = r213;
|
|
next_out = r850;
|
|
next_in = r212;
|
|
output = r120;
|
|
input = input;
|
|
continue loop9;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
state.mode = 16;
|
|
r182 = r184;
|
|
r181 = r183;
|
|
r178 = r180;
|
|
r177 = r179;
|
|
}
|
|
let length2 = state.length;
|
|
if (length2) {
|
|
if (length2 > r178) {
|
|
length2 = r178;
|
|
}
|
|
if (length2 > avail_out3) {
|
|
length2 = avail_out3;
|
|
}
|
|
r129 = r128;
|
|
r132 = r127;
|
|
bits3 = r182;
|
|
hold3 = r181;
|
|
avail_in3 = r178;
|
|
next_in3 = r177;
|
|
if (length2 === 0) {
|
|
break L349;
|
|
}
|
|
arraySet(r120, input, r177, length2, next_out3);
|
|
r273 = r178 - length2;
|
|
next_in = r177 + length2;
|
|
r272 = avail_out3 - length2;
|
|
next_out = next_out3 + length2;
|
|
state.length = state.length - length2;
|
|
r86 = r128;
|
|
avail_out = r127;
|
|
bits = r182;
|
|
hold = r181;
|
|
output = r120;
|
|
input = input;
|
|
continue;
|
|
}
|
|
state.mode = 12;
|
|
r86 = r128;
|
|
avail_out = r127;
|
|
bits = r182;
|
|
hold = r181;
|
|
r272 = avail_out3;
|
|
r273 = r178;
|
|
next_out = next_out3;
|
|
next_in = r177;
|
|
output = r120;
|
|
input = input;
|
|
continue;
|
|
}
|
|
}
|
|
if (state.havedict === 0) {
|
|
a0.next_out = next_out3;
|
|
a0.avail_out = avail_out3;
|
|
a0.next_in = next_in4;
|
|
a0.avail_in = avail_in4;
|
|
state.hold = hold4;
|
|
state.bits = bits4;
|
|
return 2;
|
|
}
|
|
state.check = 1;
|
|
a0.adler = 1;
|
|
state.mode = 12;
|
|
r174 = bits4;
|
|
r173 = hold4;
|
|
r172 = avail_in4;
|
|
r171 = next_in4;
|
|
}
|
|
r129 = r128;
|
|
r132 = r127;
|
|
bits3 = r174;
|
|
hold3 = r173;
|
|
avail_in3 = r172;
|
|
next_in3 = r171;
|
|
if (a1 === 5) {
|
|
break L349;
|
|
}
|
|
r168 = r174;
|
|
r170 = r173;
|
|
r167 = r172;
|
|
r165 = r171;
|
|
r129 = r128;
|
|
r132 = r127;
|
|
bits3 = r168;
|
|
hold3 = r170;
|
|
avail_in3 = r167;
|
|
next_in3 = r165;
|
|
if (a1 === 6) {
|
|
break L349;
|
|
}
|
|
}
|
|
if (state.last) {
|
|
hold = r170 >>> (7 & r168);
|
|
bits = r168 - (7 & r168);
|
|
state.mode = 27;
|
|
r86 = r128;
|
|
avail_out = r127;
|
|
r272 = avail_out3;
|
|
r273 = r167;
|
|
next_out = next_out3;
|
|
next_in = r165;
|
|
output = r120;
|
|
input = input;
|
|
continue;
|
|
}
|
|
let r930 = r168;
|
|
let r931 = r170;
|
|
let r932 = r167;
|
|
let r933 = r165;
|
|
let r934 = r931;
|
|
let r935 = r932;
|
|
let r936 = r933;
|
|
let r937 = r930;
|
|
while (r937 < 3) {
|
|
const r938 = r930;
|
|
const r939 = r931;
|
|
const r940 = r932;
|
|
const r941 = r933;
|
|
r129 = r128;
|
|
r132 = r127;
|
|
bits3 = r938;
|
|
hold3 = r939;
|
|
next_in3 = r941;
|
|
avail_in3 = r940;
|
|
if (avail_in3 === 0) {
|
|
break L349;
|
|
}
|
|
r932 = r940 - 1;
|
|
const r942 = +r941;
|
|
r933 = r942 + 1;
|
|
r931 = r939 + (input[r942] << r938);
|
|
r930 = r938 + 8;
|
|
r934 = r931;
|
|
r935 = r932;
|
|
r936 = r933;
|
|
r937 = r930;
|
|
}
|
|
state.last = 1 & r934;
|
|
const r946 = r937 - 1;
|
|
const r947 = r934 >>> 1;
|
|
const r948 = 3 & r947;
|
|
if (r948 === 0) {
|
|
state.mode = 14;
|
|
} else if (r948 === 1) {
|
|
L229: {
|
|
if (c8766_7) {
|
|
lencode = new Buf32(512);
|
|
distcode = new Buf32(32);
|
|
let r967 = 0;
|
|
while (true) {
|
|
const lens5 = state.lens;
|
|
const r969 = r967 + 1;
|
|
lens5[r967] = 8;
|
|
r967 = r969;
|
|
if (!(r969 < 144)) {
|
|
let r970 = r969;
|
|
let r971 = r970;
|
|
while (r971 < 256) {
|
|
const lens6 = state.lens;
|
|
const r973 = r970 + 1;
|
|
lens6[r970] = 9;
|
|
r970 = r973;
|
|
r971 = r970;
|
|
}
|
|
let r974 = r971;
|
|
let r975 = r974;
|
|
while (r975 < 280) {
|
|
const lens7 = state.lens;
|
|
const r977 = r974 + 1;
|
|
lens7[r974] = 7;
|
|
r974 = r977;
|
|
r975 = r974;
|
|
}
|
|
while (r975 < 288) {
|
|
const lens8 = state.lens;
|
|
const r979 = r975 + 1;
|
|
lens8[r975] = 8;
|
|
r975 = r979;
|
|
}
|
|
_inflate_table(1, state.lens, 0, 288, lencode, 0, state.work, {
|
|
bits: 9
|
|
});
|
|
let r996 = 0;
|
|
while (true) {
|
|
const lens9 = state.lens;
|
|
const r998 = r996 + 1;
|
|
lens9[r996] = 5;
|
|
r996 = r998;
|
|
if (!(r996 < 32)) {
|
|
_inflate_table(2, state.lens, 0, 32, distcode, 0, state.work, {
|
|
bits: 5
|
|
});
|
|
c8766_7 = false;
|
|
break L229;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
state.lencode = lencode;
|
|
state.lenbits = 9;
|
|
state.distcode = distcode;
|
|
state.distbits = 5;
|
|
state.mode = 20;
|
|
if (a1 === 6) {
|
|
hold3 = r947 >>> 2;
|
|
bits3 = r946 - 2;
|
|
r129 = r128;
|
|
r132 = r127;
|
|
avail_in3 = r935;
|
|
next_in3 = r936;
|
|
break L349;
|
|
}
|
|
} else if (r948 === 2) {
|
|
state.mode = 17;
|
|
} else if (r948 === 3) {
|
|
a0.msg = "invalid block type";
|
|
state.mode = 30;
|
|
}
|
|
hold = r947 >>> 2;
|
|
bits = r946 - 2;
|
|
r86 = r128;
|
|
avail_out = r127;
|
|
r272 = avail_out3;
|
|
r273 = r935;
|
|
next_out = next_out3;
|
|
next_in = r936;
|
|
output = r120;
|
|
input = input;
|
|
continue;
|
|
}
|
|
}
|
|
let r1059 = r163;
|
|
let r1060 = r162;
|
|
let r1061 = r157;
|
|
let time = r1059;
|
|
let r1063 = r1060;
|
|
let r1064 = r1061;
|
|
while (r169 < 32) {
|
|
const r1065 = r169;
|
|
const r1066 = r1059;
|
|
const r1067 = r1060;
|
|
const r1068 = r1061;
|
|
r129 = r128;
|
|
r132 = r127;
|
|
bits3 = r1065;
|
|
hold3 = r1066;
|
|
next_in3 = r1068;
|
|
avail_in3 = r1067;
|
|
if (avail_in3 === 0) {
|
|
break L349;
|
|
}
|
|
r1060 = r1067 - 1;
|
|
const r1069 = +r1068;
|
|
r1061 = r1069 + 1;
|
|
r1059 = r1066 + (input[r1069] << r1065);
|
|
r169 = r1065 + 8;
|
|
time = r1059;
|
|
r1063 = r1060;
|
|
r1064 = r1061;
|
|
}
|
|
if (state.head) {
|
|
state.head.time = time;
|
|
}
|
|
if (512 & state.flags) {
|
|
buf8[0] = 255 & time;
|
|
buf8[1] = time >>> 8 & 255;
|
|
buf8[2] = time >>> 16 & 255;
|
|
buf8[3] = time >>> 24 & 255;
|
|
state.check = _Module12719(state.check, buf8, 4, 0);
|
|
}
|
|
state.mode = 4;
|
|
r164 = 0;
|
|
r156 = 0;
|
|
r143 = r1063;
|
|
r142 = r1064;
|
|
}
|
|
let r1095 = r156;
|
|
let r1096 = r143;
|
|
let r1097 = r142;
|
|
let r1098 = r1095;
|
|
let r1099 = r1096;
|
|
let r1100 = r1097;
|
|
while (r164 < 16) {
|
|
const r1101 = r164;
|
|
const r1102 = r1095;
|
|
const r1103 = r1096;
|
|
const r1104 = r1097;
|
|
r129 = r128;
|
|
r132 = r127;
|
|
bits3 = r1101;
|
|
hold3 = r1102;
|
|
next_in3 = r1104;
|
|
avail_in3 = r1103;
|
|
if (avail_in3 === 0) {
|
|
break L349;
|
|
}
|
|
r1096 = r1103 - 1;
|
|
const r1105 = +r1104;
|
|
r1097 = r1105 + 1;
|
|
r1095 = r1102 + (input[r1105] << r1101);
|
|
r164 = r1101 + 8;
|
|
r1098 = r1095;
|
|
r1099 = r1096;
|
|
r1100 = r1097;
|
|
}
|
|
if (state.head) {
|
|
state.head.xflags = 255 & r1098;
|
|
state.head.os = r1098 >> 8;
|
|
}
|
|
if (512 & state.flags) {
|
|
buf8[0] = 255 & r1098;
|
|
buf8[1] = r1098 >>> 8 & 255;
|
|
state.check = _Module12719(state.check, buf8, 2, 0);
|
|
}
|
|
state.mode = 5;
|
|
r166 = 0;
|
|
r161 = 0;
|
|
r160 = r1099;
|
|
r159 = r1100;
|
|
}
|
|
if (1024 & state.flags) {
|
|
let r1138 = r166;
|
|
let r1139 = r161;
|
|
let r1140 = r160;
|
|
let r1141 = r159;
|
|
let length7 = r1139;
|
|
let r1143 = r1140;
|
|
let r1144 = r1141;
|
|
while (r1138 < 16) {
|
|
const r1145 = r1138;
|
|
const r1146 = r1139;
|
|
const r1147 = r1140;
|
|
const r1148 = r1141;
|
|
r129 = r128;
|
|
r132 = r127;
|
|
bits3 = r1145;
|
|
hold3 = r1146;
|
|
next_in3 = r1148;
|
|
avail_in3 = r1147;
|
|
if (avail_in3 === 0) {
|
|
break L349;
|
|
}
|
|
r1140 = r1147 - 1;
|
|
const r1149 = +r1148;
|
|
r1141 = r1149 + 1;
|
|
r1139 = r1146 + (input[r1149] << r1145);
|
|
r1138 = r1145 + 8;
|
|
length7 = r1139;
|
|
r1143 = r1140;
|
|
r1144 = r1141;
|
|
}
|
|
state.length = length7;
|
|
if (state.head) {
|
|
state.head.extra_len = length7;
|
|
}
|
|
const r1155 = 512 & state.flags;
|
|
r1133 = 0;
|
|
r1134 = 0;
|
|
r1135 = r1143;
|
|
r1136 = r1144;
|
|
if (r1155) {
|
|
buf8[0] = 255 & length7;
|
|
buf8[1] = length7 >>> 8 & 255;
|
|
state.check = _Module12719(state.check, buf8, 2, 0);
|
|
r1133 = 0;
|
|
r1134 = 0;
|
|
r1135 = r1143;
|
|
r1136 = r1144;
|
|
}
|
|
} else {
|
|
const head = state.head;
|
|
r1133 = r166;
|
|
r1134 = r161;
|
|
r1135 = r160;
|
|
r1136 = r159;
|
|
if (head) {
|
|
state.head.extra = null;
|
|
r1133 = r166;
|
|
r1134 = r161;
|
|
r1135 = r160;
|
|
r1136 = r159;
|
|
}
|
|
}
|
|
state.mode = 6;
|
|
r154 = r1133;
|
|
r150 = r1134;
|
|
r158 = r1135;
|
|
r155 = r1136;
|
|
}
|
|
const r1172 = 1024 & state.flags;
|
|
let r1173 = r158;
|
|
let r1174 = r155;
|
|
if (r1172) {
|
|
let length3 = state.length;
|
|
if (length3 > r158) {
|
|
length3 = r158;
|
|
}
|
|
let r1176 = r158;
|
|
let r1177 = r155;
|
|
if (length3) {
|
|
if (state.head) {
|
|
const r1182 = state.head.extra_len - state.length;
|
|
if (!state.head.extra) {
|
|
state.head.extra = new Array(state.head.extra_len);
|
|
}
|
|
arraySet(state.head.extra, input, r155, length3, r1182);
|
|
}
|
|
if (512 & state.flags) {
|
|
state.check = _Module12719(state.check, input, length3, r155);
|
|
}
|
|
r1176 = r158 - length3;
|
|
r1177 = r155 + length3;
|
|
state.length = state.length - length3;
|
|
}
|
|
const length4 = state.length;
|
|
r1173 = r1176;
|
|
r1174 = r1177;
|
|
r129 = r128;
|
|
r132 = r127;
|
|
bits3 = r154;
|
|
hold3 = r150;
|
|
avail_in3 = r1173;
|
|
next_in3 = r1174;
|
|
if (length4) {
|
|
break L349;
|
|
}
|
|
}
|
|
state.length = 0;
|
|
state.mode = 7;
|
|
r153 = r1173;
|
|
r152 = r1174;
|
|
r149 = r154;
|
|
r146 = r150;
|
|
}
|
|
if (2048 & state.flags) {
|
|
let r1231 = 0;
|
|
r129 = r128;
|
|
r132 = r127;
|
|
bits3 = r149;
|
|
hold3 = r146;
|
|
next_in3 = r152;
|
|
avail_in3 = r153;
|
|
if (avail_in3 === 0) {
|
|
break L349;
|
|
}
|
|
while (true) {
|
|
const r1233 = input[r152 + r1231];
|
|
let head3 = state.head;
|
|
const r1235 = r1231;
|
|
if (head3) {
|
|
head3 = r1233;
|
|
}
|
|
if (head3) {
|
|
head3 = state.length < 65536;
|
|
}
|
|
if (head3) {
|
|
const head4 = state.head;
|
|
head4.name = head4.name + String.fromCharCode(r1233);
|
|
}
|
|
const r1243 = r1235 + 1;
|
|
if (r1233) {
|
|
r1231 = r1243;
|
|
if (r1231 < r153) {
|
|
continue;
|
|
}
|
|
}
|
|
if (512 & state.flags) {
|
|
state.check = _Module12719(state.check, input, r1243, r152);
|
|
}
|
|
r1228 = r153 - r1243;
|
|
r1229 = r152 + r1243;
|
|
r129 = r128;
|
|
r132 = r127;
|
|
bits3 = r149;
|
|
hold3 = r146;
|
|
avail_in3 = r1228;
|
|
next_in3 = r1229;
|
|
if (r1233) {
|
|
break L349;
|
|
}
|
|
break;
|
|
}
|
|
} else {
|
|
const head2 = state.head;
|
|
r1228 = r153;
|
|
r1229 = r152;
|
|
if (head2) {
|
|
state.head.name = null;
|
|
r1228 = r153;
|
|
r1229 = r152;
|
|
}
|
|
}
|
|
state.length = 0;
|
|
state.mode = 8;
|
|
r148 = r1228;
|
|
r147 = r1229;
|
|
r145 = r149;
|
|
r144 = r146;
|
|
}
|
|
if (4096 & state.flags) {
|
|
let r1264 = 0;
|
|
r129 = r128;
|
|
r132 = r127;
|
|
bits3 = r145;
|
|
hold3 = r144;
|
|
next_in3 = r147;
|
|
avail_in3 = r148;
|
|
if (avail_in3 === 0) {
|
|
break L349;
|
|
}
|
|
while (true) {
|
|
const r1266 = input[r147 + r1264];
|
|
let head6 = state.head;
|
|
const r1268 = r1264;
|
|
if (head6) {
|
|
head6 = r1266;
|
|
}
|
|
if (head6) {
|
|
head6 = state.length < 65536;
|
|
}
|
|
if (head6) {
|
|
const head7 = state.head;
|
|
head7.comment = head7.comment + String.fromCharCode(r1266);
|
|
}
|
|
const r1276 = r1268 + 1;
|
|
if (r1266) {
|
|
r1264 = r1276;
|
|
if (r1264 < r148) {
|
|
continue;
|
|
}
|
|
}
|
|
if (512 & state.flags) {
|
|
state.check = _Module12719(state.check, input, r1276, r147);
|
|
}
|
|
r1261 = r148 - r1276;
|
|
r1262 = r147 + r1276;
|
|
r129 = r128;
|
|
r132 = r127;
|
|
bits3 = r145;
|
|
hold3 = r144;
|
|
avail_in3 = r1261;
|
|
next_in3 = r1262;
|
|
if (r1266) {
|
|
break L349;
|
|
}
|
|
break;
|
|
}
|
|
} else {
|
|
const head5 = state.head;
|
|
r1261 = r148;
|
|
r1262 = r147;
|
|
if (head5) {
|
|
state.head.comment = null;
|
|
r1261 = r148;
|
|
r1262 = r147;
|
|
}
|
|
}
|
|
state.mode = 9;
|
|
r140 = r1261;
|
|
r139 = r1262;
|
|
r151 = r145;
|
|
r141 = r144;
|
|
}
|
|
const r1292 = 512 & state.flags;
|
|
let r1293 = r151;
|
|
let r1294 = r141;
|
|
let r1295 = r140;
|
|
let r1296 = r139;
|
|
if (r1292) {
|
|
let r1297 = r151;
|
|
let r1298 = r141;
|
|
let r1299 = r140;
|
|
let r1300 = r139;
|
|
let r1301 = r1297;
|
|
let r1302 = r1298;
|
|
let r1303 = r1299;
|
|
let r1304 = r1300;
|
|
while (r1301 < 16) {
|
|
const r1305 = r1297;
|
|
const r1306 = r1298;
|
|
const r1307 = r1299;
|
|
const r1308 = r1300;
|
|
r129 = r128;
|
|
r132 = r127;
|
|
bits3 = r1305;
|
|
hold3 = r1306;
|
|
next_in3 = r1308;
|
|
avail_in3 = r1307;
|
|
if (avail_in3 === 0) {
|
|
break L349;
|
|
}
|
|
r1299 = r1307 - 1;
|
|
const r1309 = +r1308;
|
|
r1300 = r1309 + 1;
|
|
r1298 = r1306 + (input[r1309] << r1305);
|
|
r1297 = r1305 + 8;
|
|
r1302 = r1298;
|
|
r1303 = r1299;
|
|
r1304 = r1300;
|
|
r1301 = r1297;
|
|
}
|
|
const r1313 = 65535 & state.check;
|
|
r1293 = 0;
|
|
r1294 = 0;
|
|
r1295 = r1303;
|
|
r1296 = r1304;
|
|
if (r1302 !== r1313) {
|
|
a0.msg = "header crc mismatch";
|
|
state.mode = 30;
|
|
r86 = r128;
|
|
avail_out = r127;
|
|
bits = r1301;
|
|
hold = r1302;
|
|
r272 = avail_out3;
|
|
r273 = r1303;
|
|
next_out = next_out3;
|
|
next_in = r1304;
|
|
output = r120;
|
|
input = input;
|
|
continue;
|
|
}
|
|
}
|
|
if (state.head) {
|
|
state.head.hcrc = state.flags >> 9 & 1;
|
|
state.head.done = true;
|
|
}
|
|
state.check = 0;
|
|
a0.adler = 0;
|
|
state.mode = 12;
|
|
r86 = r128;
|
|
avail_out = r127;
|
|
bits = r1293;
|
|
hold = r1294;
|
|
r272 = avail_out3;
|
|
r273 = r1295;
|
|
next_out = next_out3;
|
|
next_in = r1296;
|
|
output = r120;
|
|
input = input;
|
|
continue;
|
|
}
|
|
L355: {
|
|
a0.next_out = next_out3;
|
|
a0.avail_out = avail_out3;
|
|
a0.next_in = next_in3;
|
|
a0.avail_in = avail_in3;
|
|
state.hold = hold3;
|
|
state.bits = bits3;
|
|
if (!state.wsize) {
|
|
if (r132 === a0.avail_out) {
|
|
break L355;
|
|
}
|
|
if (!(state.mode < 30)) {
|
|
break L355;
|
|
}
|
|
if (!(!(state.mode < 27) && a1 === 4)) {
|
|
updatewindow(a0, a0.output, a0.next_out, r132 - a0.avail_out);
|
|
}
|
|
} else {
|
|
updatewindow(a0, a0.output, a0.next_out, r132 - a0.avail_out);
|
|
}
|
|
}
|
|
const r1387 = avail_in - a0.avail_in;
|
|
const r1389 = r132 - a0.avail_out;
|
|
a0.total_in = a0.total_in + r1387;
|
|
a0.total_out = a0.total_out + r1389;
|
|
state.total = state.total + r1389;
|
|
if (state.wrap && r1389) {
|
|
const check4 = state.flags ? _Module12719(state.check, r120, r1389, a0.next_out - r1389) : _adler32(state.check, r120, r1389, a0.next_out - r1389);
|
|
state.check = check4;
|
|
a0.adler = check4;
|
|
}
|
|
a0.data_type = state.bits + (state.last ? 64 : 0) + (state.mode === 12 ? 128 : 0) + (state.mode !== 20 ? state.mode === 15 ? 256 : 0 : 256);
|
|
if ((r1387 === 0 && r1389 === 0 || a1 === 4) && r129 === 0) {
|
|
r129 = -5;
|
|
}
|
|
return r129;
|
|
}
|
|
}
|
|
}
|
|
return -2;
|
|
}
|
|
export function inflateEnd(a0) {
|
|
if (a0 && a0.state) {
|
|
const state = a0.state;
|
|
if (state.window) {
|
|
state.window = null;
|
|
}
|
|
a0.state = null;
|
|
return 0;
|
|
}
|
|
return -2;
|
|
}
|
|
export function inflateGetHeader(a0, a1) {
|
|
let r0 = -2;
|
|
if (a0) {
|
|
const state = a0.state;
|
|
r0 = -2;
|
|
if (state) {
|
|
const state2 = a0.state;
|
|
const r8 = 2 & state2.wrap;
|
|
r0 = -2;
|
|
if (r8) {
|
|
state2.head = a1;
|
|
a1.done = false;
|
|
r0 = 0;
|
|
}
|
|
}
|
|
}
|
|
return r0;
|
|
}
|
|
export function inflateSetDictionary(a0, a1) {
|
|
let r27;
|
|
const length = a1.length;
|
|
let r1 = -2;
|
|
let r2 = -2;
|
|
if (a0) {
|
|
const state = a0.state;
|
|
r2 = -2;
|
|
if (state) {
|
|
const state2 = a0.state;
|
|
if (!(state2.wrap !== 0 && state2.mode !== 11)) {
|
|
if (state2.mode === 11) {
|
|
const r25 = _adler32(1, a1, length, 0);
|
|
const check = state2.check;
|
|
r27 = -3;
|
|
if (r25 === check) {
|
|
updatewindow(a0, a1, length, length);
|
|
state2.havedict = 1;
|
|
r27 = 0;
|
|
}
|
|
} else {
|
|
updatewindow(a0, a1, length, length);
|
|
state2.havedict = 1;
|
|
r27 = 0;
|
|
}
|
|
r1 = r27;
|
|
}
|
|
r2 = r1;
|
|
}
|
|
}
|
|
return r2;
|
|
}
|
|
export const inflateInfo = "pako inflate (from Nodeca project)";
|