3971 lines
162 KiB
JavaScript
3971 lines
162 KiB
JavaScript
/* Metro module 24; source: unknown; dependencies: [] */
|
|
function _fun962(global, require, importDefault, importAll, module, exports, dependencyMap) { // fn#962, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:29:6, offset: 0x00c4e3c9, size: 106 bytes, params: 8, frame: 15
|
|
if (module !== undefined && module.hasOwnProperty('exports')) {
|
|
module.exports = _fun963();
|
|
}
|
|
if (typeof global.define === 'function' && global.define.amd) {
|
|
global.define(_fun1093);
|
|
}
|
|
function _fun963(a0) { // fn#963, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:29:41, offset: 0x00c4e433, size: 3429 bytes, params: 2, frame: 24
|
|
var push;
|
|
var value2;
|
|
var value3;
|
|
const Integer2 = Integer;
|
|
const closure2 = function(a0, a1) {
|
|
this.value = a0;
|
|
this.sign = a1;
|
|
this.isSmall = false;
|
|
};
|
|
const closure3 = function(a0) {
|
|
this.value = a0;
|
|
this.sign = a0 < 0;
|
|
this.isSmall = true;
|
|
};
|
|
const closure4 = function(a0) {
|
|
this.value = a0;
|
|
};
|
|
const isPrecise = function(a0) {
|
|
return -9007199254740992 < a0 && a0 < 9007199254740992;
|
|
};
|
|
const smallToArray2 = smallToArray;
|
|
const trim = function(a0) {
|
|
var r3;
|
|
var r2;
|
|
var length = a0.length;
|
|
var value = typeof length === 'bigint' ? length - 1n : +length - 1;
|
|
if (a0[value] !== 0) {
|
|
r2 = value;
|
|
} else {
|
|
for (r3 = value; true; r3 = value) {
|
|
value = typeof r3 === 'bigint' ? r3 - 1n : +r3 - 1;
|
|
if (a0[value] !== 0) {
|
|
r2 = value;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
a0.length = r2 + 1;
|
|
};
|
|
const createArray = function(a0) {
|
|
var r1;
|
|
var value4;
|
|
var Array = global.Array;
|
|
var value2 = new Array(a0);
|
|
var value3 = 0;
|
|
if (value3 < a0) {
|
|
for (r1 = value3; true; r1 = value4) {
|
|
value2[r1] = value3;
|
|
value4 = typeof r1 === 'bigint' ? r1 + 1n : +r1 + 1;
|
|
if (!(value4 < a0)) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return value2;
|
|
};
|
|
const truncate = function(a0) {
|
|
return a0 > 0 ? global.Math.floor(a0) : global.Math.ceil(a0);
|
|
};
|
|
const shiftLeft_2 = function(a0, a1) {
|
|
var r3;
|
|
var value3;
|
|
var items = [];
|
|
var value = typeof a1 === 'bigint' ? a1 : +a1;
|
|
if (value > 0) {
|
|
for (r3 = typeof value === 'bigint' ? value - 1n : +value - 1; true; r3 = value3) {
|
|
items.push(0);
|
|
value = typeof r3 === 'bigint' ? r3 : +r3;
|
|
value3 = typeof value === 'bigint' ? value - 1n : +value - 1;
|
|
if (!(value > 0)) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return items.concat(a0);
|
|
};
|
|
const divModSmall = function(a0, a1) {
|
|
var r0;
|
|
var r5;
|
|
var r1;
|
|
var value4;
|
|
var value5;
|
|
var value6;
|
|
var value7;
|
|
var property = a0.length;
|
|
var array = createArray(property);
|
|
var value2 = property - 1;
|
|
var value3 = 0;
|
|
if (value2 >= value3) {
|
|
r0 = value3;
|
|
for (r5 = value2; true; r5 = value7) {
|
|
property = a0[r5];
|
|
value4 = r0 * 10000000 + property;
|
|
value5 = truncate(value4 / a1);
|
|
value6 = value4 - value5 * a1;
|
|
array[r5] = value5 | 0;
|
|
value7 = typeof r5 === 'bigint' ? r5 - 1n : +r5 - 1;
|
|
if (!(value7 >= value3)) {
|
|
r1 = value6;
|
|
break;
|
|
}
|
|
r0 = value6;
|
|
}
|
|
} else {
|
|
r1 = value3;
|
|
}
|
|
return [array, r1 | 0];
|
|
};
|
|
const compareAbs = function(a0, a1) {
|
|
var r5;
|
|
var r2;
|
|
var value;
|
|
var value3;
|
|
var value4;
|
|
var property = a0.length;
|
|
if (property !== a1.length) {
|
|
return a0.length > a1.length ? 1 : -1;
|
|
}
|
|
value = 1;
|
|
var value2 = a0.length - value;
|
|
if (value2 >= 0) {
|
|
r5 = value2;
|
|
loopExit2: while (true) {
|
|
property = a0[r5];
|
|
if (property !== a1[r5]) {
|
|
property = a0[r5];
|
|
value4 = -1;
|
|
if (property > a1[r5]) {
|
|
r2 = value;
|
|
continue;
|
|
}
|
|
r2 = value4;
|
|
continue;
|
|
return r2;
|
|
}
|
|
value3 = typeof r5 === 'bigint' ? r5 - 1n : +r5 - 1;
|
|
if (value3 >= 0) {
|
|
r5 = value3;
|
|
continue;
|
|
}
|
|
break loopExit2;
|
|
}
|
|
}
|
|
return 0;
|
|
};
|
|
const shift_isSmall = function(a0) {
|
|
var Math = global.Math;
|
|
return Math.abs(a0) <= 10000000;
|
|
};
|
|
const max2 = max;
|
|
const min2 = min;
|
|
const gcd2 = gcd;
|
|
const parseValue2 = parseValue;
|
|
const env0_1 = smallToArray2(9007199254740992);
|
|
const BigInt = global.BigInt;
|
|
const result = typeof BigInt === 'function';
|
|
let Object = global.Object;
|
|
const create = Object.create;
|
|
let prototype = Integer2.prototype;
|
|
closure2.prototype = Reflect.apply(create, Object, [prototype]);
|
|
Object = global.Object;
|
|
closure3.prototype = Object.create(Integer2.prototype);
|
|
Object = global.Object;
|
|
closure4.prototype = Object.create(Integer2.prototype);
|
|
closure2.prototype.add = add_1003;
|
|
closure2.prototype.plus = closure2.prototype.add;
|
|
closure3.prototype.add = add_1004;
|
|
closure3.prototype.plus = closure3.prototype.add;
|
|
closure4.prototype.add = add_1005;
|
|
closure4.prototype.plus = closure4.prototype.add;
|
|
closure2.prototype.subtract = subtract_1006;
|
|
closure2.prototype.minus = closure2.prototype.subtract;
|
|
closure3.prototype.subtract = subtract_1007;
|
|
closure3.prototype.minus = closure3.prototype.subtract;
|
|
closure4.prototype.subtract = subtract_1008;
|
|
closure4.prototype.minus = closure4.prototype.subtract;
|
|
closure2.prototype.negate = negate;
|
|
closure3.prototype.negate = negate_1010;
|
|
closure4.prototype.negate = negate_1011;
|
|
closure2.prototype.abs = abs;
|
|
closure3.prototype.abs = abs_1013;
|
|
closure4.prototype.abs = abs_1014;
|
|
closure2.prototype.multiply = multiply;
|
|
prototype = closure2.prototype;
|
|
var multiply = closure2.prototype.multiply;
|
|
prototype.times = multiply;
|
|
closure3.prototype._multiplyBySmall = _multiplyBySmall;
|
|
closure2.prototype._multiplyBySmall = _multiplyBySmall_1017;
|
|
closure3.prototype.multiply = multiply_1018;
|
|
closure3.prototype.times = closure3.prototype.multiply;
|
|
closure4.prototype.multiply = multiply_1019;
|
|
closure4.prototype.times = closure4.prototype.multiply;
|
|
closure2.prototype.square = square_1020;
|
|
closure3.prototype.square = square_1021;
|
|
closure4.prototype.square = square_1022;
|
|
closure2.prototype.divmod = divmod;
|
|
prototype = closure4.prototype;
|
|
const prototype11 = closure3.prototype;
|
|
var divmod = closure2.prototype.divmod;
|
|
prototype11.divmod = divmod;
|
|
prototype.divmod = divmod;
|
|
closure2.prototype.divide = divide;
|
|
prototype = closure4.prototype;
|
|
const prototype13 = closure4.prototype;
|
|
const divide_10252 = divide_1025;
|
|
prototype13.divide = divide_10252;
|
|
prototype.over = divide_10252;
|
|
prototype = closure3.prototype;
|
|
const prototype14 = closure3.prototype;
|
|
const prototype15 = closure2.prototype;
|
|
var divide = closure2.prototype.divide;
|
|
prototype15.over = divide;
|
|
prototype14.divide = divide;
|
|
prototype.over = divide;
|
|
closure2.prototype.mod = mod;
|
|
prototype = closure4.prototype;
|
|
const prototype17 = closure4.prototype;
|
|
const remainder2 = remainder;
|
|
prototype17.remainder = remainder2;
|
|
prototype.mod = remainder2;
|
|
prototype = closure3.prototype;
|
|
const prototype18 = closure3.prototype;
|
|
const prototype19 = closure2.prototype;
|
|
var mod = closure2.prototype.mod;
|
|
prototype19.remainder = mod;
|
|
prototype18.mod = mod;
|
|
prototype.remainder = mod;
|
|
closure2.prototype.pow = pow;
|
|
prototype = closure3.prototype;
|
|
var pow = closure2.prototype.pow;
|
|
prototype.pow = pow;
|
|
closure4.prototype.pow = pow_1029;
|
|
closure2.prototype.modPow = modPow;
|
|
prototype = closure4.prototype;
|
|
const prototype22 = closure3.prototype;
|
|
var modPow = closure2.prototype.modPow;
|
|
prototype22.modPow = modPow;
|
|
prototype.modPow = modPow;
|
|
closure2.prototype.compareAbs = compareAbs_1031;
|
|
closure3.prototype.compareAbs = compareAbs_1032;
|
|
closure4.prototype.compareAbs = compareAbs_1033;
|
|
closure2.prototype.compare = compare_1034;
|
|
closure2.prototype.compareTo = closure2.prototype.compare;
|
|
closure3.prototype.compare = compare_1035;
|
|
closure3.prototype.compareTo = closure3.prototype.compare;
|
|
closure4.prototype.compare = compare_1036;
|
|
closure4.prototype.compareTo = closure4.prototype.compare;
|
|
closure2.prototype.equals = function(a0) {
|
|
return this.compare(a0) === 0;
|
|
};
|
|
prototype = closure4.prototype;
|
|
const prototype27 = closure4.prototype;
|
|
const prototype28 = closure3.prototype;
|
|
const prototype29 = closure3.prototype;
|
|
const prototype30 = closure2.prototype;
|
|
const equals = closure2.prototype.equals;
|
|
prototype30.eq = equals;
|
|
prototype29.equals = equals;
|
|
prototype28.eq = equals;
|
|
prototype27.equals = equals;
|
|
prototype.eq = equals;
|
|
closure2.prototype.notEquals = function(a0) {
|
|
return this.compare(a0) !== 0;
|
|
};
|
|
prototype = closure4.prototype;
|
|
const prototype32 = closure4.prototype;
|
|
const prototype33 = closure3.prototype;
|
|
const prototype34 = closure3.prototype;
|
|
const prototype35 = closure2.prototype;
|
|
const notEquals = closure2.prototype.notEquals;
|
|
prototype35.neq = notEquals;
|
|
prototype34.notEquals = notEquals;
|
|
prototype33.neq = notEquals;
|
|
prototype32.notEquals = notEquals;
|
|
prototype.neq = notEquals;
|
|
closure2.prototype.greater = function(a0) {
|
|
return this.compare(a0) > 0;
|
|
};
|
|
prototype = closure4.prototype;
|
|
const prototype37 = closure4.prototype;
|
|
const prototype38 = closure3.prototype;
|
|
const prototype39 = closure3.prototype;
|
|
const prototype40 = closure2.prototype;
|
|
const greater = closure2.prototype.greater;
|
|
prototype40.gt = greater;
|
|
prototype39.greater = greater;
|
|
prototype38.gt = greater;
|
|
prototype37.greater = greater;
|
|
prototype.gt = greater;
|
|
closure2.prototype.lesser = function(a0) {
|
|
return this.compare(a0) < 0;
|
|
};
|
|
prototype = closure4.prototype;
|
|
const prototype42 = closure4.prototype;
|
|
const prototype43 = closure3.prototype;
|
|
const prototype44 = closure3.prototype;
|
|
const prototype45 = closure2.prototype;
|
|
const lesser = closure2.prototype.lesser;
|
|
prototype45.lt = lesser;
|
|
prototype44.lesser = lesser;
|
|
prototype43.lt = lesser;
|
|
prototype42.lesser = lesser;
|
|
prototype.lt = lesser;
|
|
closure2.prototype.greaterOrEquals = function(a0) {
|
|
return this.compare(a0) >= 0;
|
|
};
|
|
prototype = closure4.prototype;
|
|
const prototype47 = closure4.prototype;
|
|
const prototype48 = closure3.prototype;
|
|
const prototype49 = closure3.prototype;
|
|
const prototype50 = closure2.prototype;
|
|
const greaterOrEquals = closure2.prototype.greaterOrEquals;
|
|
prototype50.geq = greaterOrEquals;
|
|
prototype49.greaterOrEquals = greaterOrEquals;
|
|
prototype48.geq = greaterOrEquals;
|
|
prototype47.greaterOrEquals = greaterOrEquals;
|
|
prototype.geq = greaterOrEquals;
|
|
closure2.prototype.lesserOrEquals = function(a0) {
|
|
return this.compare(a0) <= 0;
|
|
};
|
|
prototype = closure4.prototype;
|
|
const prototype52 = closure4.prototype;
|
|
const prototype53 = closure3.prototype;
|
|
const prototype54 = closure3.prototype;
|
|
const prototype55 = closure2.prototype;
|
|
const lesserOrEquals = closure2.prototype.lesserOrEquals;
|
|
prototype55.leq = lesserOrEquals;
|
|
prototype54.lesserOrEquals = lesserOrEquals;
|
|
prototype53.leq = lesserOrEquals;
|
|
prototype52.lesserOrEquals = lesserOrEquals;
|
|
prototype.leq = lesserOrEquals;
|
|
closure2.prototype.isEven = function() {
|
|
return !(1 & this.value[0]);
|
|
};
|
|
closure3.prototype.isEven = function() {
|
|
return !(1 & this.value);
|
|
};
|
|
closure4.prototype.isEven = function() {
|
|
return (this.value & (0, global.BigInt)(1)) === (0, global.BigInt)(0);
|
|
};
|
|
closure2.prototype.isOdd = function() {
|
|
return !(1 & ~this.value[0]);
|
|
};
|
|
closure3.prototype.isOdd = function() {
|
|
return !(1 & ~this.value);
|
|
};
|
|
closure4.prototype.isOdd = function() {
|
|
return (this.value & (0, global.BigInt)(1)) === (0, global.BigInt)(1);
|
|
};
|
|
closure2.prototype.isPositive = function() {
|
|
return !this.sign;
|
|
};
|
|
closure3.prototype.isPositive = function() {
|
|
return this.value > 0;
|
|
};
|
|
closure4.prototype.isPositive = closure3.prototype.isPositive;
|
|
closure2.prototype.isNegative = function() {
|
|
return this.sign;
|
|
};
|
|
closure3.prototype.isNegative = function() {
|
|
return this.value < 0;
|
|
};
|
|
closure4.prototype.isNegative = closure3.prototype.isNegative;
|
|
closure2.prototype.isUnit = function() {
|
|
return false;
|
|
};
|
|
closure3.prototype.isUnit = function() {
|
|
var Math = global.Math;
|
|
return Math.abs(this.value) === 1;
|
|
};
|
|
closure4.prototype.isUnit = function() {
|
|
return this.abs().value === (0, global.BigInt)(1);
|
|
};
|
|
closure2.prototype.isZero = function() {
|
|
return false;
|
|
};
|
|
closure3.prototype.isZero = function() {
|
|
return this.value === 0;
|
|
};
|
|
closure4.prototype.isZero = function() {
|
|
return this.value === (0, global.BigInt)(0);
|
|
};
|
|
closure2.prototype.isDivisibleBy = isDivisibleBy;
|
|
prototype = closure4.prototype;
|
|
const prototype59 = closure3.prototype;
|
|
var isDivisibleBy = closure2.prototype.isDivisibleBy;
|
|
prototype59.isDivisibleBy = isDivisibleBy;
|
|
prototype.isDivisibleBy = isDivisibleBy;
|
|
closure2.prototype.isPrime = isPrime;
|
|
prototype = closure4.prototype;
|
|
const prototype61 = closure3.prototype;
|
|
var isPrime = closure2.prototype.isPrime;
|
|
prototype61.isPrime = isPrime;
|
|
prototype.isPrime = isPrime;
|
|
closure2.prototype.isProbablePrime = isProbablePrime;
|
|
prototype = closure4.prototype;
|
|
const prototype63 = closure3.prototype;
|
|
var isProbablePrime = closure2.prototype.isProbablePrime;
|
|
prototype63.isProbablePrime = isProbablePrime;
|
|
prototype.isProbablePrime = isProbablePrime;
|
|
closure2.prototype.modInv = modInv;
|
|
prototype = closure4.prototype;
|
|
const prototype65 = closure3.prototype;
|
|
var modInv = closure2.prototype.modInv;
|
|
prototype65.modInv = modInv;
|
|
prototype.modInv = modInv;
|
|
closure2.prototype.next = next;
|
|
closure3.prototype.next = next_1064;
|
|
closure4.prototype.next = next_1065;
|
|
closure2.prototype.prev = prev;
|
|
closure3.prototype.prev = prev_1067;
|
|
closure4.prototype.prev = prev_1068;
|
|
const items2 = [1];
|
|
let length = items2.length;
|
|
if (2 * items2[length - 1] <= 10000000) {
|
|
while (true) {
|
|
push = items2.push;
|
|
length = items2.length;
|
|
Reflect.apply(push, items2, [2 * items2[length - 1]]);
|
|
length = items2.length;
|
|
if (!(2 * items2[length - 1] <= 10000000)) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
const env0_6 = items2[items2.length - 1];
|
|
closure2.prototype.shiftLeft = shiftLeft_1069;
|
|
prototype = closure4.prototype;
|
|
const prototype67 = closure3.prototype;
|
|
const shiftLeft = closure2.prototype.shiftLeft;
|
|
prototype67.shiftLeft = shiftLeft;
|
|
prototype.shiftLeft = shiftLeft;
|
|
closure2.prototype.shiftRight = shiftRight;
|
|
prototype = closure4.prototype;
|
|
const prototype69 = closure3.prototype;
|
|
var shiftRight = closure2.prototype.shiftRight;
|
|
prototype69.shiftRight = shiftRight;
|
|
prototype.shiftRight = shiftRight;
|
|
closure2.prototype.not = function() {
|
|
return this.negate().prev();
|
|
};
|
|
prototype = closure4.prototype;
|
|
const prototype71 = closure3.prototype;
|
|
const not = closure2.prototype.not;
|
|
prototype71.not = not;
|
|
prototype.not = not;
|
|
closure2.prototype.and = function(a0) {
|
|
return bitwise(this, a0, _fun1073);
|
|
};
|
|
prototype = closure4.prototype;
|
|
const prototype73 = closure3.prototype;
|
|
const and = closure2.prototype.and;
|
|
prototype73.and = and;
|
|
prototype.and = and;
|
|
closure2.prototype.or = function(a0) {
|
|
return bitwise(this, a0, _fun1075);
|
|
};
|
|
prototype = closure4.prototype;
|
|
const prototype75 = closure3.prototype;
|
|
const or = closure2.prototype.or;
|
|
prototype75.or = or;
|
|
prototype.or = or;
|
|
closure2.prototype.xor = function(a0) {
|
|
return bitwise(this, a0, _fun1077);
|
|
};
|
|
prototype = closure4.prototype;
|
|
const prototype77 = closure3.prototype;
|
|
const xor = closure2.prototype.xor;
|
|
prototype77.xor = xor;
|
|
prototype.xor = xor;
|
|
closure2.prototype.bitLength = bitLength;
|
|
prototype = closure4.prototype;
|
|
const prototype79 = closure3.prototype;
|
|
var bitLength = closure2.prototype.bitLength;
|
|
prototype79.bitLength = bitLength;
|
|
prototype.bitLength = bitLength;
|
|
closure2.prototype.toArray = function(a0) {
|
|
return toBase(this, a0);
|
|
};
|
|
closure3.prototype.toArray = function(a0) {
|
|
return toBase(this, a0);
|
|
};
|
|
closure4.prototype.toArray = function(a0) {
|
|
return toBase(this, a0);
|
|
};
|
|
closure2.prototype.toString = toString_1083;
|
|
closure3.prototype.toString = toString_1084;
|
|
closure4.prototype.toString = closure3.prototype.toString;
|
|
prototype = closure4.prototype;
|
|
const prototype82 = closure2.prototype;
|
|
const prototype83 = closure3.prototype;
|
|
const closure12 = function() {
|
|
return this.toString();
|
|
};
|
|
prototype83.toJSON = closure12;
|
|
prototype82.toJSON = closure12;
|
|
prototype.toJSON = closure12;
|
|
closure2.prototype.valueOf = function() {
|
|
return global.parseInt(this.toString(), 10);
|
|
};
|
|
closure2.prototype.toJSNumber = closure2.prototype.valueOf;
|
|
closure3.prototype.valueOf = function() {
|
|
return this.value;
|
|
};
|
|
closure3.prototype.toJSNumber = closure3.prototype.valueOf;
|
|
prototype = closure4.prototype;
|
|
const prototype86 = closure4.prototype;
|
|
const closure13 = function() {
|
|
return global.parseInt(this.toString(), 10);
|
|
};
|
|
prototype86.toJSNumber = closure13;
|
|
prototype.valueOf = closure13;
|
|
let value = 0;
|
|
let r7 = value;
|
|
while (true) {
|
|
Integer2[r7] = parseValue2(r7);
|
|
if (r7 > value) {
|
|
value2 = -r7;
|
|
Integer2[value2] = parseValue2(value2);
|
|
}
|
|
value3 = typeof r7 === 'bigint' ? r7 + 1n : +r7 + 1;
|
|
if (value3 < 1000) {
|
|
r7 = value3;
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
Integer2.one = Integer2[1];
|
|
Integer2.zero = Integer2[value];
|
|
Integer2.minusOne = Integer2[-1];
|
|
Integer2.max = max2;
|
|
Integer2.min = min2;
|
|
Integer2.gcd = gcd2;
|
|
Integer2.lcm = lcm;
|
|
Integer2.isInstance = isInstance;
|
|
Integer2.randBetween = randBetween;
|
|
Integer2.fromArray = function(a0, a1, a2) {
|
|
var value = a1;
|
|
var parseBaseFromArrayBinding = parseBaseFromArray;
|
|
var parseValueBinding = parseValue;
|
|
return parseBaseFromArrayBinding(a0.map(parseValueBinding), parseValueBinding(value || 10), a2);
|
|
};
|
|
return Integer2;
|
|
function Integer(a0, a1, a2, a3) { // fn#964, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:29:182, offset: 0x00c4f198, size: 88 bytes, params: 5, frame: 18
|
|
return a0 === undefined ? Integer[0] : a1 === undefined ? parseValue(a0) : Number(a1) !== 10 || a2 ? parseBase(a0,
|
|
a1, a2, a3) : parseValue(a0);
|
|
}
|
|
|
|
function arrayToSmall(a0) { // fn#970, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:29:635, offset: 0x00c4f306, size: 137 bytes, params: 2, frame: 16
|
|
trim(a0);
|
|
const length = a0.length;
|
|
if (length < 4) {
|
|
if (compareAbs(a0, env0_1) < 0) {
|
|
if (length === 0) {
|
|
return 0;
|
|
}
|
|
if (length === 1) {
|
|
return a0[0];
|
|
}
|
|
if (length === 2) {
|
|
return a0[0] + a0[1] * 10000000;
|
|
}
|
|
return a0[0] + (a0[1] + a0[2] * 10000000) * 10000000;
|
|
}
|
|
}
|
|
return a0;
|
|
}
|
|
|
|
function addAny(a0, a1) { // fn#975, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:29:1212, offset: 0x00c4f4fe, size: 54 bytes, params: 3, frame: 14
|
|
return a0.length >= a1.length ? add_2(a0, a1) : add_2(a1, a0);
|
|
}
|
|
|
|
function subtract(a0, a1) { // fn#977, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:29:1447, offset: 0x00c4f5e2, size: 207 bytes, params: 3, frame: 23
|
|
var r4;
|
|
var r8;
|
|
var r11;
|
|
var r12;
|
|
var r5;
|
|
var r1;
|
|
var value4;
|
|
var value5;
|
|
var value6;
|
|
var value7;
|
|
var value8;
|
|
var value9;
|
|
var value10;
|
|
var value11;
|
|
var value12;
|
|
const length = a0.length;
|
|
const length2 = a1.length;
|
|
const Array = global.Array;
|
|
const array = new Array(length);
|
|
const value2 = 0;
|
|
if (value2 < length2) {
|
|
r4 = value2;
|
|
r8 = value2;
|
|
while (true) {
|
|
value4 = a0[r8] - r4;
|
|
value5 = value4 - a1[r8];
|
|
if (value5 < value2) {
|
|
value6 = value5 + 10000000;
|
|
r11 = 1;
|
|
r12 = value6;
|
|
} else {
|
|
r11 = value2;
|
|
r12 = value5;
|
|
}
|
|
array[r8] = r12;
|
|
value7 = typeof r8 === 'bigint' ? r8 + 1n : +r8 + 1;
|
|
if (value7 < length2) {
|
|
r4 = r11;
|
|
r8 = value7;
|
|
continue;
|
|
}
|
|
r5 = r11;
|
|
break;
|
|
}
|
|
} else {
|
|
r5 = value2;
|
|
}
|
|
if (length2 < length) {
|
|
r4 = length2;
|
|
loopExit5: while (true) {
|
|
value8 = a0[r4] - r5;
|
|
if (value8 < value2) {
|
|
array[r4] = value8 + 10000000;
|
|
value11 = typeof r4 === 'bigint' ? r4 + 1n : +r4 + 1;
|
|
if (value11 < length) {
|
|
r4 = value11;
|
|
continue;
|
|
}
|
|
r1 = value11;
|
|
break loopExit5;
|
|
}
|
|
value9 = typeof r4 === 'bigint' ? r4 : +r4;
|
|
value10 = typeof value9 === 'bigint' ? value9 + 1n : +value9 + 1;
|
|
array[value9] = value8;
|
|
r1 = value10;
|
|
break loopExit5;
|
|
}
|
|
} else {
|
|
r1 = length2;
|
|
}
|
|
if (r1 < length) {
|
|
while (true) {
|
|
array[r1] = a0[r1];
|
|
value12 = typeof r1 === 'bigint' ? r1 + 1n : +r1 + 1;
|
|
if (!(value12 < length)) {
|
|
break;
|
|
}
|
|
r1 = value12;
|
|
}
|
|
}
|
|
trim(array);
|
|
return array;
|
|
}
|
|
|
|
function subtractSmall(a0, a1, a2) { // fn#978, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:29:1683, offset: 0x00c4f6b1, size: 218 bytes, params: 4, frame: 22
|
|
var r0;
|
|
var r5;
|
|
var r10;
|
|
var value4;
|
|
var Math;
|
|
var value5;
|
|
var value6;
|
|
var value7;
|
|
var value8;
|
|
const length = a0.length;
|
|
const Array = global.Array;
|
|
let array = new Array(length);
|
|
const value2 = -a1;
|
|
const value3 = 0;
|
|
if (value3 < length) {
|
|
r0 = value3;
|
|
r5 = value2;
|
|
while (true) {
|
|
value4 = a0[r0] + r5;
|
|
Math = global.Math;
|
|
value5 = Math.floor(value4 / 10000000);
|
|
value6 = value4 % 10000000;
|
|
if (value6 < value3) {
|
|
value7 = value6 + 10000000;
|
|
r10 = value7;
|
|
} else {
|
|
r10 = value6;
|
|
}
|
|
array[r0] = r10;
|
|
value8 = typeof r0 === 'bigint' ? r0 + 1n : +r0 + 1;
|
|
if (value8 < length) {
|
|
r0 = value8;
|
|
r5 = value5;
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
array = arrayToSmall(array);
|
|
return typeof array === 'number' ? new SmallInteger() : new BigInteger(array, a2);
|
|
}
|
|
|
|
function multiplyLong(a0, a1) { // fn#979, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:29:1913, offset: 0x00c4f78b, size: 171 bytes, params: 3, frame: 26
|
|
var r3;
|
|
var r12;
|
|
var property;
|
|
var value3;
|
|
var value4;
|
|
var Math;
|
|
var floor;
|
|
var value5;
|
|
var value6;
|
|
var value7;
|
|
var value8;
|
|
var value9;
|
|
const length = a0.length;
|
|
const length2 = a1.length;
|
|
const array = createArray(length + length2);
|
|
const value2 = 0;
|
|
if (value2 < length) {
|
|
r3 = value2;
|
|
reducibleLoop1: while (true) {
|
|
property = a0[r3];
|
|
if (value2 < length2) {
|
|
r12 = value2;
|
|
reducibleLoop2: while (true) {
|
|
value3 = property * a1[r12];
|
|
value4 = value3 + array[r3 + r12];
|
|
Math = global.Math;
|
|
floor = Math.floor;
|
|
value5 = Reflect.apply(floor, Math, [value4 / 10000000]);
|
|
value6 = r3 + r12;
|
|
array[value6] = value4 - value5 * 10000000;
|
|
value7 = r3 + r12 + 1;
|
|
array[value7] += value5;
|
|
value8 = typeof r12 === 'bigint' ? r12 + 1n : +r12 + 1;
|
|
if (value8 < length2) {
|
|
r12 = value8;
|
|
continue reducibleLoop2;
|
|
}
|
|
break reducibleLoop2;
|
|
}
|
|
}
|
|
value9 = typeof r3 === 'bigint' ? r3 + 1n : +r3 + 1;
|
|
if (value9 < length) {
|
|
r3 = value9;
|
|
continue reducibleLoop1;
|
|
}
|
|
break reducibleLoop1;
|
|
}
|
|
}
|
|
trim(array);
|
|
return array;
|
|
}
|
|
|
|
function multiplyKaratsuba(a0, a1) { // fn#982, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:29:2365, offset: 0x00c4f917, size: 232 bytes, params: 3, frame: 23
|
|
let Math = global.Math;
|
|
let value = Math.max(a0.length, a1.length);
|
|
if (value <= 30) {
|
|
value = environment;
|
|
return multiplyLong(a0, a1);
|
|
}
|
|
Math = global.Math;
|
|
value = Math.ceil(value / 2);
|
|
const value2 = a0.slice(value);
|
|
const value3 = a0.slice(0, value);
|
|
const value4 = a1.slice(value);
|
|
const value5 = a1.slice(0, value);
|
|
const multiplyKaratsubaBinding = multiplyKaratsuba;
|
|
const value7 = multiplyKaratsubaBinding(value3, value5);
|
|
const value8 = multiplyKaratsubaBinding(value2, value4);
|
|
const addAnyBinding = addAny;
|
|
const value10 = multiplyKaratsubaBinding(addAnyBinding(value3, value2), addAnyBinding(value5, value4));
|
|
const shiftLeft_2Binding = shiftLeft_2;
|
|
const subtract_2Binding = subtract_2;
|
|
value = addAnyBinding(addAnyBinding(value7, shiftLeft_2Binding(subtract_2Binding(subtract_2Binding(value10, value7),
|
|
value8), value)), shiftLeft_2Binding(value8, 2 * value));
|
|
trim(value);
|
|
return value;
|
|
}
|
|
|
|
function multiplySmallAndArray(a0, a1, a2) { // fn#983, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:29:2730, offset: 0x00c4f9ff, size: 86 bytes, params: 4, frame: 16
|
|
const r2 = a0 < 10000000 ? multiplySmall(a1, a0) : multiplyLong(a1, smallToArray(a0));
|
|
const value = Object.create(BigInteger.prototype, {constructor: {value: BigInteger}});
|
|
const bigInteger = new BigInteger(r2, a2);
|
|
return bigInteger instanceof Object ? bigInteger : value;
|
|
}
|
|
|
|
function square(a0) { // fn#984, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:29:2848, offset: 0x00c4fa55, size: 174 bytes, params: 2, frame: 26
|
|
var r3;
|
|
var r10;
|
|
var r12;
|
|
var r11;
|
|
var property;
|
|
var value3;
|
|
var value4;
|
|
var value5;
|
|
var Math;
|
|
var floor;
|
|
var value6;
|
|
var value7;
|
|
var value8;
|
|
var value9;
|
|
const length = a0.length;
|
|
const array = createArray(length + length);
|
|
const value2 = 0;
|
|
if (value2 < length) {
|
|
r3 = value2;
|
|
reducibleLoop1: while (true) {
|
|
property = a0[r3];
|
|
value3 = value2 - property * property;
|
|
if (r3 < length) {
|
|
r10 = r3;
|
|
r12 = value3;
|
|
reducibleLoop2: while (true) {
|
|
value4 = property * a0[r10] * 2;
|
|
value5 = value4 + array[r3 + r10] + r12;
|
|
Math = global.Math;
|
|
floor = Math.floor;
|
|
value6 = Reflect.apply(floor, Math, [value5 / 10000000]);
|
|
value7 = r3 + r10;
|
|
array[value7] = value5 - value6 * 10000000;
|
|
value8 = typeof r10 === 'bigint' ? r10 + 1n : +r10 + 1;
|
|
if (value8 < length) {
|
|
r10 = value8;
|
|
r12 = value6;
|
|
continue reducibleLoop2;
|
|
}
|
|
r11 = value6;
|
|
break reducibleLoop2;
|
|
}
|
|
} else {
|
|
r11 = value3;
|
|
}
|
|
array[r3 + length] = r11;
|
|
value9 = typeof r3 === 'bigint' ? r3 + 1n : +r3 + 1;
|
|
if (value9 < length) {
|
|
r3 = value9;
|
|
continue reducibleLoop1;
|
|
}
|
|
break reducibleLoop1;
|
|
}
|
|
}
|
|
trim(array);
|
|
return array;
|
|
}
|
|
|
|
function divModAny(a0, a1) { // fn#986, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:29:3193, offset: 0x00c4fb76, size: 1802 bytes, params: 3, frame: 43
|
|
var r12;
|
|
var r7;
|
|
var r24;
|
|
var r28;
|
|
var r25;
|
|
var r29;
|
|
var r16;
|
|
var r23;
|
|
var r27;
|
|
var r30;
|
|
var r31;
|
|
var r13;
|
|
var r17;
|
|
var r15;
|
|
var r11;
|
|
var r8;
|
|
var r3;
|
|
var Math;
|
|
var value6;
|
|
var length3;
|
|
var items3;
|
|
var items2;
|
|
var unshift;
|
|
var value10;
|
|
var value11;
|
|
var value12;
|
|
var value13;
|
|
var value14;
|
|
var value15;
|
|
var ceil;
|
|
var value16;
|
|
var multiplySmallBinding;
|
|
var value17;
|
|
var value18;
|
|
var push;
|
|
var value19;
|
|
var arrayToSmallBinding;
|
|
var length4;
|
|
var array;
|
|
var value21;
|
|
var property;
|
|
var value22;
|
|
var value23;
|
|
var value24;
|
|
var value25;
|
|
var floor;
|
|
var value27;
|
|
var value28;
|
|
var value29;
|
|
var value30;
|
|
var property2;
|
|
var value31;
|
|
var value32;
|
|
var value33;
|
|
var value34;
|
|
var value35;
|
|
var value36;
|
|
var value37;
|
|
var value38;
|
|
var value39;
|
|
var value40;
|
|
var sign;
|
|
var prototype;
|
|
var bigInteger;
|
|
var value45;
|
|
var smallInteger;
|
|
var value48;
|
|
var value49;
|
|
var value50;
|
|
var value51;
|
|
var value52;
|
|
var sign4;
|
|
var value53;
|
|
var value55;
|
|
var value57;
|
|
var value58;
|
|
var value60;
|
|
var nativeBigInt;
|
|
var value62;
|
|
var value;
|
|
const value2 = parseValue(a1);
|
|
if (result) {
|
|
value = a0.value;
|
|
value /= value2.value;
|
|
prototype = NativeBigInt.prototype;
|
|
value60 = Object.create(prototype, {constructor: {value: NativeBigInt}});
|
|
nativeBigInt = new NativeBigInt();
|
|
value = nativeBigInt instanceof Object ? nativeBigInt : value60;
|
|
items3 = [value];
|
|
value = a0.value;
|
|
value %= value2.value;
|
|
prototype = NativeBigInt.prototype;
|
|
value62 = Object.create(prototype, {constructor: {value: NativeBigInt}});
|
|
nativeBigInt = new NativeBigInt();
|
|
value = nativeBigInt instanceof Object ? nativeBigInt : value62;
|
|
items3[1] = value;
|
|
return items3;
|
|
}
|
|
const value3 = a0.value;
|
|
const value4 = value2.value;
|
|
const value5 = 0;
|
|
if (value5 === value4) {
|
|
throw new global.Error('Cannot divide by zero');
|
|
}
|
|
const isSmall = a0.isSmall;
|
|
const isSmall2 = value2.isSmall;
|
|
if (isSmall) {
|
|
if (isSmall2) {
|
|
value = truncate(value3 / value4);
|
|
prototype = SmallInteger.prototype;
|
|
value57 = Object.create(prototype, {constructor: {value: SmallInteger}});
|
|
smallInteger = new SmallInteger();
|
|
value = smallInteger instanceof Object ? smallInteger : value57;
|
|
items3 = [value];
|
|
value = value3 % value4;
|
|
prototype = SmallInteger.prototype;
|
|
value58 = Object.create(prototype, {constructor: {value: SmallInteger}});
|
|
smallInteger = new SmallInteger();
|
|
value = smallInteger instanceof Object ? smallInteger : value58;
|
|
items3[1] = value;
|
|
r3 = items3;
|
|
} else {
|
|
r3 = [Integer[value5], a0];
|
|
}
|
|
return r3;
|
|
}
|
|
if (isSmall2) {
|
|
if (value4 === 1) {
|
|
return [a0, Integer[value5]];
|
|
}
|
|
if (value4 == -1) {
|
|
items3 = [a0.negate()];
|
|
items3[1] = Integer[value5];
|
|
return items3;
|
|
}
|
|
Math = global.Math;
|
|
value6 = Math.abs(value4);
|
|
if (value6 < 10000000) {
|
|
arrayToSmallBinding = arrayToSmall;
|
|
value50 = divModSmall(value3, value6);
|
|
value51 = arrayToSmallBinding(value50[value5]);
|
|
property = value50[1];
|
|
sign = a0.sign;
|
|
reducibleJoin58: while (true) {
|
|
if (sign) {
|
|
value52 = -property;
|
|
r12 = value52;
|
|
break reducibleJoin58;
|
|
}
|
|
r12 = property;
|
|
break reducibleJoin58;
|
|
}
|
|
if (typeof value51 === 'number') {
|
|
reducibleJoin62: while (true) {
|
|
if (a0.sign === value2.sign) {
|
|
r8 = value51;
|
|
break reducibleJoin62;
|
|
}
|
|
value55 = -value51;
|
|
r8 = value55;
|
|
break reducibleJoin62;
|
|
}
|
|
prototype = SmallInteger.prototype;
|
|
value = Object.create(prototype, {constructor: {value: SmallInteger}});
|
|
smallInteger = new SmallInteger();
|
|
value = smallInteger instanceof Object ? smallInteger : value;
|
|
items3 = [value];
|
|
prototype = SmallInteger.prototype;
|
|
value = Object.create(prototype, {constructor: {value: SmallInteger}});
|
|
smallInteger = new SmallInteger();
|
|
value = smallInteger instanceof Object ? smallInteger : value;
|
|
items3[1] = value;
|
|
r7 = items3;
|
|
} else {
|
|
sign = a0.sign;
|
|
sign4 = value2.sign;
|
|
prototype = BigInteger.prototype;
|
|
value53 = Object.create(prototype, {constructor: {value: BigInteger}});
|
|
bigInteger = new BigInteger(value51, sign !== sign4);
|
|
items3 = [bigInteger instanceof Object ? bigInteger : value53];
|
|
prototype = SmallInteger.prototype;
|
|
value = Object.create(prototype, {constructor: {value: SmallInteger}});
|
|
smallInteger = new SmallInteger();
|
|
value = smallInteger instanceof Object ? smallInteger : value;
|
|
items3[1] = value;
|
|
r7 = items3;
|
|
}
|
|
return r7;
|
|
}
|
|
r12 = smallToArray(value6);
|
|
} else {
|
|
r12 = value4;
|
|
}
|
|
const value8 = compareAbs(value3, r12);
|
|
const value9 = -1;
|
|
if (value9 === value8) {
|
|
return [Integer[value5], a0];
|
|
}
|
|
if (value5 === value8) {
|
|
reducibleJoin54: while (true) {
|
|
if (a0.sign !== value2.sign) {
|
|
r11 = value9;
|
|
break reducibleJoin54;
|
|
}
|
|
value49 = 1;
|
|
r11 = value49;
|
|
break reducibleJoin54;
|
|
}
|
|
return [Integer[r11], Integer[value5]];
|
|
}
|
|
let length = value3.length;
|
|
if (length + r12.length <= 200) {
|
|
length = value3.length;
|
|
length4 = r12.length;
|
|
array = createArray(r12.length);
|
|
value21 = 1;
|
|
property = r12[length4 - value21];
|
|
Math = global.Math;
|
|
value22 = Math.ceil(10000000 / (2 * property));
|
|
multiplySmallBinding = multiplySmall;
|
|
value23 = multiplySmallBinding(value3, value22);
|
|
value24 = multiplySmallBinding(r12, value22);
|
|
reducibleJoin24: while (true) {
|
|
if (value23.length <= length) {
|
|
push = value23.push;
|
|
Reflect.apply(push, value23, [value5]);
|
|
break reducibleJoin24;
|
|
}
|
|
break reducibleJoin24;
|
|
}
|
|
value24.push(value5);
|
|
property = value24[length4 - value21];
|
|
value25 = length - length4;
|
|
if (value25 >= value5) {
|
|
r16 = value25;
|
|
reducibleLoop25: while (true) {
|
|
reducibleJoin27: while (true) {
|
|
if (value23[r16 + length4] === property) {
|
|
r23 = 9999999;
|
|
break reducibleJoin27;
|
|
}
|
|
Math = global.Math;
|
|
floor = Math.floor;
|
|
value27 = value23[r16 + length4] * 10000000;
|
|
value28 = Reflect.apply(floor, Math, [(value27 + value23[r16 + length4 - value21]) / property]);
|
|
r23 = value28;
|
|
break reducibleJoin27;
|
|
}
|
|
length = value24.length;
|
|
if (value5 < length) {
|
|
r24 = value5;
|
|
r27 = value5;
|
|
r28 = value5;
|
|
reducibleLoop28: while (true) {
|
|
value29 = r28 + r23 * value24[r24];
|
|
Math = global.Math;
|
|
floor = Math.floor;
|
|
value30 = Reflect.apply(floor, Math, [value29 / 10000000]);
|
|
property2 = value23[r16 + r24];
|
|
value31 = r27 + (property2 - (value29 - value30 * 10000000));
|
|
if (value31 < value5) {
|
|
value32 = r16 + r24;
|
|
value23[value32] = value31 + 10000000;
|
|
r29 = value9;
|
|
} else {
|
|
value23[r16 + r24] = value31;
|
|
r29 = value5;
|
|
}
|
|
value33 = typeof r24 === 'bigint' ? r24 + 1n : +r24 + 1;
|
|
if (value33 < length) {
|
|
r24 = value33;
|
|
r27 = r29;
|
|
r28 = value30;
|
|
continue reducibleLoop28;
|
|
}
|
|
r25 = r29;
|
|
break reducibleLoop28;
|
|
}
|
|
} else {
|
|
r25 = value5;
|
|
}
|
|
if (value5 !== r25) {
|
|
r24 = r23;
|
|
reducibleLoop33: while (true) {
|
|
value34 = r24 - value21;
|
|
if (value5 < length) {
|
|
r29 = value5;
|
|
r30 = value5;
|
|
reducibleLoop34: while (true) {
|
|
value35 = value23[r16 + r29] - 10000000;
|
|
value36 = r30 + (value35 + value24[r29]);
|
|
if (value36 < value5) {
|
|
value37 = r16 + r29;
|
|
value23[value37] = value36 + 10000000;
|
|
r31 = value5;
|
|
} else {
|
|
value23[r16 + r29] = value36;
|
|
r31 = value21;
|
|
}
|
|
value38 = typeof r29 === 'bigint' ? r29 + 1n : +r29 + 1;
|
|
if (value38 < length) {
|
|
r29 = value38;
|
|
r30 = r31;
|
|
continue reducibleLoop34;
|
|
}
|
|
r28 = r31;
|
|
break reducibleLoop34;
|
|
}
|
|
} else {
|
|
r28 = value5;
|
|
}
|
|
value39 = r25 + r28;
|
|
if (value5 !== value39) {
|
|
r24 = value34;
|
|
r25 = value39;
|
|
continue reducibleLoop33;
|
|
}
|
|
r23 = value34;
|
|
break reducibleLoop33;
|
|
}
|
|
}
|
|
array[r16] = r23;
|
|
value40 = typeof r16 === 'bigint' ? r16 - 1n : +r16 - 1;
|
|
if (value40 >= value5) {
|
|
r16 = value40;
|
|
continue reducibleLoop25;
|
|
}
|
|
break reducibleLoop25;
|
|
}
|
|
}
|
|
property = divModSmall(value23, value22)[value5];
|
|
arrayToSmallBinding = arrayToSmall;
|
|
r13 = [arrayToSmallBinding(array), arrayToSmallBinding(property)];
|
|
} else {
|
|
length = value3.length;
|
|
length3 = r12.length;
|
|
items3 = [];
|
|
items2 = [];
|
|
if (length) {
|
|
r7 = items2;
|
|
r24 = length;
|
|
reducibleLoop12: while (true) {
|
|
unshift = r7.unshift;
|
|
value10 = typeof r24 === 'bigint' ? r24 - 1n : +r24 - 1;
|
|
Reflect.apply(unshift, r7, [value3[value10]]);
|
|
trim(r7);
|
|
compareAbsBinding = compareAbs;
|
|
if (compareAbsBinding(r7, r12) < value5) {
|
|
push = items3.push;
|
|
Reflect.apply(push, items3, [value5]);
|
|
r25 = r7;
|
|
} else {
|
|
length = r7.length;
|
|
value11 = r7[length - 1] * 10000000;
|
|
value12 = value11 + r7[length - 2];
|
|
value13 = r12[length3 - 1] * 10000000;
|
|
value14 = value13 + r12[length3 - 2];
|
|
reducibleJoin15: while (true) {
|
|
if (length > length3) {
|
|
value15 = (value12 + 1) * 10000000;
|
|
r28 = value15;
|
|
break reducibleJoin15;
|
|
}
|
|
r28 = value12;
|
|
break reducibleJoin15;
|
|
}
|
|
Math = global.Math;
|
|
ceil = Math.ceil;
|
|
value16 = Reflect.apply(ceil, Math, [r28 / value14]);
|
|
r25 = value16;
|
|
reducibleLoop16: while (true) {
|
|
compareAbsBinding = compareAbs;
|
|
value17 = multiplySmall(r12, r25);
|
|
if (compareAbsBinding(value17, r7) <= value5) {
|
|
r29 = r25;
|
|
break reducibleLoop16;
|
|
}
|
|
value18 = typeof r25 === 'bigint' ? r25 - 1n : +r25 - 1;
|
|
if (value18) {
|
|
r25 = value18;
|
|
continue reducibleLoop16;
|
|
}
|
|
r29 = value18;
|
|
break reducibleLoop16;
|
|
}
|
|
push = items3.push;
|
|
Reflect.apply(push, items3, [r29]);
|
|
value19 = subtract_2(r7, value17);
|
|
r25 = value19;
|
|
}
|
|
if (value10) {
|
|
r7 = r25;
|
|
r24 = value10;
|
|
continue reducibleLoop12;
|
|
}
|
|
r12 = r25;
|
|
break reducibleLoop12;
|
|
}
|
|
} else {
|
|
r12 = items2;
|
|
}
|
|
items3.reverse();
|
|
arrayToSmallBinding = arrayToSmall;
|
|
items3 = [arrayToSmallBinding(items3), arrayToSmallBinding(r12)];
|
|
r13 = items3;
|
|
}
|
|
property = r13[value5];
|
|
const value42 = a0.sign !== value2.sign;
|
|
const property3 = r13[1];
|
|
sign = a0.sign;
|
|
if (typeof property === 'number') {
|
|
reducibleJoin45: while (true) {
|
|
if (value42) {
|
|
value45 = -property;
|
|
r17 = value45;
|
|
break reducibleJoin45;
|
|
}
|
|
r17 = property;
|
|
break reducibleJoin45;
|
|
}
|
|
smallInteger = new SmallInteger();
|
|
} else {
|
|
bigInteger = new BigInteger(property, value42);
|
|
}
|
|
if (typeof property3 === 'number') {
|
|
reducibleJoin50: while (true) {
|
|
if (sign) {
|
|
value48 = -property3;
|
|
r15 = value48;
|
|
break reducibleJoin50;
|
|
}
|
|
r15 = property3;
|
|
break reducibleJoin50;
|
|
}
|
|
r12 = new SmallInteger();
|
|
} else {
|
|
r12 = new BigInteger(property3);
|
|
}
|
|
return [r13, r12];
|
|
}
|
|
|
|
function millerRabinTest(a0, a1) { // fn#989, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:29:5468, offset: 0x00c503a3, size: 299 bytes, params: 3, frame: 26
|
|
var r1;
|
|
var r2;
|
|
var r7;
|
|
var r8;
|
|
var r0;
|
|
var r14;
|
|
var divide;
|
|
var value3;
|
|
var value4;
|
|
var lesser;
|
|
var binding;
|
|
var value6;
|
|
var modPow;
|
|
var value7;
|
|
var isUnit;
|
|
var equals;
|
|
var value8;
|
|
var square;
|
|
var value9;
|
|
var mod;
|
|
var value10;
|
|
var value11;
|
|
var value12;
|
|
const value = a0.prev();
|
|
const isEven2 = value.isEven();
|
|
const value2 = 0;
|
|
if (isEven2) {
|
|
r1 = value2;
|
|
r2 = value;
|
|
reducibleLoop1: while (true) {
|
|
divide = r2.divide;
|
|
value3 = Reflect.apply(divide, r2, [2]);
|
|
value4 = typeof r1 === 'bigint' ? r1 + 1n : +r1 + 1;
|
|
if (value3.isEven()) {
|
|
r1 = value4;
|
|
r2 = value3;
|
|
continue reducibleLoop1;
|
|
}
|
|
r7 = value4;
|
|
r8 = value3;
|
|
break reducibleLoop1;
|
|
}
|
|
} else {
|
|
r7 = value2;
|
|
r8 = value;
|
|
}
|
|
let length = a1.length;
|
|
if (value2 < length) {
|
|
r2 = value2;
|
|
reducibleLoop3: while (true) {
|
|
lesser = a0.lesser;
|
|
if (!Reflect.apply(lesser, a0, [a1[r2]])) {
|
|
binding = env1_0;
|
|
value6 = binding(a1[r2]);
|
|
modPow = value6.modPow;
|
|
value7 = Reflect.apply(modPow, value6, [r8, a0]);
|
|
isUnit = value7.isUnit;
|
|
reducibleJoin12: while (true) {
|
|
if (Reflect.apply(isUnit, value7, [])) {
|
|
break reducibleJoin12;
|
|
}
|
|
equals = value7.equals;
|
|
if (Reflect.apply(equals, value7, [value])) {
|
|
break reducibleJoin12;
|
|
}
|
|
value8 = r7 - 1;
|
|
if (value2 === value8) {
|
|
return false;
|
|
}
|
|
r0 = value7;
|
|
r14 = value8;
|
|
reducibleLoop7: while (true) {
|
|
square = r0.square;
|
|
value9 = Reflect.apply(square, r0, []);
|
|
mod = value9.mod;
|
|
value10 = Reflect.apply(mod, value9, [a0]);
|
|
isUnit = value10.isUnit;
|
|
if (Reflect.apply(isUnit, value10, [])) {
|
|
return false;
|
|
}
|
|
equals = value10.equals;
|
|
if (Reflect.apply(equals, value10, [value])) {
|
|
break reducibleJoin12;
|
|
}
|
|
value11 = typeof r14 === 'bigint' ? r14 - 1n : +r14 - 1;
|
|
if (value2 == value11) {
|
|
return false;
|
|
}
|
|
r0 = value10;
|
|
r14 = value11;
|
|
continue reducibleLoop7;
|
|
}
|
|
value12 = typeof r2 === 'bigint' ? r2 + 1n : +r2 + 1;
|
|
length = a1.length;
|
|
if (!(value12 < length)) {
|
|
return true;
|
|
}
|
|
r2 = value12;
|
|
continue reducibleLoop3;
|
|
}
|
|
}
|
|
value12 = typeof r2 === 'bigint' ? r2 + 1n : +r2 + 1;
|
|
length = a1.length;
|
|
if (!(value12 < length)) {
|
|
return true;
|
|
}
|
|
r2 = value12;
|
|
continue reducibleLoop3;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
function bitwise(a0, a1, a2) { // fn#991, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:29:18014, offset: 0x00c504f0, size: 416 bytes, params: 4, frame: 25
|
|
var r12;
|
|
var r11;
|
|
var r9;
|
|
var r10;
|
|
var r14;
|
|
var r1;
|
|
var r3;
|
|
var not;
|
|
var property;
|
|
var toJSNumber;
|
|
var value6;
|
|
var value7;
|
|
var value8;
|
|
var value9;
|
|
var value10;
|
|
var property2;
|
|
var push;
|
|
var multiply;
|
|
var add;
|
|
var binding;
|
|
var value12;
|
|
let value = a0;
|
|
const value3 = parseValue(a1);
|
|
const isNegative2 = value.isNegative();
|
|
const isNegative3 = value3.isNegative();
|
|
reducibleJoin2: while (true) {
|
|
if (isNegative2) {
|
|
not = value.not;
|
|
value = Reflect.apply(not, value, []);
|
|
r12 = value;
|
|
break reducibleJoin2;
|
|
}
|
|
r12 = value;
|
|
break reducibleJoin2;
|
|
}
|
|
reducibleJoin4: while (true) {
|
|
if (isNegative3) {
|
|
not = value3.not;
|
|
value = Reflect.apply(not, value3, []);
|
|
r11 = value;
|
|
break reducibleJoin4;
|
|
}
|
|
r11 = value3;
|
|
break reducibleJoin4;
|
|
}
|
|
const items2 = [];
|
|
value = r12.isZero();
|
|
const value4 = 0;
|
|
const value5 = 1;
|
|
if (value) {
|
|
isZero = r11.isZero;
|
|
if (!Reflect.apply(isZero, r11, [])) {
|
|
r9 = r11;
|
|
r10 = r12;
|
|
reducibleLoop6: while (true) {
|
|
value = divModAny(r10, env0_6);
|
|
property = value[value5];
|
|
toJSNumber = property.toJSNumber;
|
|
value6 = Reflect.apply(toJSNumber, property, []);
|
|
reducibleJoin8: while (true) {
|
|
if (isNegative2) {
|
|
value7 = env0_6 - value5 - value6;
|
|
r14 = value7;
|
|
break reducibleJoin8;
|
|
}
|
|
r14 = value6;
|
|
break reducibleJoin8;
|
|
}
|
|
value8 = divModAny(r9, env0_6);
|
|
property = value8[value5];
|
|
toJSNumber = property.toJSNumber;
|
|
value9 = Reflect.apply(toJSNumber, property, []);
|
|
reducibleJoin10: while (true) {
|
|
if (isNegative3) {
|
|
value10 = env0_6 - value5 - value9;
|
|
r1 = value10;
|
|
break reducibleJoin10;
|
|
}
|
|
r1 = value9;
|
|
break reducibleJoin10;
|
|
}
|
|
property = value[value4];
|
|
property2 = value8[value4];
|
|
push = items2.push;
|
|
Reflect.apply(push, items2, [a2(r14, r1)]);
|
|
isZero = property.isZero;
|
|
reducibleJoin11: while (true) {
|
|
if (Reflect.apply(isZero, property, [])) {
|
|
break reducibleJoin11;
|
|
}
|
|
r9 = property2;
|
|
r10 = property;
|
|
continue reducibleLoop6;
|
|
}
|
|
isZero = property2.isZero;
|
|
if (Reflect.apply(isZero, property2, [])) {
|
|
break reducibleLoop6;
|
|
}
|
|
r9 = property2;
|
|
r10 = property;
|
|
continue reducibleLoop6;
|
|
}
|
|
}
|
|
} else {
|
|
r9 = r11;
|
|
r10 = r12;
|
|
reducibleLoop6: while (true) {
|
|
value = divModAny(r10, env0_6);
|
|
property = value[value5];
|
|
toJSNumber = property.toJSNumber;
|
|
value6 = Reflect.apply(toJSNumber, property, []);
|
|
reducibleJoin8: while (true) {
|
|
if (isNegative2) {
|
|
value7 = env0_6 - value5 - value6;
|
|
r14 = value7;
|
|
break reducibleJoin8;
|
|
}
|
|
r14 = value6;
|
|
break reducibleJoin8;
|
|
}
|
|
value8 = divModAny(r9, env0_6);
|
|
property = value8[value5];
|
|
toJSNumber = property.toJSNumber;
|
|
value9 = Reflect.apply(toJSNumber, property, []);
|
|
reducibleJoin10: while (true) {
|
|
if (isNegative3) {
|
|
value10 = env0_6 - value5 - value9;
|
|
r1 = value10;
|
|
break reducibleJoin10;
|
|
}
|
|
r1 = value9;
|
|
break reducibleJoin10;
|
|
}
|
|
property = value[value4];
|
|
property2 = value8[value4];
|
|
push = items2.push;
|
|
Reflect.apply(push, items2, [a2(r14, r1)]);
|
|
isZero = property.isZero;
|
|
reducibleJoin11: while (true) {
|
|
if (Reflect.apply(isZero, property, [])) {
|
|
break reducibleJoin11;
|
|
}
|
|
r9 = property2;
|
|
r10 = property;
|
|
continue reducibleLoop6;
|
|
}
|
|
isZero = property2.isZero;
|
|
if (Reflect.apply(isZero, property2, [])) {
|
|
break reducibleLoop6;
|
|
}
|
|
r9 = property2;
|
|
r10 = property;
|
|
continue reducibleLoop6;
|
|
}
|
|
}
|
|
r1 = isNegative2 ? value5 : value4;
|
|
let r0 = isNegative3 ? value5 : value4;
|
|
if (value4 !== a2(r1, r0)) {
|
|
value = environment.__proto__;
|
|
value = env1_0(-1);
|
|
r0 = value;
|
|
} else {
|
|
value = environment.__proto__;
|
|
value = env1_0(value4);
|
|
r0 = value;
|
|
}
|
|
value = items2.length - value5;
|
|
if (value >= value4) {
|
|
r1 = r0;
|
|
r3 = value;
|
|
reducibleLoop18: while (true) {
|
|
multiply = r1.multiply;
|
|
value = Reflect.apply(multiply, r1, [env0_6]);
|
|
add = value.add;
|
|
binding = env1_0;
|
|
value = Reflect.apply(add, value, [binding(items2[r3])]);
|
|
value12 = r3 - value5;
|
|
if (value12 >= value4) {
|
|
r1 = value;
|
|
r3 = value12;
|
|
continue reducibleLoop18;
|
|
}
|
|
r0 = value;
|
|
break reducibleLoop18;
|
|
}
|
|
}
|
|
return r0;
|
|
}
|
|
|
|
function roughLOB({value}) { // fn#992, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:29:19932, offset: 0x00c50690, size: 114 bytes, params: 2, frame: 13
|
|
var r1;
|
|
const value2 = typeof value;
|
|
if (value2 === 'number') {
|
|
value |= env0_7;
|
|
r1 = value;
|
|
} else if (value2 === 'bigint') {
|
|
value |= global.BigInt(env0_7);
|
|
r1 = value;
|
|
} else {
|
|
value = value[0] + value[1] * 10000000 | 1073758208;
|
|
r1 = value;
|
|
}
|
|
return r1 & -r1;
|
|
}
|
|
|
|
function integerLogarithm(a0, a1) { // fn#993, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:29:20058, offset: 0x00c50702, size: 162 bytes, params: 3, frame: 16
|
|
var integerLogarithmBinding;
|
|
var p;
|
|
var e;
|
|
let value = a1.compareTo(a0);
|
|
if (value <= 0) {
|
|
integerLogarithmBinding = integerLogarithm;
|
|
value = a1.square(a1);
|
|
value = integerLogarithmBinding(a0, value);
|
|
p = value.p;
|
|
e = value.e;
|
|
value = p.multiply(a1);
|
|
return value.compareTo(a0) <= 0 ? {p: value, e: 2 * e + 1} : {p: p, e: 2 * e};
|
|
}
|
|
const object = {};
|
|
value = environment.__proto__;
|
|
object.p = env1_0(1);
|
|
object.e = 0;
|
|
return object;
|
|
}
|
|
|
|
function max(a0, a1) { // fn#994, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:29:20247, offset: 0x00c507a4, size: 44 bytes, params: 3, frame: 12
|
|
const parseValueBinding = parseValue;
|
|
const valueBinding = parseValueBinding(a0);
|
|
const valueBinding2 = parseValueBinding(a1);
|
|
return valueBinding.greater(valueBinding2) ? valueBinding : valueBinding2;
|
|
}
|
|
|
|
function min(a0, a1) { // fn#995, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:29:20321, offset: 0x00c507d0, size: 44 bytes, params: 3, frame: 12
|
|
const parseValueBinding = parseValue;
|
|
const valueBinding = parseValueBinding(a0);
|
|
const valueBinding2 = parseValueBinding(a1);
|
|
return valueBinding.lesser(valueBinding2) ? valueBinding : valueBinding2;
|
|
}
|
|
|
|
function gcd(a0, a1) { // fn#996, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:29:20394, offset: 0x00c507fc, size: 484 bytes, params: 3, frame: 23
|
|
var r4;
|
|
var r6;
|
|
var r10;
|
|
var r3;
|
|
var r5;
|
|
var r9;
|
|
var r2;
|
|
var minBinding;
|
|
var roughLOBBinding;
|
|
var value6;
|
|
var value7;
|
|
var divide;
|
|
var value8;
|
|
var value9;
|
|
var multiply;
|
|
var value10;
|
|
var value11;
|
|
var value12;
|
|
var greater;
|
|
var subtract;
|
|
var value13;
|
|
let value = environment;
|
|
const parseValueBinding = parseValue;
|
|
const value3 = parseValueBinding(a0).abs();
|
|
const value5 = parseValueBinding(a1).abs();
|
|
if (value3.equals(value5)) {
|
|
return value3;
|
|
}
|
|
let isZero = value3.isZero;
|
|
if (Reflect.apply(isZero, value3, [])) {
|
|
return value5;
|
|
}
|
|
if (value5.isZero()) {
|
|
return value3;
|
|
}
|
|
const property = Integer[1];
|
|
let isEven = value3.isEven;
|
|
reducibleJoin7: while (true) {
|
|
if (!Reflect.apply(isEven, value3, [])) {
|
|
r3 = value3;
|
|
r5 = property;
|
|
r9 = value5;
|
|
break reducibleJoin7;
|
|
}
|
|
isEven = value5.isEven;
|
|
if (!Reflect.apply(isEven, value5, [])) {
|
|
r3 = value3;
|
|
r5 = property;
|
|
r9 = value5;
|
|
break reducibleJoin7;
|
|
}
|
|
r4 = property;
|
|
r6 = value5;
|
|
r10 = value3;
|
|
reducibleLoop5: while (true) {
|
|
minBinding = min;
|
|
roughLOBBinding = roughLOB;
|
|
value6 = roughLOBBinding(r10);
|
|
value7 = minBinding(value6, roughLOBBinding(r6));
|
|
divide = r10.divide;
|
|
value8 = Reflect.apply(divide, r10, [value7]);
|
|
divide = r6.divide;
|
|
value9 = Reflect.apply(divide, r6, [value7]);
|
|
multiply = r4.multiply;
|
|
value10 = Reflect.apply(multiply, r4, [value7]);
|
|
isEven = value8.isEven;
|
|
if (Reflect.apply(isEven, value8, [])) {
|
|
isEven = value9.isEven;
|
|
if (Reflect.apply(isEven, value9, [])) {
|
|
r4 = value10;
|
|
r6 = value9;
|
|
r10 = value8;
|
|
continue reducibleLoop5;
|
|
}
|
|
r3 = value8;
|
|
r5 = value10;
|
|
r9 = value9;
|
|
break reducibleJoin7;
|
|
}
|
|
r3 = value8;
|
|
r5 = value10;
|
|
r9 = value9;
|
|
break reducibleJoin7;
|
|
}
|
|
}
|
|
isEven = r3.isEven;
|
|
if (Reflect.apply(isEven, r3, [])) {
|
|
r4 = r3;
|
|
reducibleLoop8: while (true) {
|
|
divide = r4.divide;
|
|
value11 = Reflect.apply(divide, r4, [roughLOB(r4)]);
|
|
isEven = value11.isEven;
|
|
if (Reflect.apply(isEven, value11, [])) {
|
|
r4 = value11;
|
|
continue reducibleLoop8;
|
|
}
|
|
r3 = r9;
|
|
r6 = value11;
|
|
break reducibleLoop8;
|
|
}
|
|
} else {
|
|
r6 = r3;
|
|
r3 = r9;
|
|
}
|
|
reducibleLoop9: while (true) {
|
|
isEven = r3.isEven;
|
|
if (Reflect.apply(isEven, r3, [])) {
|
|
r9 = r3;
|
|
reducibleLoop10: while (true) {
|
|
divide = r9.divide;
|
|
value12 = Reflect.apply(divide, r9, [roughLOB(r9)]);
|
|
isEven = value12.isEven;
|
|
if (Reflect.apply(isEven, value12, [])) {
|
|
r9 = value12;
|
|
continue reducibleLoop10;
|
|
}
|
|
r2 = value12;
|
|
break reducibleLoop10;
|
|
}
|
|
} else {
|
|
r2 = r3;
|
|
}
|
|
greater = r6.greater;
|
|
if (Reflect.apply(greater, r6, [r2])) {
|
|
r4 = r2;
|
|
r9 = r6;
|
|
} else {
|
|
r4 = r6;
|
|
r9 = r2;
|
|
}
|
|
subtract = r9.subtract;
|
|
value13 = Reflect.apply(subtract, r9, [r4]);
|
|
isZero = value13.isZero;
|
|
if (Reflect.apply(isZero, value13, [])) {
|
|
break reducibleLoop9;
|
|
}
|
|
r3 = value13;
|
|
r6 = r4;
|
|
continue reducibleLoop9;
|
|
}
|
|
reducibleJoin15: while (true) {
|
|
if (r5.isUnit()) {
|
|
r2 = r4;
|
|
break reducibleJoin15;
|
|
}
|
|
multiply = r4.multiply;
|
|
value = Reflect.apply(multiply, r4, [r5]);
|
|
r2 = value;
|
|
break reducibleJoin15;
|
|
}
|
|
return r2;
|
|
}
|
|
|
|
function parseBaseFromArray(a0, a1, a2) { // fn#997, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:29:21703, offset: 0x00c509e0, size: 112 bytes, params: 4, frame: 18
|
|
var r0;
|
|
var r1;
|
|
var r3;
|
|
var r2;
|
|
var add;
|
|
var times;
|
|
var value2;
|
|
var value3;
|
|
var negate;
|
|
let property = Integer[0];
|
|
const property2 = Integer[1];
|
|
let value = a0.length - 1;
|
|
if (value >= 0) {
|
|
r0 = property;
|
|
r1 = value;
|
|
r3 = property2;
|
|
reducibleLoop1: while (true) {
|
|
add = r0.add;
|
|
property = a0[r1];
|
|
times = property.times;
|
|
value = Reflect.apply(add, r0, [Reflect.apply(times, property, [r3])]);
|
|
times = r3.times;
|
|
value2 = Reflect.apply(times, r3, [a1]);
|
|
value3 = typeof r1 === 'bigint' ? r1 - 1n : +r1 - 1;
|
|
if (value3 >= 0) {
|
|
r0 = value;
|
|
r1 = value3;
|
|
r3 = value2;
|
|
continue reducibleLoop1;
|
|
}
|
|
r2 = value;
|
|
break reducibleLoop1;
|
|
}
|
|
} else {
|
|
r2 = property;
|
|
}
|
|
reducibleJoin4: while (true) {
|
|
if (a2) {
|
|
negate = r2.negate;
|
|
value = Reflect.apply(negate, r2, []);
|
|
r0 = value;
|
|
break reducibleJoin4;
|
|
}
|
|
r0 = r2;
|
|
break reducibleJoin4;
|
|
}
|
|
return r0;
|
|
}
|
|
|
|
function toBase(a0, a1) { // fn#998, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:29:21854, offset: 0x00c50a50, size: 869 bytes, params: 3, frame: 23
|
|
var r2;
|
|
var r0;
|
|
var r10;
|
|
var r7;
|
|
var r4;
|
|
var r12;
|
|
var r6;
|
|
var isPositive;
|
|
var isPositive2;
|
|
var abs;
|
|
var value5;
|
|
var object;
|
|
var compareAbs;
|
|
var divmod;
|
|
var quotient;
|
|
var remainder;
|
|
var minus;
|
|
var next;
|
|
var value6;
|
|
var push;
|
|
var toJSNumber;
|
|
var Array;
|
|
var apply;
|
|
var map;
|
|
var Array3;
|
|
var concat;
|
|
var apply2;
|
|
let value = a0;
|
|
const value3 = env1_0(a1);
|
|
if (value3.isZero()) {
|
|
if (value.isZero()) {
|
|
return {value: [0], isNegative: false};
|
|
}
|
|
throw new global.Error('Cannot convert nonzero numbers to base 0.');
|
|
}
|
|
if (value3.equals(-1)) {
|
|
if (value.isZero()) {
|
|
return {value: [0], isNegative: false};
|
|
}
|
|
if (value.isNegative()) {
|
|
concat = [].concat;
|
|
apply = concat.apply;
|
|
Array = global.Array;
|
|
apply2 = Array.apply;
|
|
value = global.Array(-value.toJSNumber());
|
|
value = Reflect.apply(apply2, Array, [null, value]);
|
|
map = value.map;
|
|
Array = global.Array;
|
|
value = Reflect.apply(map, value, [Array.prototype.valueOf, [1, 0]]);
|
|
return {value: Reflect.apply(apply, concat, [[], value]), isNegative: false};
|
|
}
|
|
Array = global.Array;
|
|
apply = Array.apply;
|
|
Array3 = global.Array;
|
|
value = value.toJSNumber();
|
|
value = Array3(value - 1);
|
|
value = Reflect.apply(apply, Array, [null, value]);
|
|
map = value.map;
|
|
Array = global.Array;
|
|
value = Reflect.apply(map, value, [Array.prototype.valueOf, [0, 1]]);
|
|
value.unshift([1]);
|
|
object = {};
|
|
concat = [].concat;
|
|
object.value = concat.apply([], value);
|
|
object.isNegative = false;
|
|
return object;
|
|
}
|
|
const isNegative2 = value.isNegative();
|
|
reducibleJoin4: while (true) {
|
|
if (isNegative2) {
|
|
isPositive = value3.isPositive;
|
|
isPositive2 = Reflect.apply(isPositive, value3, []);
|
|
r2 = isPositive2;
|
|
break reducibleJoin4;
|
|
}
|
|
r2 = isNegative2;
|
|
break reducibleJoin4;
|
|
}
|
|
const value4 = false;
|
|
reducibleJoin6: while (true) {
|
|
if (r2) {
|
|
abs = value.abs;
|
|
value = Reflect.apply(abs, value, []);
|
|
value5 = true;
|
|
r0 = value5;
|
|
r10 = value;
|
|
break reducibleJoin6;
|
|
}
|
|
r0 = value4;
|
|
r10 = value;
|
|
break reducibleJoin6;
|
|
}
|
|
if (value3.isUnit()) {
|
|
value = r10.isZero();
|
|
object = {};
|
|
if (value) {
|
|
object.value = [0];
|
|
object.isNegative = value4;
|
|
} else {
|
|
Array = global.Array;
|
|
apply = Array.apply;
|
|
value = global.Array(r10.toJSNumber());
|
|
value = Reflect.apply(apply, Array, [null, value]);
|
|
object.value = value.map(global.Number.prototype.valueOf, 1);
|
|
object.isNegative = r0;
|
|
}
|
|
return object;
|
|
}
|
|
object = [];
|
|
let isNegative = r10.isNegative;
|
|
if (Reflect.apply(isNegative, r10, [])) {
|
|
r7 = r10;
|
|
reducibleLoop9: while (true) {
|
|
divmod = r7.divmod;
|
|
value = Reflect.apply(divmod, r7, [value3]);
|
|
quotient = value.quotient;
|
|
remainder = value.remainder;
|
|
isNegative = remainder.isNegative;
|
|
reducibleJoin11: while (true) {
|
|
if (Reflect.apply(isNegative, remainder, [])) {
|
|
minus = value3.minus;
|
|
value = Reflect.apply(minus, value3, [remainder]);
|
|
abs = value.abs;
|
|
value = Reflect.apply(abs, value, []);
|
|
next = quotient.next;
|
|
value6 = Reflect.apply(next, quotient, []);
|
|
r4 = value6;
|
|
r12 = value;
|
|
break reducibleJoin11;
|
|
}
|
|
r4 = quotient;
|
|
r12 = remainder;
|
|
break reducibleJoin11;
|
|
}
|
|
push = object.push;
|
|
toJSNumber = r12.toJSNumber;
|
|
Reflect.apply(push, object, [Reflect.apply(toJSNumber, r12, [])]);
|
|
isNegative = r4.isNegative;
|
|
reducibleJoin12: while (true) {
|
|
if (Reflect.apply(isNegative, r4, [])) {
|
|
r7 = r4;
|
|
continue reducibleLoop9;
|
|
}
|
|
break reducibleJoin12;
|
|
}
|
|
compareAbs = r4.compareAbs;
|
|
value = Reflect.apply(compareAbs, r4, [value3]);
|
|
if (value >= 0) {
|
|
r7 = r4;
|
|
continue reducibleLoop9;
|
|
}
|
|
r6 = r4;
|
|
break reducibleLoop9;
|
|
}
|
|
} else {
|
|
value = r10.compareAbs(value3);
|
|
if (value >= 0) {
|
|
r7 = r10;
|
|
reducibleLoop9: while (true) {
|
|
divmod = r7.divmod;
|
|
value = Reflect.apply(divmod, r7, [value3]);
|
|
quotient = value.quotient;
|
|
remainder = value.remainder;
|
|
isNegative = remainder.isNegative;
|
|
reducibleJoin11: while (true) {
|
|
if (Reflect.apply(isNegative, remainder, [])) {
|
|
minus = value3.minus;
|
|
value = Reflect.apply(minus, value3, [remainder]);
|
|
abs = value.abs;
|
|
value = Reflect.apply(abs, value, []);
|
|
next = quotient.next;
|
|
value6 = Reflect.apply(next, quotient, []);
|
|
r4 = value6;
|
|
r12 = value;
|
|
break reducibleJoin11;
|
|
}
|
|
r4 = quotient;
|
|
r12 = remainder;
|
|
break reducibleJoin11;
|
|
}
|
|
push = object.push;
|
|
toJSNumber = r12.toJSNumber;
|
|
Reflect.apply(push, object, [Reflect.apply(toJSNumber, r12, [])]);
|
|
isNegative = r4.isNegative;
|
|
reducibleJoin12: while (true) {
|
|
if (Reflect.apply(isNegative, r4, [])) {
|
|
r7 = r4;
|
|
continue reducibleLoop9;
|
|
}
|
|
break reducibleJoin12;
|
|
}
|
|
compareAbs = r4.compareAbs;
|
|
value = Reflect.apply(compareAbs, r4, [value3]);
|
|
if (value >= 0) {
|
|
r7 = r4;
|
|
continue reducibleLoop9;
|
|
}
|
|
r6 = r4;
|
|
break reducibleLoop9;
|
|
}
|
|
} else {
|
|
r6 = r10;
|
|
}
|
|
}
|
|
object.push(r6.toJSNumber());
|
|
const object2 = {};
|
|
object2.value = object.reverse();
|
|
object2.isNegative = r0;
|
|
return object2;
|
|
}
|
|
|
|
function toBaseString(a0, a1, a2) { // fn#999, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:29:22802, offset: 0x00c50db5, size: 86 bytes, params: 4, frame: 14
|
|
const env0_0 = a2;
|
|
var value;
|
|
const isNegative = toBase(a0, a1).isNegative;
|
|
const value2 = '';
|
|
const r1 = isNegative ? '-' : value2;
|
|
value = value.value;
|
|
value = value.map(_fun1000);
|
|
return r1 + value.join(value2);
|
|
function _fun1000(a0) { // fn#1000, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:29:22890, offset: 0x00c50e0b, size: 53 bytes, params: 2, frame: 4
|
|
const r1 = importDefault || env1_2;
|
|
return a0 < r1.length ? r1[a0] : '<' + a0 + '>';
|
|
}
|
|
|
|
}
|
|
|
|
function parseStringValue(a0) { // fn#1001, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:29:22991, offset: 0x00c50e40, size: 815 bytes, params: 2, frame: 26
|
|
var r2;
|
|
var r0;
|
|
var r5;
|
|
var r11;
|
|
var slice;
|
|
var property;
|
|
var value5;
|
|
var value6;
|
|
var indexOf;
|
|
var value7;
|
|
var value8;
|
|
var Array;
|
|
var prototype;
|
|
var value9;
|
|
var array;
|
|
var join;
|
|
var Error;
|
|
var error;
|
|
var items2;
|
|
var push;
|
|
var bigInteger;
|
|
var BigInt;
|
|
var value11;
|
|
var nativeBigInt;
|
|
var value12;
|
|
var value14;
|
|
let value = a0;
|
|
if (isPrecise(Number(value))) {
|
|
value14 = Number(value);
|
|
if (value14 === truncate(value14)) {
|
|
return result ? new NativeBigInt(global.BigInt(value14)) : new SmallInteger();
|
|
}
|
|
Error = global.Error;
|
|
value = 'Invalid integer: ' + value;
|
|
throw new Error(value);
|
|
}
|
|
const value3 = 0;
|
|
const value4 = value[value3] === '-';
|
|
reducibleJoin3: while (true) {
|
|
if (value4) {
|
|
slice = value.slice;
|
|
value = Reflect.apply(slice, value, [1]);
|
|
r2 = value;
|
|
break reducibleJoin3;
|
|
}
|
|
r2 = value;
|
|
break reducibleJoin3;
|
|
}
|
|
let length = r2.split(RegExp('e', 'i')).length;
|
|
if (length > 2) {
|
|
Error = global.Error;
|
|
value = value.join('e');
|
|
value = 'Invalid integer: ' + value;
|
|
throw new Error(value);
|
|
}
|
|
length = value.length;
|
|
if (length === 2) {
|
|
property = value[1];
|
|
reducibleJoin7: while (true) {
|
|
if (property[value3] !== '+') {
|
|
r0 = property;
|
|
break reducibleJoin7;
|
|
}
|
|
slice = property.slice;
|
|
value5 = Reflect.apply(slice, property, [1]);
|
|
r0 = value5;
|
|
break reducibleJoin7;
|
|
}
|
|
value6 = Number(r0);
|
|
reducibleJoin13: while (true) {
|
|
reducibleJoin24: while (true) {
|
|
if (value6 !== truncate(value6)) {
|
|
break reducibleJoin24;
|
|
}
|
|
if (isPrecise(value6)) {
|
|
property = value[value3];
|
|
indexOf = property.indexOf;
|
|
value = Reflect.apply(indexOf, property, ['.']);
|
|
reducibleJoin11: while (true) {
|
|
if (value >= value3) {
|
|
length = property.length;
|
|
value7 = value6 - (length - value - 1);
|
|
slice = property.slice;
|
|
value8 = Reflect.apply(slice, property, [value3, value]);
|
|
slice = property.slice;
|
|
value = value8 + Reflect.apply(slice, property, [value + 1]);
|
|
r0 = value7;
|
|
r5 = value;
|
|
break reducibleJoin11;
|
|
}
|
|
r0 = value6;
|
|
r5 = property;
|
|
break reducibleJoin11;
|
|
}
|
|
if (r0 < value3) {
|
|
throw new global.Error('Cannot include negative exponent part for integers');
|
|
}
|
|
Array = global.Array;
|
|
prototype = Array.prototype;
|
|
value = Object.create(prototype, {constructor: {value: Array}});
|
|
value9 = r0 + 1;
|
|
array = new Array();
|
|
value = array instanceof Object ? array : value;
|
|
join = value.join;
|
|
value = r5 + Reflect.apply(join, value, ['0']);
|
|
r2 = value;
|
|
break reducibleJoin13;
|
|
}
|
|
break reducibleJoin24;
|
|
}
|
|
Error = global.Error;
|
|
prototype = Error.prototype;
|
|
value = Object.create(prototype, {constructor: {value: Error}});
|
|
value12 = 'Invalid integer: ' + value6 + ' is not a valid exponent.';
|
|
error = new Error();
|
|
value = error instanceof Object ? error : value;
|
|
throw value;
|
|
}
|
|
}
|
|
const regexp = RegExp('^([0-9][0-9]*)$', '');
|
|
if (regexp.test(r2)) {
|
|
if (result) {
|
|
BigInt = global.BigInt;
|
|
reducibleJoin22: while (true) {
|
|
if (value4) {
|
|
value = '-' + r2;
|
|
r0 = value;
|
|
break reducibleJoin22;
|
|
}
|
|
r0 = r2;
|
|
break reducibleJoin22;
|
|
}
|
|
value = BigInt(r0);
|
|
value11 = Object.create(NativeBigInt.prototype, {constructor: {value: NativeBigInt}});
|
|
nativeBigInt = new NativeBigInt(value);
|
|
return nativeBigInt instanceof Object ? nativeBigInt : value11;
|
|
}
|
|
items2 = [];
|
|
length = r2.length;
|
|
value = length - 7;
|
|
if (length > value3) {
|
|
r0 = value;
|
|
r11 = length;
|
|
reducibleLoop17: while (true) {
|
|
push = items2.push;
|
|
slice = r2.slice;
|
|
Reflect.apply(push, items2, [Number(Reflect.apply(slice, r2, [r0, r11]))]);
|
|
value = r0 - 7;
|
|
r0 = value < value3 ? value3 : value;
|
|
value = r11 - 7;
|
|
if (value > value3) {
|
|
r11 = value;
|
|
continue reducibleLoop17;
|
|
}
|
|
break reducibleLoop17;
|
|
}
|
|
}
|
|
trim(items2);
|
|
value = Object.create(BigInteger.prototype, {constructor: {value: BigInteger}});
|
|
bigInteger = new BigInteger(items2, value4);
|
|
return bigInteger instanceof Object ? bigInteger : value;
|
|
}
|
|
Error = global.Error;
|
|
value = 'Invalid integer: ' + r2;
|
|
const value10 = Object.create(Error.prototype, {constructor: {value: Error}});
|
|
error = new Error(value);
|
|
throw error instanceof Object ? error : value10;
|
|
}
|
|
|
|
function parseValue(a0) { // fn#1002, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:29:23858, offset: 0x00c5116f, size: 254 bytes, params: 2, frame: 15
|
|
var r0;
|
|
var Error;
|
|
let value = a0;
|
|
const value2 = typeof value;
|
|
if (value2 === 'number') {
|
|
if (result) {
|
|
value = global.BigInt(value);
|
|
return new NativeBigInt(value);
|
|
}
|
|
if (isPrecise(value)) {
|
|
if (value !== truncate(value)) {
|
|
Error = global.Error;
|
|
value += ' is not an integer.';
|
|
throw new Error(value);
|
|
}
|
|
return new SmallInteger(value);
|
|
}
|
|
value = parseStringValue(value.toString());
|
|
return value;
|
|
}
|
|
if (value2 === 'string') {
|
|
value = parseStringValue(value);
|
|
r0 = value;
|
|
} else {
|
|
r0 = value2 !== 'bigint' ? value : new NativeBigInt(value);
|
|
}
|
|
return r0;
|
|
}
|
|
|
|
function add_1003(a0) { // fn#1003, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:29:5953, offset: 0x00c5126d, size: 177 bytes, params: 2, frame: 19
|
|
const value2 = parseValue(a0);
|
|
if (this.sign !== value2.sign) {
|
|
return this.subtract(value2.negate());
|
|
}
|
|
const value3 = this.value;
|
|
const value4 = value2.value;
|
|
return value2.isSmall ? new BigInteger(addSmall(value3, global.Math.abs(value4)),
|
|
this.sign) : new BigInteger(addAny(value3, value4), this.sign);
|
|
}
|
|
|
|
function add_1004(a0) { // fn#1004, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:29:6251, offset: 0x00c5131e, size: 217 bytes, params: 2, frame: 21
|
|
var r9;
|
|
var smallToArrayBinding;
|
|
var Math;
|
|
var abs;
|
|
var addSmallBinding;
|
|
var value9;
|
|
var smallInteger;
|
|
var value;
|
|
const value2 = parseValue(a0);
|
|
const value3 = this.value;
|
|
if (value3 < 0 !== value2.sign) {
|
|
return this.subtract(value2.negate());
|
|
}
|
|
const value5 = value2.value;
|
|
if (value2.isSmall) {
|
|
if (isPrecise(value3 + value5)) {
|
|
value = value3 + value5;
|
|
value9 = Object.create(SmallInteger.prototype, {constructor: {value: SmallInteger}});
|
|
smallInteger = new SmallInteger();
|
|
return smallInteger instanceof Object ? smallInteger : value9;
|
|
}
|
|
smallToArrayBinding = smallToArray;
|
|
Math = global.Math;
|
|
abs = Math.abs;
|
|
r9 = smallToArrayBinding(Reflect.apply(abs, Math, [value5]));
|
|
addSmallBinding = addSmall;
|
|
Math = global.Math;
|
|
abs = Math.abs;
|
|
value = addSmallBinding(r9, Reflect.apply(abs, Math, [value3]));
|
|
} else {
|
|
r9 = value5;
|
|
addSmallBinding = addSmall;
|
|
Math = global.Math;
|
|
value = addSmallBinding(r9, Math.abs(value3));
|
|
}
|
|
const value7 = value3 < 0;
|
|
const value8 = Object.create(BigInteger.prototype, {constructor: {value: BigInteger}});
|
|
const bigInteger = new BigInteger();
|
|
return bigInteger instanceof Object ? bigInteger : value8;
|
|
}
|
|
|
|
function add_1005(a0) { // fn#1005, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:29:6582, offset: 0x00c513f7, size: 60 bytes, params: 2, frame: 13
|
|
const value2 = this.value;
|
|
let value = parseValue(a0).value;
|
|
value = value2 + value;
|
|
const value3 = Object.create(NativeBigInt.prototype, {constructor: {value: NativeBigInt}});
|
|
const nativeBigInt = new NativeBigInt();
|
|
return nativeBigInt instanceof Object ? nativeBigInt : value3;
|
|
}
|
|
|
|
function subtract_1006(a0) { // fn#1006, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:29:6736, offset: 0x00c51433, size: 261 bytes, params: 2, frame: 20
|
|
var r4;
|
|
var r5;
|
|
var r0;
|
|
var value6;
|
|
var value7;
|
|
var subtractSmallBinding;
|
|
var value;
|
|
const value2 = parseValue(a0);
|
|
let sign = this.sign;
|
|
if (sign !== value2.sign) {
|
|
return this.add(value2.negate());
|
|
}
|
|
const value3 = this.value;
|
|
const value4 = value2.value;
|
|
if (value2.isSmall) {
|
|
subtractSmallBinding = subtractSmall;
|
|
value = global.Math.abs(value4);
|
|
value = subtractSmallBinding(value3, value, this.sign);
|
|
r0 = value;
|
|
} else {
|
|
sign = this.sign;
|
|
if (compareAbs(value3, value4) >= 0) {
|
|
r4 = subtract_2(value3, value4);
|
|
r5 = sign;
|
|
} else {
|
|
value6 = subtract_2(value4, value3);
|
|
value7 = !sign;
|
|
r4 = value6;
|
|
r5 = value7;
|
|
}
|
|
r0 = typeof arrayToSmall(r4) === 'number' ? new SmallInteger() : new BigInteger();
|
|
}
|
|
return r0;
|
|
}
|
|
|
|
function subtract_1007(a0) { // fn#1007, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:29:7194, offset: 0x00c51538, size: 143 bytes, params: 2, frame: 20
|
|
var r0;
|
|
var subtractSmallBinding;
|
|
var value;
|
|
const value2 = parseValue(a0);
|
|
const value3 = this.value;
|
|
if (value3 < 0 !== value2.sign) {
|
|
return this.add(value2.negate());
|
|
}
|
|
const value5 = value2.value;
|
|
if (value2.isSmall) {
|
|
value = value3 - value5;
|
|
r0 = new SmallInteger();
|
|
} else {
|
|
subtractSmallBinding = subtractSmall;
|
|
value = global.Math.abs(value3);
|
|
value = subtractSmallBinding(value5, value, value3 >= 0);
|
|
r0 = value;
|
|
}
|
|
return r0;
|
|
}
|
|
|
|
function subtract_1008(a0) { // fn#1008, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:29:7464, offset: 0x00c515c7, size: 60 bytes, params: 2, frame: 13
|
|
const value2 = this.value;
|
|
let value = parseValue(a0).value;
|
|
value = value2 - value;
|
|
const value3 = Object.create(NativeBigInt.prototype, {constructor: {value: NativeBigInt}});
|
|
const nativeBigInt = new NativeBigInt();
|
|
return nativeBigInt instanceof Object ? nativeBigInt : value3;
|
|
}
|
|
|
|
function negate() { // fn#1009, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:29:7622, offset: 0x00c51603, size: 46 bytes, params: 1, frame: 13
|
|
const value = this.value;
|
|
const sign = this.sign;
|
|
const value2 = Object.create(BigInteger.prototype, {constructor: {value: BigInteger}});
|
|
const bigInteger = new BigInteger(value, !sign);
|
|
return bigInteger instanceof Object ? bigInteger : value2;
|
|
}
|
|
|
|
function negate_1010() { // fn#1010, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:29:7709, offset: 0x00c51631, size: 55 bytes, params: 1, frame: 12
|
|
const sign = this.sign;
|
|
let value = this.value;
|
|
value = -value;
|
|
const smallInteger = new SmallInteger();
|
|
smallInteger.sign = !sign;
|
|
return smallInteger;
|
|
}
|
|
|
|
function negate_1011() { // fn#1011, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:29:7818, offset: 0x00c51668, size: 40 bytes, params: 1, frame: 11
|
|
let value = this.value;
|
|
value = -value;
|
|
const value2 = Object.create(NativeBigInt.prototype, {constructor: {value: NativeBigInt}});
|
|
const nativeBigInt = new NativeBigInt();
|
|
return nativeBigInt instanceof Object ? nativeBigInt : value2;
|
|
}
|
|
|
|
function abs() { // fn#1012, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:29:7892, offset: 0x00c51690, size: 39 bytes, params: 1, frame: 13
|
|
const value = this.value;
|
|
const value2 = Object.create(BigInteger.prototype, {constructor: {value: BigInteger}});
|
|
const bigInteger = new BigInteger(value, false);
|
|
return bigInteger instanceof Object ? bigInteger : value2;
|
|
}
|
|
|
|
function abs_1013() { // fn#1013, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:29:7968, offset: 0x00c516b7, size: 56 bytes, params: 1, frame: 12
|
|
const Math = global.Math;
|
|
const abs = Math.abs;
|
|
let value = this.value;
|
|
value = Reflect.apply(abs, Math, [value]);
|
|
const value2 = Object.create(SmallInteger.prototype, {constructor: {value: SmallInteger}});
|
|
const smallInteger = new SmallInteger();
|
|
return smallInteger instanceof Object ? smallInteger : value2;
|
|
}
|
|
|
|
function abs_1014() { // fn#1014, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:29:8053, offset: 0x00c516ef, size: 61 bytes, params: 1, frame: 12
|
|
var r0;
|
|
let value = this.value;
|
|
if (value >= 0) {
|
|
r0 = this.value;
|
|
} else {
|
|
value = this.value;
|
|
value = -value;
|
|
r0 = value;
|
|
}
|
|
value = Object.create(NativeBigInt.prototype, {constructor: {value: NativeBigInt}});
|
|
const nativeBigInt = new NativeBigInt();
|
|
return nativeBigInt instanceof Object ? nativeBigInt : value;
|
|
}
|
|
|
|
function multiply(a0) { // fn#1015, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:29:8157, offset: 0x00c5172c, size: 342 bytes, params: 2, frame: 22
|
|
var r9;
|
|
var value6;
|
|
var bigInteger;
|
|
var value13;
|
|
var value;
|
|
const value2 = parseValue(a0);
|
|
const value3 = this.value;
|
|
const value4 = value2.value;
|
|
const value5 = this.sign !== value2.sign;
|
|
if (value2.isSmall) {
|
|
if (value4 === 0) {
|
|
return Integer[0];
|
|
}
|
|
if (value4 === 1) {
|
|
return this;
|
|
}
|
|
if (value4 === -1) {
|
|
return this.negate();
|
|
}
|
|
value6 = global.Math.abs(value4);
|
|
if (value6 < 10000000) {
|
|
value = multiplySmall(value3, value6);
|
|
value13 = Object.create(BigInteger.prototype, {constructor: {value: BigInteger}});
|
|
bigInteger = new BigInteger(value, value5);
|
|
return bigInteger instanceof Object ? bigInteger : value13;
|
|
}
|
|
r9 = smallToArray(value6);
|
|
} else {
|
|
r9 = value4;
|
|
}
|
|
const length = value3.length;
|
|
const length2 = r9.length;
|
|
return -0.012 * length - 0.012 * length2 + 0.000015 * length * length2 > 0 ? new BigInteger(multiplyKaratsuba(value3,
|
|
r9), value5) : new BigInteger(multiplyLong(value3, r9), value5);
|
|
}
|
|
|
|
function _multiplyBySmall(a0) { // fn#1016, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:29:8673, offset: 0x00c51882, size: 161 bytes, params: 2, frame: 20
|
|
var r0;
|
|
var multiplySmallAndArrayBinding;
|
|
var Math;
|
|
var abs;
|
|
var value5;
|
|
var smallToArrayBinding;
|
|
var value;
|
|
if (isPrecise(a0.value * this.value)) {
|
|
value = a0.value;
|
|
value *= this.value;
|
|
r0 = new SmallInteger();
|
|
} else {
|
|
multiplySmallAndArrayBinding = multiplySmallAndArray;
|
|
Math = global.Math;
|
|
value5 = Math.abs(a0.value);
|
|
smallToArrayBinding = smallToArray;
|
|
Math = global.Math;
|
|
abs = Math.abs;
|
|
value = this.value;
|
|
value = smallToArrayBinding(Reflect.apply(abs, Math, [value]));
|
|
value = multiplySmallAndArrayBinding(value5, value, this.sign !== a0.sign);
|
|
r0 = value;
|
|
}
|
|
return r0;
|
|
}
|
|
|
|
function _multiplyBySmall_1017(a0) { // fn#1017, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:29:8893, offset: 0x00c51923, size: 138 bytes, params: 2, frame: 19
|
|
var r1;
|
|
var r0;
|
|
var multiplySmallAndArrayBinding;
|
|
var Math;
|
|
let value = this;
|
|
if (a0.value === 0) {
|
|
r0 = Integer[0];
|
|
} else if (a0.value === 1) {
|
|
r0 = value;
|
|
} else {
|
|
if (a0.value === -1) {
|
|
value = value.negate();
|
|
r1 = value;
|
|
} else {
|
|
multiplySmallAndArrayBinding = multiplySmallAndArray;
|
|
Math = global.Math;
|
|
value = multiplySmallAndArrayBinding(Math.abs(a0.value), value.value, value.sign !== a0.sign);
|
|
r1 = value;
|
|
}
|
|
r0 = r1;
|
|
}
|
|
return r0;
|
|
}
|
|
|
|
function multiply_1018(a0) { // fn#1018, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:29:9083, offset: 0x00c519ad, size: 33 bytes, params: 2, frame: 11
|
|
return parseValue(a0)._multiplyBySmall(this);
|
|
}
|
|
|
|
function multiply_1019(a0) { // fn#1019, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:29:9233, offset: 0x00c519ce, size: 60 bytes, params: 2, frame: 13
|
|
const value2 = this.value;
|
|
let value = parseValue(a0).value;
|
|
value = value2 * value;
|
|
const value3 = Object.create(NativeBigInt.prototype, {constructor: {value: NativeBigInt}});
|
|
const nativeBigInt = new NativeBigInt();
|
|
return nativeBigInt instanceof Object ? nativeBigInt : value3;
|
|
}
|
|
|
|
function square_1020() { // fn#1020, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:29:9391, offset: 0x00c51a0a, size: 50 bytes, params: 1, frame: 13
|
|
const squareBinding = square;
|
|
let value = this.value;
|
|
value = squareBinding(value);
|
|
const value2 = Object.create(BigInteger.prototype, {constructor: {value: BigInteger}});
|
|
const bigInteger = new BigInteger(value, false);
|
|
return bigInteger instanceof Object ? bigInteger : value2;
|
|
}
|
|
|
|
function square_1021() { // fn#1021, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:29:9478, offset: 0x00c51a3c, size: 133 bytes, params: 1, frame: 18
|
|
var r0;
|
|
var squareBinding;
|
|
var smallToArrayBinding;
|
|
var Math;
|
|
var abs;
|
|
let value = this.value;
|
|
value *= this.value;
|
|
if (isPrecise(value)) {
|
|
r0 = new SmallInteger(value);
|
|
} else {
|
|
squareBinding = square;
|
|
smallToArrayBinding = smallToArray;
|
|
Math = global.Math;
|
|
abs = Math.abs;
|
|
value = this.value;
|
|
value = squareBinding(smallToArrayBinding(Reflect.apply(abs, Math, [value])));
|
|
r0 = new BigInteger(value, false);
|
|
}
|
|
return r0;
|
|
}
|
|
|
|
function square_1022(a0) { // fn#1022, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:29:9650, offset: 0x00c51ac1, size: 46 bytes, params: 2, frame: 11
|
|
let value = this.value;
|
|
value *= this.value;
|
|
const value3 = Object.create(NativeBigInt.prototype, {constructor: {value: NativeBigInt}});
|
|
const nativeBigInt = new NativeBigInt();
|
|
return nativeBigInt instanceof Object ? nativeBigInt : value3;
|
|
}
|
|
|
|
function divmod(a0) { // fn#1023, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:29:9738, offset: 0x00c51aef, size: 48 bytes, params: 2, frame: 13
|
|
const value = divModAny(this, a0);
|
|
return {quotient: value[0], remainder: value[1]};
|
|
}
|
|
|
|
function divide(a0) { // fn#1024, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:29:9928, offset: 0x00c51b1f, size: 29 bytes, params: 2, frame: 13
|
|
return divModAny(this, a0)[0];
|
|
}
|
|
|
|
function divide_1025(a0) { // fn#1025, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:29:10027, offset: 0x00c51b3c, size: 60 bytes, params: 2, frame: 13
|
|
const value2 = this.value;
|
|
let value = parseValue(a0).value;
|
|
value = value2 / value;
|
|
const value3 = Object.create(NativeBigInt.prototype, {constructor: {value: NativeBigInt}});
|
|
const nativeBigInt = new NativeBigInt();
|
|
return nativeBigInt instanceof Object ? nativeBigInt : value3;
|
|
}
|
|
|
|
function mod(a0) { // fn#1026, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:29:10233, offset: 0x00c51b78, size: 30 bytes, params: 2, frame: 13
|
|
return divModAny(this, a0)[1];
|
|
}
|
|
|
|
function mod_1027(a0) { // fn#1027, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:29:10334, offset: 0x00c51b96, size: 60 bytes, params: 2, frame: 13
|
|
const value2 = this.value;
|
|
let value = parseValue(a0).value;
|
|
value = value2 % value;
|
|
const value3 = Object.create(NativeBigInt.prototype, {constructor: {value: NativeBigInt}});
|
|
const nativeBigInt = new NativeBigInt();
|
|
return nativeBigInt instanceof Object ? nativeBigInt : value3;
|
|
}
|
|
|
|
function pow(a0) { // fn#1028, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:29:10544, offset: 0x00c51bd2, size: 406 bytes, params: 2, frame: 26
|
|
var r4;
|
|
var r11;
|
|
var r7;
|
|
var r9;
|
|
var r13;
|
|
var isPreciseBinding;
|
|
var value7;
|
|
var property;
|
|
var times;
|
|
var value8;
|
|
var value9;
|
|
var square;
|
|
var value10;
|
|
var value11;
|
|
var value12;
|
|
var smallInteger;
|
|
let value = this;
|
|
const value3 = parseValue(a0);
|
|
const value4 = value.value;
|
|
const value5 = value3.value;
|
|
if (value5 === 0) {
|
|
return Integer[1];
|
|
}
|
|
if (value4 === 0) {
|
|
return Integer[0];
|
|
}
|
|
if (value4 === 1) {
|
|
return Integer[1];
|
|
}
|
|
if (value4 === -1) {
|
|
return value3.isEven() ? Integer[1] : Integer[-1];
|
|
}
|
|
if (value3.sign) {
|
|
return Integer[0];
|
|
}
|
|
if (value3.isSmall) {
|
|
if (value.isSmall) {
|
|
isPreciseBinding = isPrecise;
|
|
value7 = global.Math.pow(value4, value5);
|
|
reducibleJoin9: while (true) {
|
|
if (isPreciseBinding(value7)) {
|
|
value = truncate(value7);
|
|
value12 = Object.create(SmallInteger.prototype, {constructor: {value: SmallInteger}});
|
|
smallInteger = new SmallInteger(value);
|
|
return smallInteger instanceof Object ? smallInteger : value12;
|
|
}
|
|
break reducibleJoin9;
|
|
}
|
|
}
|
|
property = Integer[1];
|
|
reducibleJoin11: while (true) {
|
|
if (true & value5) {
|
|
times = property.times;
|
|
value8 = Reflect.apply(times, property, [value]);
|
|
value9 = typeof value5 === 'bigint' ? value5 - 1n : +value5 - 1;
|
|
r4 = value8;
|
|
r11 = value9;
|
|
break reducibleJoin11;
|
|
}
|
|
r4 = property;
|
|
r11 = value5;
|
|
break reducibleJoin11;
|
|
}
|
|
if (r11 !== 0) {
|
|
r7 = r4;
|
|
r9 = value;
|
|
reducibleLoop12: while (true) {
|
|
value = r11 / 2;
|
|
square = r9.square;
|
|
value10 = Reflect.apply(square, r9, []);
|
|
reducibleJoin14: while (true) {
|
|
if (true & value) {
|
|
times = r7.times;
|
|
value11 = Reflect.apply(times, r7, [value10]);
|
|
value = typeof value === 'bigint' ? value - 1n : +value - 1;
|
|
r11 = value;
|
|
r13 = value11;
|
|
break reducibleJoin14;
|
|
}
|
|
r11 = value;
|
|
r13 = r7;
|
|
break reducibleJoin14;
|
|
}
|
|
if (r11 !== 0) {
|
|
r7 = r13;
|
|
r9 = value10;
|
|
continue reducibleLoop12;
|
|
}
|
|
r4 = r13;
|
|
break reducibleLoop12;
|
|
}
|
|
}
|
|
return r4;
|
|
}
|
|
const Error = global.Error;
|
|
value = value3.toString();
|
|
value = 'The exponent ' + value;
|
|
const value6 = Object.create(Error.prototype, {constructor: {value: Error}});
|
|
value += ' is too large.';
|
|
const error = new Error(value);
|
|
throw error instanceof Object ? error : value6;
|
|
}
|
|
|
|
function pow_1029(a0) { // fn#1029, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:29:11086, offset: 0x00c51d68, size: 325 bytes, params: 2, frame: 24
|
|
var r4;
|
|
var r9;
|
|
var r6;
|
|
var r8;
|
|
var r12;
|
|
var value9;
|
|
var value10;
|
|
var value11;
|
|
var value12;
|
|
var nativeBigInt;
|
|
let value = this;
|
|
const value3 = parseValue(a0);
|
|
const value4 = value.value;
|
|
const value5 = value3.value;
|
|
let BigInt = global.BigInt;
|
|
const value6 = BigInt(0);
|
|
BigInt = global.BigInt;
|
|
const value7 = BigInt(1);
|
|
BigInt = global.BigInt;
|
|
const value8 = BigInt(2);
|
|
if (value5 === value6) {
|
|
return Integer[1];
|
|
}
|
|
if (value4 === value6) {
|
|
return Integer[0];
|
|
}
|
|
if (value4 === value7) {
|
|
return Integer[1];
|
|
}
|
|
BigInt = global.BigInt;
|
|
if (value4 === BigInt(-1)) {
|
|
return value3.isEven() ? Integer[1] : Integer[-1];
|
|
}
|
|
if (value3.isNegative()) {
|
|
value = Object.create(NativeBigInt.prototype, {constructor: {value: NativeBigInt}});
|
|
nativeBigInt = new NativeBigInt(value6);
|
|
return nativeBigInt instanceof Object ? nativeBigInt : value;
|
|
}
|
|
const property = Integer[1];
|
|
if ((value5 & value7) !== value7) {
|
|
r4 = property;
|
|
r9 = value5;
|
|
} else {
|
|
value9 = property.times(value);
|
|
value10 = typeof value5 === 'bigint' ? value5 - 1n : +value5 - 1;
|
|
r4 = value9;
|
|
r9 = value10;
|
|
}
|
|
if (r9 !== value6) {
|
|
r6 = r4;
|
|
r8 = value;
|
|
while (true) {
|
|
value = r9 / value8;
|
|
value11 = r8.square();
|
|
if ((value & value7) !== value7) {
|
|
r9 = value;
|
|
r12 = r6;
|
|
} else {
|
|
value12 = r6.times(value11);
|
|
value = typeof value === 'bigint' ? value - 1n : +value - 1;
|
|
r9 = value;
|
|
r12 = value12;
|
|
}
|
|
if (r9 !== value6) {
|
|
r6 = r12;
|
|
r8 = value11;
|
|
continue;
|
|
}
|
|
r4 = r12;
|
|
break;
|
|
}
|
|
}
|
|
return r4;
|
|
}
|
|
|
|
function modPow(a0, a1) { // fn#1030, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:29:11483, offset: 0x00c51ead, size: 304 bytes, params: 3, frame: 19
|
|
var r3;
|
|
var r6;
|
|
var r4;
|
|
var r8;
|
|
var r1;
|
|
var multiply;
|
|
var value5;
|
|
var value6;
|
|
var isOdd;
|
|
var value7;
|
|
var value8;
|
|
var divide;
|
|
var value9;
|
|
var square;
|
|
var value10;
|
|
var value11;
|
|
const parseValueBinding = parseValue;
|
|
const valueBinding = parseValueBinding(a0);
|
|
const valueBinding2 = parseValueBinding(a1);
|
|
let isZero = valueBinding2.isZero;
|
|
if (Reflect.apply(isZero, valueBinding2, [])) {
|
|
throw new global.Error('Cannot take modPow with modulus 0');
|
|
}
|
|
const property = Integer[1];
|
|
const value4 = this.mod(valueBinding2);
|
|
if (valueBinding.isNegative()) {
|
|
value5 = valueBinding.multiply(Integer[-1]);
|
|
value6 = value4.modInv(valueBinding2);
|
|
r3 = value5;
|
|
r6 = value6;
|
|
} else {
|
|
r3 = valueBinding;
|
|
r6 = value4;
|
|
}
|
|
let isPositive = r3.isPositive;
|
|
if (Reflect.apply(isPositive, r3, [])) {
|
|
r4 = r3;
|
|
r3 = property;
|
|
loopExit4: while (true) {
|
|
isZero = r6.isZero;
|
|
if (Reflect.apply(isZero, r6, [])) {
|
|
return Integer[0];
|
|
}
|
|
isOdd = r4.isOdd;
|
|
if (!Reflect.apply(isOdd, r4, [])) {
|
|
r8 = r3;
|
|
continue;
|
|
}
|
|
multiply = r3.multiply;
|
|
value7 = Reflect.apply(multiply, r3, [r6]);
|
|
value8 = value7.mod(valueBinding2);
|
|
r8 = value8;
|
|
divide = r4.divide;
|
|
value9 = Reflect.apply(divide, r4, [2]);
|
|
square = r6.square;
|
|
value10 = Reflect.apply(square, r6, []);
|
|
value11 = value10.mod(valueBinding2);
|
|
isPositive = value9.isPositive;
|
|
if (Reflect.apply(isPositive, value9, [])) {
|
|
r3 = r8;
|
|
r4 = value9;
|
|
r6 = value11;
|
|
continue;
|
|
}
|
|
r1 = r8;
|
|
break loopExit4;
|
|
}
|
|
return r1;
|
|
}
|
|
return property;
|
|
}
|
|
|
|
function compareAbs_1031(a0) { // fn#1031, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:29:11938, offset: 0x00c51fdd, size: 54 bytes, params: 2, frame: 15
|
|
const value2 = parseValue(a0);
|
|
return value2.isSmall ? 1 : compareAbs(this.value, value2.value);
|
|
}
|
|
|
|
function compareAbs_1032(a0) { // fn#1032, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:29:12063, offset: 0x00c52013, size: 108 bytes, params: 2, frame: 14
|
|
var r0;
|
|
var value5;
|
|
let value = parseValue(a0);
|
|
const Math = global.Math;
|
|
const value3 = Math.abs(this.value);
|
|
const value4 = value.value;
|
|
const isSmall = value.isSmall;
|
|
value = -1;
|
|
if (isSmall) {
|
|
value5 = global.Math.abs(value4);
|
|
r0 = value3 === value5 ? 0 : value3 > value5 ? 1 : value;
|
|
} else {
|
|
r0 = value;
|
|
}
|
|
return r0;
|
|
}
|
|
|
|
function compareAbs_1033(a0) { // fn#1033, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:29:12214, offset: 0x00c5207f, size: 79 bytes, params: 2, frame: 13
|
|
const value = this.value;
|
|
const value3 = parseValue(a0).value;
|
|
const value4 = 0;
|
|
const r2 = value >= value4 ? value : -value;
|
|
const r1 = value3 >= value4 ? value3 : -value3;
|
|
return r2 === r1 ? value4 : r2 > r1 ? 1 : -1;
|
|
}
|
|
|
|
function compare_1034(a0) { // fn#1034, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:29:12342, offset: 0x00c520ce, size: 182 bytes, params: 2, frame: 17
|
|
var r0;
|
|
if (a0 === Infinity) {
|
|
return -1;
|
|
}
|
|
if (a0 === -Infinity) {
|
|
return 1;
|
|
}
|
|
var value;
|
|
const value2 = parseValue(a0);
|
|
if (this.sign !== value2.sign) {
|
|
r0 = value2.sign ? 1 : -1;
|
|
} else if (value2.isSmall) {
|
|
r0 = this.sign ? -1 : 1;
|
|
} else {
|
|
value = compareAbs(this.value, value2.value);
|
|
r0 = this.sign ? -1 : 1;
|
|
value *= r0;
|
|
r0 = value;
|
|
}
|
|
return r0;
|
|
}
|
|
|
|
function compare_1035(a0) { // fn#1035, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:29:12626, offset: 0x00c52184, size: 174 bytes, params: 2, frame: 14
|
|
if (a0 === Infinity) {
|
|
return -1;
|
|
}
|
|
if (a0 === -Infinity) {
|
|
return 1;
|
|
}
|
|
const value = parseValue(a0);
|
|
const value2 = this.value;
|
|
const value3 = value.value;
|
|
const isSmall = value.isSmall;
|
|
const value4 = 0;
|
|
return isSmall ? value2 == value3 ? value4 : value2 > value3 ? 1 : -1 : value2 < value4 !== value.sign ? value2 < value4 ? -1 : 1 : value2 < value4 ? 1 : -1;
|
|
}
|
|
|
|
function compare_1036(a0) { // fn#1036, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:29:12882, offset: 0x00c52232, size: 98 bytes, params: 2, frame: 12
|
|
if (a0 === Infinity) {
|
|
return -1;
|
|
}
|
|
if (a0 === -Infinity) {
|
|
return 1;
|
|
}
|
|
const value = this.value;
|
|
const value3 = parseValue(a0).value;
|
|
return value === value3 ? 0 : -1 > value3 ? 1 : -1;
|
|
}
|
|
|
|
function isDivisibleBy(a0) { // fn#1059, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:29:15776, offset: 0x00c524a2, size: 116 bytes, params: 2, frame: 14
|
|
var r2;
|
|
var r1;
|
|
var r0;
|
|
var isUnit2;
|
|
var value;
|
|
const isZero2 = parseValue(a0).isZero();
|
|
if (isZero2) {
|
|
r0 = !isZero2;
|
|
} else {
|
|
isUnit2 = value.isUnit();
|
|
if (isUnit2) {
|
|
r1 = !!isUnit2;
|
|
} else {
|
|
if (value.compareAbs(2) === 0) {
|
|
r2 = this.isEven();
|
|
} else {
|
|
value = this.mod(value);
|
|
value = value.isZero();
|
|
r2 = value;
|
|
}
|
|
r1 = r2;
|
|
}
|
|
r0 = r1;
|
|
}
|
|
return r0;
|
|
}
|
|
|
|
function isPrime(a0) { // fn#1060, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:29:16039, offset: 0x00c52516, size: 227 bytes, params: 2, frame: 21
|
|
var r2;
|
|
var r6;
|
|
var Math2;
|
|
var pow;
|
|
var value6;
|
|
var push;
|
|
var binding;
|
|
var value10;
|
|
const isBasicPrime2 = isBasicPrime(this);
|
|
if (isBasicPrime2 !== env0_0) {
|
|
return isBasicPrime2;
|
|
}
|
|
const value2 = this.abs();
|
|
const value3 = value2.bitLength();
|
|
if (value3 <= 64) {
|
|
return millerRabinTest(value2, [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37]);
|
|
}
|
|
let Math = global.Math;
|
|
const value5 = Math.log(2) * value3.toJSNumber();
|
|
Math = global.Math;
|
|
const ceil = Math.ceil;
|
|
reducibleJoin4: while (true) {
|
|
if (a0 !== true) {
|
|
r2 = value5;
|
|
break reducibleJoin4;
|
|
}
|
|
Math2 = global.Math;
|
|
pow = Math2.pow;
|
|
value6 = 2 * Reflect.apply(pow, Math2, [value5, 2]);
|
|
r2 = value6;
|
|
break reducibleJoin4;
|
|
}
|
|
const value7 = Reflect.apply(ceil, Math, [r2]);
|
|
const items2 = [];
|
|
const value8 = 0;
|
|
if (value8 < value7) {
|
|
r6 = value8;
|
|
reducibleLoop5: while (true) {
|
|
push = items2.push;
|
|
binding = env1_0;
|
|
Reflect.apply(push, items2, [binding(r6 + 2)]);
|
|
value10 = typeof r6 === 'bigint' ? r6 + 1n : +r6 + 1;
|
|
if (value10 < value7) {
|
|
r6 = value10;
|
|
continue reducibleLoop5;
|
|
}
|
|
break reducibleLoop5;
|
|
}
|
|
}
|
|
return millerRabinTest(value2, items2);
|
|
}
|
|
|
|
function isProbablePrime(a0, a1) { // fn#1061, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:29:16460, offset: 0x00c525f9, size: 133 bytes, params: 3, frame: 24
|
|
var r7;
|
|
var push;
|
|
var binding;
|
|
var randBetween;
|
|
var minus;
|
|
let value = a0;
|
|
const isBasicPrime2 = isBasicPrime(this);
|
|
if (isBasicPrime2 !== env0_0) {
|
|
return isBasicPrime2;
|
|
}
|
|
const value3 = this.abs();
|
|
const r8 = value === env0_0 ? 5 : value;
|
|
const items2 = [];
|
|
value = 0;
|
|
if (value < r8) {
|
|
r7 = value;
|
|
reducibleLoop3: while (true) {
|
|
push = items2.push;
|
|
binding = env1_0;
|
|
randBetween = binding.randBetween;
|
|
minus = value3.minus;
|
|
Reflect.apply(push, items2, [Reflect.apply(randBetween, binding, [2, Reflect.apply(minus, value3, [2]),
|
|
a1])]);
|
|
value = typeof r7 === 'bigint' ? r7 + 1n : +r7 + 1;
|
|
if (value < r8) {
|
|
r7 = value;
|
|
continue reducibleLoop3;
|
|
}
|
|
break reducibleLoop3;
|
|
}
|
|
}
|
|
return millerRabinTest(value3, items2);
|
|
}
|
|
|
|
function modInv(a0) { // fn#1062, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:29:16777, offset: 0x00c5267e, size: 307 bytes, params: 2, frame: 21
|
|
var r5;
|
|
var r6;
|
|
var r7;
|
|
var r8;
|
|
var r2;
|
|
var r3;
|
|
var r0;
|
|
var divide;
|
|
var subtract;
|
|
var multiply;
|
|
var value3;
|
|
var add;
|
|
var negate;
|
|
let value = environment.__proto__;
|
|
const zero = env1_0.zero;
|
|
const one = env1_0.one;
|
|
value = parseValue(a0);
|
|
const value2 = this.abs();
|
|
let isZero = value2.isZero;
|
|
if (Reflect.apply(isZero, value2, [])) {
|
|
r2 = value;
|
|
r3 = zero;
|
|
} else {
|
|
r5 = value2;
|
|
r6 = value;
|
|
r7 = zero;
|
|
r8 = one;
|
|
reducibleLoop1: while (true) {
|
|
divide = r6.divide;
|
|
value = Reflect.apply(divide, r6, [r5]);
|
|
subtract = r7.subtract;
|
|
multiply = value.multiply;
|
|
value3 = Reflect.apply(subtract, r7, [Reflect.apply(multiply, value, [r8])]);
|
|
subtract = r6.subtract;
|
|
multiply = value.multiply;
|
|
value = Reflect.apply(subtract, r6, [Reflect.apply(multiply, value, [r5])]);
|
|
isZero = value.isZero;
|
|
if (Reflect.apply(isZero, value, [])) {
|
|
r2 = r5;
|
|
r3 = r8;
|
|
break reducibleLoop1;
|
|
}
|
|
r6 = r5;
|
|
r5 = value;
|
|
r7 = r8;
|
|
r8 = value3;
|
|
continue reducibleLoop1;
|
|
}
|
|
}
|
|
if (r2.isUnit()) {
|
|
value = r3.compare(0);
|
|
reducibleJoin6: while (true) {
|
|
if (value !== -1) {
|
|
r2 = r3;
|
|
break reducibleJoin6;
|
|
}
|
|
add = r3.add;
|
|
value = Reflect.apply(add, r3, [a0]);
|
|
r2 = value;
|
|
break reducibleJoin6;
|
|
}
|
|
reducibleJoin8: while (true) {
|
|
if (this.isNegative()) {
|
|
negate = r2.negate;
|
|
value = Reflect.apply(negate, r2, []);
|
|
r0 = value;
|
|
break reducibleJoin8;
|
|
}
|
|
r0 = r2;
|
|
break reducibleJoin8;
|
|
}
|
|
return r0;
|
|
}
|
|
const Error = global.Error;
|
|
value = this.toString();
|
|
value += ' and ';
|
|
value += a0.toString();
|
|
const value4 = Object.create(Error.prototype, {constructor: {value: Error}});
|
|
value += ' are not co-prime';
|
|
const error = new Error(value);
|
|
throw error instanceof Object ? error : value4;
|
|
}
|
|
|
|
function next() { // fn#1063, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:29:17221, offset: 0x00c527b1, size: 91 bytes, params: 1, frame: 17
|
|
var r0;
|
|
let value = this.value;
|
|
if (this.sign) {
|
|
value = subtractSmall(value, 1, this.sign);
|
|
r0 = value;
|
|
} else {
|
|
value = addSmall(value, 1);
|
|
r0 = new BigInteger(value, this.sign);
|
|
}
|
|
return r0;
|
|
}
|
|
|
|
function next_1064() { // fn#1064, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:29:17364, offset: 0x00c5280c, size: 97 bytes, params: 1, frame: 15
|
|
var r0;
|
|
let value = this.value;
|
|
if (value + 1 < 9007199254740992) {
|
|
value += 1;
|
|
r0 = new SmallInteger(value);
|
|
} else {
|
|
r0 = new BigInteger(env0_1, false);
|
|
}
|
|
return r0;
|
|
}
|
|
|
|
function next_1065() { // fn#1065, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:29:17477, offset: 0x00c5286d, size: 59 bytes, params: 1, frame: 13
|
|
let value = this.value;
|
|
const BigInt = global.BigInt;
|
|
value += BigInt(1);
|
|
const value2 = Object.create(NativeBigInt.prototype, {constructor: {value: NativeBigInt}});
|
|
const nativeBigInt = new NativeBigInt();
|
|
return nativeBigInt instanceof Object ? nativeBigInt : value2;
|
|
}
|
|
|
|
function prev() { // fn#1066, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:29:17561, offset: 0x00c528a8, size: 87 bytes, params: 1, frame: 16
|
|
var r0;
|
|
let value = this.value;
|
|
if (this.sign) {
|
|
value = addSmall(value, 1);
|
|
r0 = new BigInteger(value, true);
|
|
} else {
|
|
value = subtractSmall(value, 1, this.sign);
|
|
r0 = value;
|
|
}
|
|
return r0;
|
|
}
|
|
|
|
function prev_1067() { // fn#1067, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:29:17697, offset: 0x00c528ff, size: 97 bytes, params: 1, frame: 15
|
|
var r0;
|
|
let value = this.value;
|
|
if (value - 1 > -9007199254740992) {
|
|
value -= 1;
|
|
r0 = new SmallInteger(value);
|
|
} else {
|
|
r0 = new BigInteger(env0_1, true);
|
|
}
|
|
return r0;
|
|
}
|
|
|
|
function prev_1068() { // fn#1068, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:29:17826, offset: 0x00c52960, size: 59 bytes, params: 1, frame: 13
|
|
let value = this.value;
|
|
const BigInt = global.BigInt;
|
|
value -= BigInt(1);
|
|
const value2 = Object.create(NativeBigInt.prototype, {constructor: {value: NativeBigInt}});
|
|
const nativeBigInt = new NativeBigInt();
|
|
return nativeBigInt instanceof Object ? nativeBigInt : value2;
|
|
}
|
|
|
|
function shiftLeft_1069(a0) { // fn#1069, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:29:18438, offset: 0x00c5299b, size: 215 bytes, params: 2, frame: 19
|
|
var r6;
|
|
var r7;
|
|
var r4;
|
|
var r5;
|
|
var multiply;
|
|
var value6;
|
|
let value = this;
|
|
const value4 = parseValue(a0).toJSNumber();
|
|
if (shift_isSmall(value4)) {
|
|
if (value4 < 0) {
|
|
return value.shiftRight(-value4);
|
|
}
|
|
if (value.isZero()) {
|
|
return value;
|
|
}
|
|
if (value4 >= length) {
|
|
r6 = value;
|
|
r7 = value4;
|
|
reducibleLoop5: while (true) {
|
|
multiply = r6.multiply;
|
|
value = Reflect.apply(multiply, r6, [env0_6]);
|
|
value6 = r7 - (length - 1);
|
|
if (value6 >= length) {
|
|
r6 = value;
|
|
r7 = value6;
|
|
continue reducibleLoop5;
|
|
}
|
|
r4 = value;
|
|
r5 = value6;
|
|
break reducibleLoop5;
|
|
}
|
|
} else {
|
|
r4 = value;
|
|
r5 = value4;
|
|
}
|
|
return r4.multiply(env0_4[r5]);
|
|
}
|
|
const Error = global.Error;
|
|
const String = global.String;
|
|
value = String(value4);
|
|
value += ' is too large for shifting.';
|
|
const value5 = Object.create(Error.prototype, {constructor: {value: Error}});
|
|
const error = new Error(value);
|
|
throw error instanceof Object ? error : value5;
|
|
}
|
|
|
|
function shiftRight(a0) { // fn#1070, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:29:18817, offset: 0x00c52a72, size: 329 bytes, params: 2, frame: 23
|
|
var r10;
|
|
var r11;
|
|
var r13;
|
|
var r7;
|
|
var r9;
|
|
var r3;
|
|
var isZero;
|
|
var isNegative;
|
|
var isUnit;
|
|
var property;
|
|
var isNegative2;
|
|
var prev;
|
|
var isNegative3;
|
|
let value = this;
|
|
const value4 = parseValue(a0).toJSNumber();
|
|
if (shift_isSmall(value4)) {
|
|
if (value4 < 0) {
|
|
return value.shiftLeft(-value4);
|
|
}
|
|
if (value4 >= length) {
|
|
r10 = value;
|
|
r11 = value4;
|
|
reducibleLoop4: while (true) {
|
|
isZero = r10.isZero;
|
|
if (Reflect.apply(isZero, r10, [])) {
|
|
return r10;
|
|
}
|
|
isNegative = r10.isNegative;
|
|
if (Reflect.apply(isNegative, r10, [])) {
|
|
isUnit = r10.isUnit;
|
|
reducibleJoin7: while (true) {
|
|
if (Reflect.apply(isUnit, r10, [])) {
|
|
return r10;
|
|
}
|
|
break reducibleJoin7;
|
|
}
|
|
}
|
|
value = divModAny(r10, env0_6);
|
|
property = value[1];
|
|
isNegative = property.isNegative;
|
|
isNegative2 = Reflect.apply(isNegative, property, []);
|
|
property = value[0];
|
|
reducibleJoin9: while (true) {
|
|
if (isNegative2) {
|
|
prev = property.prev;
|
|
value = Reflect.apply(prev, property, []);
|
|
r13 = value;
|
|
break reducibleJoin9;
|
|
}
|
|
r13 = property;
|
|
break reducibleJoin9;
|
|
}
|
|
value = r11 - (length - 1);
|
|
if (value >= length) {
|
|
r10 = r13;
|
|
r11 = value;
|
|
continue reducibleLoop4;
|
|
}
|
|
r7 = r13;
|
|
r9 = value;
|
|
break reducibleLoop4;
|
|
}
|
|
} else {
|
|
r7 = value;
|
|
r9 = value4;
|
|
}
|
|
value = divModAny(r7, env0_4[r9]);
|
|
property = value[1];
|
|
isNegative3 = property.isNegative();
|
|
property = value[0];
|
|
reducibleJoin12: while (true) {
|
|
if (isNegative3) {
|
|
prev = property.prev;
|
|
value = Reflect.apply(prev, property, []);
|
|
r3 = value;
|
|
break reducibleJoin12;
|
|
}
|
|
r3 = property;
|
|
break reducibleJoin12;
|
|
}
|
|
return r3;
|
|
}
|
|
const Error = global.Error;
|
|
const String = global.String;
|
|
value = String(value4);
|
|
value += ' is too large for shifting.';
|
|
const value5 = Object.create(Error.prototype, {constructor: {value: Error}});
|
|
const error = new Error(value);
|
|
throw error instanceof Object ? error : value5;
|
|
}
|
|
|
|
function and(a0) { // fn#1072, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:29:19440, offset: 0x00c52bd4, size: 31 bytes, params: 2, frame: 15
|
|
return bitwise(this, a0, function(a0, a1) {
|
|
return a0 & a1;
|
|
});
|
|
}
|
|
|
|
function or(a0) { // fn#1074, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:29:19607, offset: 0x00c52bff, size: 31 bytes, params: 2, frame: 15
|
|
return bitwise(this, a0, function(a0, a1) {
|
|
return a0 | a1;
|
|
});
|
|
}
|
|
|
|
function xor(a0) { // fn#1076, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:29:19772, offset: 0x00c52c2a, size: 31 bytes, params: 2, frame: 15
|
|
return bitwise(this, a0, function(a0, a1) {
|
|
return a0 ^ a1;
|
|
});
|
|
}
|
|
|
|
function bitLength() { // fn#1078, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:29:20863, offset: 0x00c52c55, size: 167 bytes, params: 1, frame: 17
|
|
var r4;
|
|
var r0;
|
|
var binding;
|
|
let value = this;
|
|
if (value.compareTo(env1_0(0)) < 0) {
|
|
value = value.negate();
|
|
value = value.subtract(env1_0(1));
|
|
r4 = value;
|
|
} else {
|
|
r4 = value;
|
|
}
|
|
if (r4.compareTo(env1_0(0)) === 0) {
|
|
r0 = env1_0(0);
|
|
} else {
|
|
binding = env1_0;
|
|
value = binding(integerLogarithm(r4, binding(2)).e);
|
|
value = value.add(env1_0(1));
|
|
r0 = value;
|
|
}
|
|
return r0;
|
|
}
|
|
|
|
function parseBase(a0, a1, a2, a3) { // fn#1079, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:29:21114, offset: 0x00c52cfc, size: 471 bytes, params: 5, frame: 29
|
|
var r3;
|
|
var r5;
|
|
var r12;
|
|
var r1;
|
|
var r0;
|
|
var r16;
|
|
var binding;
|
|
var toLowerCase;
|
|
var value2;
|
|
var value4;
|
|
var length3;
|
|
var property;
|
|
var Error;
|
|
var value6;
|
|
var error;
|
|
var value7;
|
|
var value10;
|
|
var push;
|
|
var slice;
|
|
var value12;
|
|
let value = a2;
|
|
reducibleJoin2: while (true) {
|
|
if (value) {
|
|
r3 = value;
|
|
break reducibleJoin2;
|
|
}
|
|
value = environment;
|
|
binding = env0_2;
|
|
r3 = binding;
|
|
break reducibleJoin2;
|
|
}
|
|
const String = global.String;
|
|
value = String(a0);
|
|
reducibleJoin4: while (true) {
|
|
if (a3) {
|
|
r5 = r3;
|
|
r12 = value;
|
|
break reducibleJoin4;
|
|
}
|
|
toLowerCase = value.toLowerCase;
|
|
value = Reflect.apply(toLowerCase, value, []);
|
|
toLowerCase = r3.toLowerCase;
|
|
value2 = Reflect.apply(toLowerCase, r3, []);
|
|
r5 = value2;
|
|
r12 = value;
|
|
break reducibleJoin4;
|
|
}
|
|
let length = r12.length;
|
|
const Math = global.Math;
|
|
value = Math.abs(a1);
|
|
const object = {};
|
|
const length2 = r5.length;
|
|
const value3 = 0;
|
|
if (value3 < length2) {
|
|
r1 = value3;
|
|
reducibleLoop5: while (true) {
|
|
object[r5[r1]] = r1;
|
|
value4 = typeof r1 === 'bigint' ? r1 + 1n : +r1 + 1;
|
|
length3 = r5.length;
|
|
if (value4 < length3) {
|
|
r1 = value4;
|
|
continue reducibleLoop5;
|
|
}
|
|
break reducibleLoop5;
|
|
}
|
|
}
|
|
const value5 = 1;
|
|
if (value3 < length) {
|
|
r0 = value3;
|
|
reducibleLoop7: while (true) {
|
|
property = r12[r0];
|
|
if (property !== '-') {
|
|
reducibleJoin13: while (true) {
|
|
if (property in object) {
|
|
if (object[property] >= value) {
|
|
if (property !== '1') {
|
|
Error = global.Error;
|
|
value = property + ' is not a valid digit in base ' + a1;
|
|
value6 = Object.create(Error.prototype, {constructor: {value: Error}});
|
|
value += '.';
|
|
error = new Error(value);
|
|
value = error instanceof Object ? error : value6;
|
|
throw value;
|
|
}
|
|
if (value5 !== value) {
|
|
Error = global.Error;
|
|
value = property + ' is not a valid digit in base ' + a1;
|
|
value6 = Object.create(Error.prototype, {constructor: {value: Error}});
|
|
value += '.';
|
|
error = new Error(value);
|
|
value = error instanceof Object ? error : value6;
|
|
throw value;
|
|
}
|
|
break reducibleJoin13;
|
|
}
|
|
break reducibleJoin13;
|
|
}
|
|
break reducibleJoin13;
|
|
}
|
|
}
|
|
value7 = typeof r0 === 'bigint' ? r0 + 1n : +r0 + 1;
|
|
if (value7 < length) {
|
|
r0 = value7;
|
|
continue reducibleLoop7;
|
|
}
|
|
break reducibleLoop7;
|
|
}
|
|
}
|
|
value = environment;
|
|
const value8 = parseValue(a1);
|
|
const items2 = [];
|
|
const value9 = r12[value3] === '-';
|
|
let r10 = value9 ? value5 : value3;
|
|
length = r12.length;
|
|
if (r10 < length) {
|
|
reducibleLoop16: while (true) {
|
|
property = r12[r10];
|
|
if (property in object) {
|
|
push = items2.push;
|
|
Reflect.apply(push, items2, [parseValue(object[property])]);
|
|
r5 = r10;
|
|
} else {
|
|
if (property !== '<') {
|
|
throw new global.Error(property + ' is not a valid character');
|
|
}
|
|
r16 = r10;
|
|
reducibleLoop18: while (true) {
|
|
value10 = typeof r16 === 'bigint' ? r16 + 1n : +r16 + 1;
|
|
if (r12[value10] === '>') {
|
|
break reducibleLoop18;
|
|
}
|
|
length = r12.length;
|
|
if (value10 < length) {
|
|
r16 = value10;
|
|
continue reducibleLoop18;
|
|
}
|
|
break reducibleLoop18;
|
|
}
|
|
push = items2.push;
|
|
parseValueBinding = parseValue;
|
|
slice = r12.slice;
|
|
Reflect.apply(push, items2, [parseValueBinding(Reflect.apply(slice, r12, [r10 + value5, value10]))]);
|
|
r5 = value10;
|
|
}
|
|
value12 = typeof r5 === 'bigint' ? r5 + 1n : +r5 + 1;
|
|
length = r12.length;
|
|
if (!(value12 < length)) {
|
|
return parseBaseFromArray(items2, value8, value9);
|
|
}
|
|
r10 = value12;
|
|
continue reducibleLoop16;
|
|
}
|
|
}
|
|
return parseBaseFromArray(items2, value8, value9);
|
|
}
|
|
|
|
function toString_1083(a0, a1) { // fn#1083, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:29:24427, offset: 0x00c52eea, size: 172 bytes, params: 3, frame: 24
|
|
var r4;
|
|
var r1;
|
|
var r7;
|
|
var r2;
|
|
var value6;
|
|
var slice;
|
|
var value7;
|
|
var value8;
|
|
let value = a0;
|
|
reducibleJoin2: while (true) {
|
|
if (value !== env0_0) {
|
|
r4 = value;
|
|
break reducibleJoin2;
|
|
}
|
|
value = 10;
|
|
r4 = value;
|
|
break reducibleJoin2;
|
|
}
|
|
if (r4 !== 10) {
|
|
return toBaseString(this, r4, a1);
|
|
}
|
|
value = this.value;
|
|
let length = value.length;
|
|
let String = global.String;
|
|
const value3 = typeof length === 'bigint' ? length - 1n : +length - 1;
|
|
const value4 = String(value[value3]);
|
|
const value5 = typeof value3 === 'bigint' ? value3 - 1n : +value3 - 1;
|
|
if (value5 >= 0) {
|
|
r1 = value4;
|
|
r7 = value5;
|
|
reducibleLoop4: while (true) {
|
|
String = global.String;
|
|
value6 = String(value[r7]);
|
|
slice = '0000000'.slice;
|
|
length = value6.length;
|
|
value7 = r1 + (Reflect.apply(slice, '0000000', [length]) + value6);
|
|
value8 = typeof r7 === 'bigint' ? r7 - 1n : +r7 - 1;
|
|
if (value8 >= 0) {
|
|
r1 = value7;
|
|
r7 = value8;
|
|
continue reducibleLoop4;
|
|
}
|
|
r2 = value7;
|
|
break reducibleLoop4;
|
|
}
|
|
} else {
|
|
r2 = value4;
|
|
}
|
|
const sign = this.sign;
|
|
value = '';
|
|
reducibleJoin7: while (true) {
|
|
if (sign) {
|
|
value = '-';
|
|
r1 = value;
|
|
break reducibleJoin7;
|
|
}
|
|
r1 = value;
|
|
break reducibleJoin7;
|
|
}
|
|
return r1 + r2;
|
|
}
|
|
|
|
function toString_1084(a0, a1) { // fn#1084, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:29:24660, offset: 0x00c52f96, size: 67 bytes, params: 3, frame: 16
|
|
var r0;
|
|
var String;
|
|
let value = a0;
|
|
const r5 = value !== env0_0 ? value : 10;
|
|
if (r5 != 10) {
|
|
r0 = toBaseString(this, r5, a1);
|
|
} else {
|
|
String = global.String;
|
|
value = this.value;
|
|
value = String(value);
|
|
r0 = value;
|
|
}
|
|
return r0;
|
|
}
|
|
|
|
function lcm(a0, a1) { // fn#1089, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:29:25532, offset: 0x00c53012, size: 79 bytes, params: 3, frame: 14
|
|
const parseValueBinding = parseValue;
|
|
const value3 = parseValueBinding(a0).abs();
|
|
const value5 = parseValueBinding(a1).abs();
|
|
return value3.divide(gcd(value3, value5)).multiply(value5);
|
|
}
|
|
|
|
function isInstance(a0) { // fn#1090, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:29:25652, offset: 0x00c53061, size: 38 bytes, params: 2, frame: 4
|
|
let r0 = a0 instanceof BigInteger || a0 instanceof SmallInteger;
|
|
r0 = !r0 ? a0 instanceof NativeBigInt : r0;
|
|
return r0;
|
|
}
|
|
|
|
function randBetween(a0, a1, a2) { // fn#1091, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:29:25770, offset: 0x00c53087, size: 267 bytes, params: 4, frame: 24
|
|
var r4;
|
|
var r10;
|
|
var r12;
|
|
var Math;
|
|
var property;
|
|
var value13;
|
|
var value14;
|
|
let value = a2;
|
|
const parseValueBinding = parseValue;
|
|
const valueBinding = parseValueBinding(a0);
|
|
const valueBinding2 = parseValueBinding(a1);
|
|
const r6 = value || global.Math.random;
|
|
value = min(valueBinding, valueBinding2);
|
|
const value6 = max(valueBinding, valueBinding2).subtract(value);
|
|
let add = value6.add;
|
|
const value7 = Reflect.apply(add, value6, [1]);
|
|
if (value7.isSmall) {
|
|
add = value.add;
|
|
Math = global.Math;
|
|
return Reflect.apply(add, value, [Math.floor(r6() * value7)]);
|
|
}
|
|
const toBaseBinding = toBase;
|
|
const value8 = 10000000;
|
|
const value9 = toBaseBinding(value7, value8).value;
|
|
const items2 = [];
|
|
let length = value9.length;
|
|
const value10 = 0;
|
|
const value11 = false;
|
|
if (value10 < length) {
|
|
r4 = true;
|
|
r10 = value10;
|
|
while (true) {
|
|
if (r4) {
|
|
property = value9[r10];
|
|
r12 = property;
|
|
} else {
|
|
r12 = value8;
|
|
}
|
|
value13 = truncate(r6() * r12);
|
|
items2.push(value13);
|
|
if (value13 < r12) {
|
|
r4 = value11;
|
|
continue;
|
|
}
|
|
continue;
|
|
value14 = typeof r10 === 'bigint' ? r10 + 1n : +r10 + 1;
|
|
length = value9.length;
|
|
if (value14 < length) {
|
|
r10 = value14;
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
return value.add(Integer.fromArray(items2, value8, value11));
|
|
}
|
|
|
|
}
|
|
|
|
function _fun1093() { // fn#1093, offset: 0x00c36f09, size: 9 bytes, params: 1, frame: 1
|
|
return env0_0;
|
|
}
|
|
|
|
}
|
|
|
|
function smallToArray(a0) { // fn#969, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:29:511, offset: 0x00c4f269, size: 157 bytes, params: 2, frame: 16
|
|
var r0;
|
|
var items2;
|
|
var Math;
|
|
var floor;
|
|
if (a0 < 10000000) {
|
|
r0 = [a0];
|
|
} else if (a0 < 100000000000000) {
|
|
Math = global.Math;
|
|
r0 = [a0 % 10000000, Math.floor(a0 / 10000000)];
|
|
} else {
|
|
items2 = [a0 % 10000000];
|
|
Math = global.Math;
|
|
floor = Math.floor;
|
|
items2[1] = Reflect.apply(floor, Math, [a0 / 10000000]) % 10000000;
|
|
Math = global.Math;
|
|
floor = Math.floor;
|
|
items2[2] = Reflect.apply(floor, Math, [a0 / 100000000000000]);
|
|
r0 = items2;
|
|
}
|
|
return r0;
|
|
}
|
|
|
|
function add(a0, a1) { // fn#974, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:29:1021, offset: 0x00c4f439, size: 197 bytes, params: 3, frame: 23
|
|
var r3;
|
|
var r9;
|
|
var r13;
|
|
var r2;
|
|
var r4;
|
|
var property;
|
|
var value4;
|
|
var value5;
|
|
var value6;
|
|
var value7;
|
|
var value8;
|
|
const length = a0.length;
|
|
const length2 = a1.length;
|
|
const Array = global.Array;
|
|
const array = new Array(length);
|
|
const value2 = 0;
|
|
const value3 = 1;
|
|
if (value2 < length2) {
|
|
r3 = value2;
|
|
r9 = value2;
|
|
while (true) {
|
|
property = a0[r9];
|
|
value4 = property + a1[r9] + r3;
|
|
r13 = value4 >= 10000000 ? value3 : value2;
|
|
array[r9] = value4 - r13 * 10000000;
|
|
value5 = typeof r9 === 'bigint' ? r9 + 1n : +r9 + 1;
|
|
if (value5 < length2) {
|
|
r3 = r13;
|
|
r9 = value5;
|
|
continue;
|
|
}
|
|
r2 = r13;
|
|
r4 = value5;
|
|
break;
|
|
}
|
|
} else {
|
|
r2 = value2;
|
|
r4 = value2;
|
|
}
|
|
if (r4 < length) {
|
|
r3 = r2;
|
|
while (true) {
|
|
value6 = a0[r4] + r3;
|
|
r9 = value6 !== 10000000 ? value2 : value3;
|
|
value7 = typeof r4 === 'bigint' ? r4 : +r4;
|
|
value8 = typeof value7 === 'bigint' ? value7 + 1n : +value7 + 1;
|
|
array[value7] = value6 - r9 * 10000000;
|
|
if (value8 < length) {
|
|
r3 = r9;
|
|
r4 = value8;
|
|
continue;
|
|
}
|
|
r2 = r9;
|
|
break;
|
|
}
|
|
}
|
|
if (r2 > value2) {
|
|
array.push(r2);
|
|
}
|
|
return array;
|
|
}
|
|
|
|
function addSmall(a0, a1) { // fn#976, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:29:1277, offset: 0x00c4f534, size: 174 bytes, params: 3, frame: 23
|
|
var r6;
|
|
var r7;
|
|
var r1;
|
|
var r2;
|
|
var Math;
|
|
var value5;
|
|
var value6;
|
|
var value7;
|
|
let value = a1;
|
|
const length = a0.length;
|
|
const Array = global.Array;
|
|
const array = new Array(length);
|
|
const value4 = 0;
|
|
if (value4 < length) {
|
|
r6 = value4;
|
|
for (r7 = value; true; r7 = value) {
|
|
value = a0[r6] - 10000000 + r7;
|
|
Math = global.Math;
|
|
value5 = Math.floor(value / 10000000);
|
|
array[r6] = value - value5 * 10000000;
|
|
value = value5 + 1;
|
|
value6 = typeof r6 === 'bigint' ? r6 + 1n : +r6 + 1;
|
|
if (!(value6 < length)) {
|
|
r1 = value6;
|
|
r2 = value;
|
|
break;
|
|
}
|
|
r6 = value6;
|
|
}
|
|
} else {
|
|
r1 = value4;
|
|
r2 = value;
|
|
}
|
|
if (r2 > value4) {
|
|
while (true) {
|
|
value = typeof r1 === 'bigint' ? r1 : +r1;
|
|
value7 = typeof value === 'bigint' ? value + 1n : +value + 1;
|
|
array[value] = r2 % 10000000;
|
|
Math = global.Math;
|
|
value = Math.floor(r2 / 10000000);
|
|
if (!(value > value4)) {
|
|
break;
|
|
}
|
|
r1 = value7;
|
|
r2 = value;
|
|
}
|
|
}
|
|
return array;
|
|
}
|
|
|
|
function multiplySmall(a0, a1) { // fn#980, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:29:2117, offset: 0x00c4f836, size: 171 bytes, params: 3, frame: 23
|
|
var r6;
|
|
var r7;
|
|
var r1;
|
|
var r2;
|
|
var value3;
|
|
var Math;
|
|
var value4;
|
|
var value5;
|
|
var value6;
|
|
var value7;
|
|
var value8;
|
|
const length = a0.length;
|
|
const Array = global.Array;
|
|
const array = new Array(length);
|
|
const value2 = 0;
|
|
if (value2 < length) {
|
|
r6 = value2;
|
|
for (r7 = value2; true; r7 = value5) {
|
|
value3 = a0[r7] * a1 + r6;
|
|
Math = global.Math;
|
|
value4 = Math.floor(value3 / 10000000);
|
|
array[r7] = value3 - value4 * 10000000;
|
|
value5 = typeof r7 === 'bigint' ? r7 + 1n : +r7 + 1;
|
|
if (!(value5 < length)) {
|
|
r1 = value4;
|
|
r2 = value5;
|
|
break;
|
|
}
|
|
r6 = value4;
|
|
}
|
|
} else {
|
|
r1 = value2;
|
|
r2 = value2;
|
|
}
|
|
if (r1 > value2) {
|
|
while (true) {
|
|
value6 = typeof r2 === 'bigint' ? r2 : +r2;
|
|
value7 = typeof value6 === 'bigint' ? value6 + 1n : +value6 + 1;
|
|
array[value6] = r1 % 10000000;
|
|
Math = global.Math;
|
|
value8 = Math.floor(r1 / 10000000);
|
|
if (!(value8 > value2)) {
|
|
break;
|
|
}
|
|
r1 = value8;
|
|
r2 = value7;
|
|
}
|
|
}
|
|
return array;
|
|
}
|
|
|
|
function isBasicPrime(a0) { // fn#988, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:29:5285, offset: 0x00c502f4, size: 175 bytes, params: 2, frame: 14
|
|
var r1;
|
|
var r2;
|
|
var r0;
|
|
let value = a0.abs();
|
|
const isUnit2 = value.isUnit();
|
|
if (isUnit2) {
|
|
r0 = !isUnit2;
|
|
} else {
|
|
r1 = value.equals(2) || value.equals(3);
|
|
r1 = !r1 ? value.equals(5) : r1;
|
|
if (r1) {
|
|
r1 = !!r1;
|
|
} else {
|
|
r2 = value.isEven() || value.isDivisibleBy(3);
|
|
r2 = !r2 ? value.isDivisibleBy(5) : r2;
|
|
if (r2) {
|
|
r2 = !r2;
|
|
} else {
|
|
value = value.lesser(49);
|
|
r2 = value ? !!value : undefined;
|
|
}
|
|
r1 = r2;
|
|
}
|
|
r0 = r1;
|
|
}
|
|
return r0;
|
|
}
|
|
|
|
function _fun1073(a0, a1) { // fn#1073, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:29:19475, offset: 0x00c52bf3, size: 12 bytes, params: 3, frame: 2
|
|
return a0 & a1;
|
|
}
|
|
|
|
function _fun1075(a0, a1) { // fn#1075, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:29:19642, offset: 0x00c52c1e, size: 12 bytes, params: 3, frame: 2
|
|
return a0 | a1;
|
|
}
|
|
|
|
function _fun1077(a0, a1) { // fn#1077, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:29:19807, offset: 0x00c52c49, size: 12 bytes, params: 3, frame: 2
|
|
return a0 ^ a1;
|
|
}
|
|
|
|
global.__d(_fun962, 24, []) /* metro module 24 */;
|