/* 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 */;