407 lines
14 KiB
JavaScript
407 lines
14 KiB
JavaScript
// Metro module 12724 (f12725).
|
|
module.exports = function inflate_fast(a0, a1) {
|
|
let r102, r103, r105, r178, r179, r180, r181, r190, r191, r192, r193, next_out2;
|
|
const state = a0.state;
|
|
let next_in = a0.next_in;
|
|
const input = a0.input;
|
|
const r40 = next_in + (a0.avail_in - 5);
|
|
let next_out = a0.next_out;
|
|
const output = a0.output;
|
|
const r52 = next_out - (a1 - a0.avail_out);
|
|
const r73 = next_out + (a0.avail_out - 257);
|
|
const { dmax, wsize, whave, wnext, window: window2 } = state;
|
|
let hold = state.hold;
|
|
let bits = state.bits;
|
|
const { lencode, distcode } = state;
|
|
const r30 = (1 << state.lenbits) - 1;
|
|
const r31 = (1 << state.distbits) - 1;
|
|
loop1: while (true) {
|
|
const r60 = bits;
|
|
const r61 = hold;
|
|
const r59 = next_out;
|
|
const r79 = next_in;
|
|
let r42 = r61;
|
|
let r58 = r79;
|
|
let r41 = r60;
|
|
if (r41 < 15) {
|
|
const r80 = +r79;
|
|
const r82 = r61 + (input[r80] << r60);
|
|
const r83 = r60 + 8;
|
|
const r85 = +(r80 + 1);
|
|
r58 = r85 + 1;
|
|
r42 = r82 + (input[r85] << r83);
|
|
r41 = r83 + 8;
|
|
}
|
|
let r88 = lencode[r42 & r30];
|
|
while (true) {
|
|
L64: {
|
|
L62: {
|
|
const r89 = r88 >>> 24;
|
|
const r18 = r42 >>> r89;
|
|
const r19 = r41 - r89;
|
|
const r1 = r88 >>> 16 & 255;
|
|
const r91 = r88;
|
|
if (r1 === 0) {
|
|
const r247 = +r59;
|
|
r180 = r247 + 1;
|
|
output[r247] = 65535 & r91;
|
|
r178 = r19;
|
|
r179 = r18;
|
|
r181 = r58;
|
|
} else {
|
|
if (!(16 & r1)) {
|
|
if (64 & r1) {
|
|
if (32 & r1) {
|
|
state.mode = 12;
|
|
r102 = r19;
|
|
r103 = r18;
|
|
next_out2 = r59;
|
|
r105 = r58;
|
|
break L64;
|
|
}
|
|
a0.msg = "invalid literal/length code";
|
|
state.mode = 30;
|
|
r102 = r19;
|
|
r103 = r18;
|
|
next_out2 = r59;
|
|
r105 = r58;
|
|
break L64;
|
|
}
|
|
r88 = lencode[(65535 & r91) + (r18 & (1 << r1) - 1)];
|
|
r41 = r19;
|
|
r42 = r18;
|
|
continue;
|
|
}
|
|
const r5 = 65535 & r91;
|
|
const r7 = r1 & 15;
|
|
let r14 = r5;
|
|
let r106 = r19;
|
|
let r15 = r18;
|
|
let r107 = r58;
|
|
if (r7) {
|
|
let r12 = r19;
|
|
let r108 = r18;
|
|
let r109 = r58;
|
|
if (r19 < r7) {
|
|
const r62 = +r58;
|
|
r109 = r62 + 1;
|
|
r108 = r18 + (input[r62] << r19);
|
|
r12 = r19 + 8;
|
|
}
|
|
r14 = r5 + (r108 & (1 << r7) - 1);
|
|
r15 = r108 >>> r7;
|
|
r106 = r12 - r7;
|
|
r107 = r109;
|
|
}
|
|
let r114 = r15;
|
|
let r115 = r107;
|
|
let r116 = r106;
|
|
if (r116 < 15) {
|
|
const r117 = +r107;
|
|
const r119 = input[r117] << r106;
|
|
const r120 = r106 + 8;
|
|
const r122 = +(r117 + 1);
|
|
r115 = r122 + 1;
|
|
r114 = r15 + r119 + (input[r122] << r120);
|
|
r116 = r120 + 8;
|
|
}
|
|
let r127 = distcode[r114 & r31];
|
|
while (true) {
|
|
const r128 = r127 >>> 24;
|
|
const r129 = r114 >>> r128;
|
|
const r130 = r116 - r128;
|
|
const r132 = r127 >>> 16 & 255;
|
|
const r133 = 16 & r132;
|
|
const r134 = r127;
|
|
if (r133) {
|
|
const r143 = 65535 & r134;
|
|
const r144 = r132 & 15;
|
|
let r145 = r130;
|
|
let r146 = r129;
|
|
let r147 = r115;
|
|
if (r130 < r144) {
|
|
const r148 = +r115;
|
|
const r149 = r148 + 1;
|
|
const r13 = r129 + (input[r148] << r130);
|
|
const r8 = r130 + 8;
|
|
let r152 = r13;
|
|
let r153 = r149;
|
|
let r154 = r8;
|
|
if (r154 < r144) {
|
|
const r155 = +r149;
|
|
r153 = r155 + 1;
|
|
r152 = r13 + (input[r155] << r8);
|
|
r154 = r8 + 8;
|
|
}
|
|
r145 = r154;
|
|
r146 = r152;
|
|
r147 = r153;
|
|
}
|
|
const r10 = r143 + (r146 & (1 << r144) - 1);
|
|
if (r10 > dmax) {
|
|
a0.msg = "invalid distance too far back";
|
|
state.mode = 30;
|
|
r102 = r145;
|
|
r103 = r146;
|
|
next_out2 = r59;
|
|
r105 = r147;
|
|
break L64;
|
|
}
|
|
const r161 = r146 >>> r144;
|
|
const r162 = r145 - r144;
|
|
const r163 = r59 - r52;
|
|
if (r10 > r163) {
|
|
const r187 = r10 - r163;
|
|
if (r187 > whave && state.sane) {
|
|
a0.msg = "invalid distance too far back";
|
|
state.mode = 30;
|
|
r102 = r162;
|
|
r103 = r161;
|
|
next_out2 = r59;
|
|
r105 = r147;
|
|
break L64;
|
|
}
|
|
L53: {
|
|
if (wnext === 0) {
|
|
let r213 = 0 + (wsize - r187);
|
|
r190 = window2;
|
|
r191 = r213;
|
|
r192 = r14;
|
|
r193 = r59;
|
|
if (r187 < r14) {
|
|
let r214 = r187;
|
|
let r215 = r59;
|
|
while (true) {
|
|
const r216 = +r215;
|
|
const r217 = r216 + 1;
|
|
const r218 = r213 + 1;
|
|
output[r216] = window2[r213];
|
|
r214 = r214 - 1;
|
|
r213 = r218;
|
|
r215 = r217;
|
|
if (!r214) {
|
|
r192 = r14 - r187;
|
|
r191 = r217 - r10;
|
|
r190 = output;
|
|
r193 = r217;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
} else if (wnext < r187) {
|
|
let r9 = 0 + (wsize + wnext - r187);
|
|
const r199 = r187 - wnext;
|
|
r190 = window2;
|
|
r191 = r9;
|
|
r193 = r59;
|
|
r192 = r14;
|
|
if (r199 < r192) {
|
|
let r200 = r199;
|
|
let r201 = r59;
|
|
while (true) {
|
|
const r202 = +r201;
|
|
let r203 = r202 + 1;
|
|
const r26 = r9 + 1;
|
|
output[r202] = window2[r9];
|
|
r200 = r200 - 1;
|
|
r9 = r26;
|
|
r201 = r203;
|
|
if (!r200) {
|
|
const r205 = r14 - r199;
|
|
const r35 = wnext < r205;
|
|
r190 = window2;
|
|
r191 = 0;
|
|
r192 = r205;
|
|
r193 = r203;
|
|
if (!r35) {
|
|
break;
|
|
}
|
|
const r206 = r205 - wnext;
|
|
let r207 = 0;
|
|
let r208 = wnext;
|
|
while (true) {
|
|
const r68 = +r203;
|
|
const r209 = r68 + 1;
|
|
const r210 = r207 + 1;
|
|
output[r68] = window2[r207];
|
|
r208 = r208 - 1;
|
|
r207 = r210;
|
|
r203 = r209;
|
|
if (!r208) {
|
|
r191 = r209 - r10;
|
|
r190 = output;
|
|
r192 = r206;
|
|
r193 = r209;
|
|
break L53;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
let r0 = 0 + (wnext - r187);
|
|
r190 = window2;
|
|
r191 = r0;
|
|
r192 = r14;
|
|
r193 = r59;
|
|
if (r187 < r14) {
|
|
let r4 = r187;
|
|
let r194 = r59;
|
|
while (true) {
|
|
const r67 = +r194;
|
|
const r195 = r67 + 1;
|
|
const r17 = r0 + 1;
|
|
output[r67] = window2[r0];
|
|
r4 = r4 - 1;
|
|
r0 = r17;
|
|
r194 = r195;
|
|
if (!r4) {
|
|
r192 = r14 - r187;
|
|
r191 = r195 - r10;
|
|
r190 = output;
|
|
r193 = r195;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
let r220 = r191;
|
|
let r221 = r192;
|
|
let r222 = r193;
|
|
let r223 = r220;
|
|
let r224 = r222;
|
|
let r225 = r221;
|
|
while (2 < r225) {
|
|
const r226 = +r222;
|
|
const r227 = r220 + 1;
|
|
output[r226] = r190[r220];
|
|
const r230 = +(r226 + 1);
|
|
const r231 = r227 + 1;
|
|
output[r230] = r190[r227];
|
|
const r234 = +(r230 + 1);
|
|
r222 = r234 + 1;
|
|
r220 = r231 + 1;
|
|
output[r234] = r190[r231];
|
|
r221 = r221 - 3;
|
|
r223 = r220;
|
|
r224 = r222;
|
|
r225 = r221;
|
|
}
|
|
r178 = r162;
|
|
r179 = r161;
|
|
r180 = r224;
|
|
r181 = r147;
|
|
if (!r225) {
|
|
break;
|
|
}
|
|
const r236 = +r224;
|
|
const r237 = r236 + 1;
|
|
output[r236] = r190[r223];
|
|
let r239 = r237;
|
|
if (1 < r225) {
|
|
const r240 = r223 + 1;
|
|
const r241 = +r237;
|
|
r239 = r241 + 1;
|
|
output[r241] = r190[r240];
|
|
}
|
|
r180 = r239;
|
|
r178 = r162;
|
|
r179 = r161;
|
|
r181 = r147;
|
|
break;
|
|
}
|
|
let r164 = r59 - r10;
|
|
let r165 = r14;
|
|
let r166 = r59;
|
|
while (true) {
|
|
const r167 = +r166;
|
|
const r168 = r164 + 1;
|
|
output[r167] = output[r164];
|
|
const r170 = +(r167 + 1);
|
|
const r171 = r168 + 1;
|
|
output[r170] = output[r168];
|
|
const r64 = +(r170 + 1);
|
|
const r174 = r64 + 1;
|
|
const r175 = r171 + 1;
|
|
output[r64] = output[r171];
|
|
const r177 = r165 - 3;
|
|
r164 = r175;
|
|
r166 = r174;
|
|
r165 = r177;
|
|
if (!(2 < r165)) {
|
|
r178 = r162;
|
|
r179 = r161;
|
|
r180 = r174;
|
|
r181 = r147;
|
|
if (!r177) {
|
|
break L62;
|
|
}
|
|
const r65 = +r174;
|
|
const r182 = r65 + 1;
|
|
output[r65] = output[r175];
|
|
let r184 = r182;
|
|
if (1 < r177) {
|
|
const r185 = r175 + 1;
|
|
const r66 = +r182;
|
|
r184 = r66 + 1;
|
|
output[r66] = output[r185];
|
|
}
|
|
r180 = r184;
|
|
r178 = r162;
|
|
r179 = r161;
|
|
r181 = r147;
|
|
break L62;
|
|
}
|
|
}
|
|
} else {
|
|
if (64 & r132) {
|
|
a0.msg = "invalid distance code";
|
|
state.mode = 30;
|
|
r102 = r130;
|
|
r103 = r129;
|
|
next_out2 = r59;
|
|
r105 = r115;
|
|
break L64;
|
|
}
|
|
r127 = distcode[(65535 & r134) + (r129 & (1 << r132) - 1)];
|
|
r116 = r130;
|
|
r114 = r129;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
r102 = r178;
|
|
r103 = r179;
|
|
next_out2 = r180;
|
|
r105 = r181;
|
|
if (r105 < r40) {
|
|
bits = r178;
|
|
hold = r179;
|
|
next_out = r180;
|
|
next_in = r181;
|
|
r102 = bits;
|
|
r103 = hold;
|
|
next_out2 = next_out;
|
|
r105 = next_in;
|
|
if (r180 < r73) {
|
|
continue loop1;
|
|
}
|
|
}
|
|
}
|
|
const r249 = r102 >> 3;
|
|
const next_in2 = r105 - r249;
|
|
a0.next_in = next_in2;
|
|
a0.next_out = next_out2;
|
|
a0.avail_in = next_in2 < r40 ? r40 - next_in2 + 5 : 5 - (next_in2 - r40);
|
|
const avail_out = next_out2 < r73 ? r73 - next_out2 + 257 : 257 - (next_out2 - r73);
|
|
const bits2 = r102 - (r249 << 3);
|
|
const hold2 = r103 & (1 << bits2) - 1;
|
|
a0.avail_out = avail_out;
|
|
state.hold = hold2;
|
|
state.bits = bits2;
|
|
return void 0;
|
|
}
|
|
}
|
|
};
|