260 lines
6.1 KiB
JavaScript
260 lines
6.1 KiB
JavaScript
// Metro module 1313 (f1314).
|
|
let c1082_0;
|
|
export function varint64read() {
|
|
let r4 = 0;
|
|
let r0 = 0;
|
|
while (true) {
|
|
const buf = this.buf;
|
|
const r16 = +this.pos;
|
|
this.pos = r16 + 1;
|
|
const r17 = buf[r16];
|
|
const r19 = r0 | (127 & r17) << r4;
|
|
const r9 = 128 & r17;
|
|
const r5 = r4;
|
|
if (!r9) {
|
|
this.assertBounds();
|
|
return [r19, 0];
|
|
}
|
|
r4 = r5 + 7;
|
|
r0 = r19;
|
|
if (!(r4 < 28)) {
|
|
const buf2 = this.buf;
|
|
const r25 = +this.pos;
|
|
this.pos = r25 + 1;
|
|
const r27 = buf2[r25];
|
|
const r31 = r19 | (15 & r27) << 28;
|
|
const r35 = (112 & r27) >> 4;
|
|
const r36 = 128 & r27;
|
|
let r37 = 3;
|
|
let r39 = r35;
|
|
if (!r36) {
|
|
this.assertBounds();
|
|
return [r31, r35];
|
|
}
|
|
while (true) {
|
|
const buf3 = this.buf;
|
|
const r45 = +this.pos;
|
|
this.pos = r45 + 1;
|
|
const r47 = buf3[r45];
|
|
const r50 = r39 | (127 & r47) << r37;
|
|
const r51 = 128 & r47;
|
|
const r52 = r37;
|
|
if (!r51) {
|
|
this.assertBounds();
|
|
return [r31, r50];
|
|
}
|
|
r37 = r52 + 7;
|
|
r39 = r50;
|
|
if (!(r37 <= 31)) {
|
|
throw new Error("invalid varint");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
export function varint64write(a0, a1, a2) {
|
|
let r1 = 0;
|
|
while (true) {
|
|
const r2 = a0 >>> r1;
|
|
const r0 = r2 >>> 7;
|
|
let r9 = r0 === 0;
|
|
const r3 = r1;
|
|
if (r0 === 0) {
|
|
r9 = a1 == 0;
|
|
}
|
|
const r15 = !r9;
|
|
a2.push(255 & (r15 ? 128 | r2 : r2));
|
|
if (!r15) {
|
|
return void 0;
|
|
}
|
|
r1 = r3 + 7;
|
|
if (!(r1 < 28)) {
|
|
const r26 = a0 >>> 28 & 15 | (7 & a1) << 4;
|
|
let r27 = 3;
|
|
const r30 = !!(a1 >> 3);
|
|
a2.push.call(a2, 255 & (r30 ? 128 | r26 : r26));
|
|
if (r30) {
|
|
while (true) {
|
|
const r36 = a1 >>> r27;
|
|
const r39 = !(r36 >>> 7 === 0);
|
|
const r40 = r27;
|
|
a2.push(255 & (r39 ? 128 | r36 : r36));
|
|
if (!r39) {
|
|
return void 0;
|
|
}
|
|
r27 = r40 + 7;
|
|
if (!(r27 < 31)) {
|
|
a2.push(a1 >>> 31 & 1);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
}
|
|
}
|
|
c1082_0 = 4294967296;
|
|
export function int64fromString(a0) {
|
|
const r7 = a0[0] == "-";
|
|
const r13 = r7 ? a0.slice(1) : a0;
|
|
const r20 = 0 + Number(r13.slice(-24, -18));
|
|
let r22 = 0;
|
|
let r23 = r20;
|
|
if (r23 >= c1082_0) {
|
|
r22 = 0 + (r20 / c1082_0 | 0);
|
|
r23 = r20 % c1082_0;
|
|
}
|
|
const r29 = Number(r13.slice(-18, -12));
|
|
const r4 = r22 * 1000000;
|
|
const r32 = r23 * 1000000 + r29;
|
|
let r33 = r4;
|
|
let r34 = r32;
|
|
if (r34 >= c1082_0) {
|
|
r33 = r4 + (r32 / c1082_0 | 0);
|
|
r34 = r32 % c1082_0;
|
|
}
|
|
const r41 = Number(r13.slice(-12, -6));
|
|
const r42 = r33 * 1000000;
|
|
const r44 = r34 * 1000000 + r41;
|
|
let r45 = r42;
|
|
let r46 = r44;
|
|
if (r46 >= c1082_0) {
|
|
r45 = r42 + (r44 / c1082_0 | 0);
|
|
r46 = r44 % c1082_0;
|
|
}
|
|
const r52 = Number(r13.slice(-6, void 0));
|
|
const r53 = r45 * 1000000;
|
|
const r55 = r46 * 1000000 + r52;
|
|
let r56 = r53;
|
|
let r57 = r55;
|
|
if (r57 >= c1082_0) {
|
|
r56 = r53 + (r55 / c1082_0 | 0);
|
|
r57 = r55 % c1082_0;
|
|
}
|
|
return [r7, r57, r56];
|
|
}
|
|
export function int64toString(a0, a1) {
|
|
if (a1 <= 2097151) {
|
|
return "" + (c1082_0 * a1 + (a0 >>> 0));
|
|
}
|
|
const r21 = (a0 >>> 24 | a1 << 8) >>> 0 & 16777215;
|
|
const r25 = a1 >> 16 & 65535;
|
|
const r31 = (16777215 & a0) + 6777216 * r21 + 6710656 * r25;
|
|
const r34 = r21 + 8147497 * r25;
|
|
let r10 = r34;
|
|
let r36 = r31;
|
|
if (10000000 <= r36) {
|
|
r10 = r34 + Math.floor(r31 / 10000000);
|
|
r36 = r31 % 10000000;
|
|
}
|
|
const r40 = 2 * r25;
|
|
let r12 = r40;
|
|
let r14 = r10;
|
|
if (r14 >= 10000000) {
|
|
r12 = r40 + Math.floor(r10 / 10000000);
|
|
r14 = r10 % 10000000;
|
|
}
|
|
let r46 = "";
|
|
const r47 = r12 ? String(r12) : "";
|
|
const r13 = r14 ? String(r14) : "";
|
|
const r57 = r47 + (r12 ? "0000000".slice(r13.length) + r13 : r13);
|
|
if (r36) {
|
|
r46 = String(r36);
|
|
}
|
|
return r57 + ("0000000".slice(r46.length) + r46);
|
|
}
|
|
export function varint32write(a0, a1) {
|
|
let r0 = 0;
|
|
const r8 = a0 >= 0;
|
|
let r9 = a0;
|
|
if (r8) {
|
|
let r17 = a0;
|
|
let r18 = a0;
|
|
if (a0 > 127) {
|
|
do {
|
|
a1.push(127 & r17 | 128);
|
|
r17 = r17 >>> 7;
|
|
r18 = r17;
|
|
} while (127 < r18);
|
|
}
|
|
a1.push(r18);
|
|
} else {
|
|
while (true) {
|
|
a1.push(127 & r9 | 128);
|
|
r9 = r9 >> 7;
|
|
r0 = r0 + 1;
|
|
if (!(r0 < 9)) {
|
|
a1.push(1);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
export function varint32read() {
|
|
const buf = this.buf;
|
|
const r15 = +this.pos;
|
|
this.pos = r15 + 1;
|
|
const r16 = buf[r15];
|
|
const r7 = 127 & r16;
|
|
if (128 & r16) {
|
|
const buf2 = this.buf;
|
|
const r21 = +this.pos;
|
|
this.pos = r21 + 1;
|
|
const r23 = buf2[r21];
|
|
const r26 = r7 | (127 & r23) << 7;
|
|
if (128 & r23) {
|
|
const buf3 = this.buf;
|
|
const r32 = +this.pos;
|
|
this.pos = r32 + 1;
|
|
const r34 = buf3[r32];
|
|
const r38 = r26 | (127 & r34) << 14;
|
|
if (128 & r34) {
|
|
const buf4 = this.buf;
|
|
const r44 = +this.pos;
|
|
this.pos = r44 + 1;
|
|
const r46 = buf4[r44];
|
|
const r50 = r38 | (127 & r46) << 21;
|
|
if (128 & r46) {
|
|
const buf5 = this.buf;
|
|
const r56 = +this.pos;
|
|
this.pos = r56 + 1;
|
|
let r58 = buf5[r56];
|
|
const r60 = 15 & r58;
|
|
const r2 = 128 & r58;
|
|
let r0 = 5;
|
|
if (r2) {
|
|
do {
|
|
const buf6 = this.buf;
|
|
const r65 = +this.pos;
|
|
this.pos = r65 + 1;
|
|
const r66 = buf6[r65];
|
|
const r6 = 128 & r66;
|
|
const r67 = r0;
|
|
r58 = r66;
|
|
if (!r6) {
|
|
break;
|
|
}
|
|
r0 = r67 + 1;
|
|
r58 = r66;
|
|
} while (r0 < 10);
|
|
}
|
|
if (128 & r58) {
|
|
throw new Error("invalid varint");
|
|
}
|
|
const r71 = r50 | r60 << 28;
|
|
this.assertBounds();
|
|
return r71 >>> 0;
|
|
}
|
|
this.assertBounds();
|
|
return r50;
|
|
}
|
|
this.assertBounds();
|
|
return r38;
|
|
}
|
|
this.assertBounds();
|
|
return r26;
|
|
}
|
|
this.assertBounds();
|
|
return r7;
|
|
}
|