discord-decomp/sources/by-id/module-00024.jsx

/* 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 closure = 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 closure5 = smallToArray;
    const trim_971 = 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_973 = 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_973(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 closure6 = max_994;
    const closure7 = min_995;
    const closure8 = gcd;
    const closure9 = parseValue_1002;
    const env0_1 = closure5(9007199254740992);
    const BigInt = global.BigInt;
    const result = typeof BigInt === 'function';
    let Object = global.Object;
    const create = Object.create;
    let prototype = closure.prototype;
    closure2.prototype = Reflect.apply(create, Object, [prototype]);
    Object = global.Object;
    closure3.prototype = Object.create(closure.prototype);
    Object = global.Object;
    closure4.prototype = Object.create(closure.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_1009;
    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_1015;
    closure2.prototype.times = closure2.prototype.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_1024;
    prototype = closure4.prototype;
    const prototype13 = closure4.prototype;
    const closure10 = divide_1025;
    prototype13.divide = closure10;
    prototype.over = closure10;
    prototype = closure3.prototype;
    const prototype14 = closure3.prototype;
    const prototype15 = closure2.prototype;
    const divide = closure2.prototype.divide;
    prototype15.over = divide;
    prototype14.divide = divide;
    prototype.over = divide;
    closure2.prototype.mod = mod_1026;
    prototype = closure4.prototype;
    const prototype17 = closure4.prototype;
    const closure11 = remainder;
    prototype17.remainder = closure11;
    prototype.mod = closure11;
    prototype = closure3.prototype;
    const prototype18 = closure3.prototype;
    const prototype19 = closure2.prototype;
    const 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_1063;
    closure3.prototype.next = next_1064;
    closure4.prototype.next = next_1065;
    closure2.prototype.prev = prev_1066;
    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) {
        closure[r7] = closure9(r7);
        if (r7 > value) {
            value2 = -r7;
            closure[value2] = closure9(value2);
        }
        value3 = typeof r7 === 'bigint' ? r7 + 1n : +r7 + 1;
        if (value3 < 1000) {
            r7 = value3;
            continue;
        }
        break;
    }
    closure.one = closure[1];
    closure.zero = closure[value];
    closure.minusOne = closure[-1];
    closure.max = closure6;
    closure.min = closure7;
    closure.gcd = closure8;
    closure.lcm = lcm;
    closure.isInstance = isInstance_1090;
    closure.randBetween = randBetween;
    closure.fromArray = function(a0, a1, a2) {
        var value = a1;
        var parseBaseFromArrayBinding = parseBaseFromArray;
        var parseValue_1002Binding = parseValue_1002;
        return parseBaseFromArrayBinding(a0.map(parseValue_1002Binding), parseValue_1002Binding(value || 10), a2);
    };
    return closure;
}

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_1002(a0) : Number(a1) !== 10 || a2 ? parseBase(a0,
        a1, a2, a3) : parseValue_1002(a0);
}

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 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_971(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 add_974(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 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_974(a0, a1) : add_974(a1, a0);
}

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 subtract_977(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_971(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_971(array);
    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 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_977Binding = subtract_977;
    value = addAnyBinding(addAnyBinding(value7, shiftLeft_2Binding(subtract_977Binding(subtract_977Binding(value10,
        value7), value8), value)), shiftLeft_2Binding(value8, 2 * value));
    trim_971(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_971(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 value5;
    var length3;
    var items3;
    var items2;
    var unshift;
    var value9;
    var value10;
    var value11;
    var value12;
    var value13;
    var value14;
    var ceil;
    var value15;
    var multiplySmallBinding;
    var value16;
    var value17;
    var push;
    var value18;
    var arrayToSmallBinding;
    var length4;
    var array;
    var value20;
    var property;
    var value21;
    var value22;
    var value23;
    var value24;
    var floor;
    var value26;
    var value27;
    var value28;
    var value29;
    var property2;
    var value30;
    var value31;
    var value32;
    var value33;
    var value34;
    var value35;
    var value36;
    var value37;
    var value38;
    var value39;
    var sign;
    var prototype;
    var bigInteger;
    var value44;
    var smallInteger;
    var value47;
    var value48;
    var value49;
    var value50;
    var value51;
    var sign4;
    var value52;
    var value54;
    var value56;
    var value57;
    var value59;
    var nativeBigInt;
    var value61;
    var value;
    const value_1002 = parseValue_1002(a1);
    if (result) {
        value = a0.value;
        value /= value_1002.value;
        prototype = NativeBigInt.prototype;
        value59 = Object.create(prototype, {constructor: {value: NativeBigInt}});
        nativeBigInt = new NativeBigInt();
        value = nativeBigInt instanceof Object ? nativeBigInt : value59;
        items3 = [value];
        value = a0.value;
        value %= value_1002.value;
        prototype = NativeBigInt.prototype;
        value61 = Object.create(prototype, {constructor: {value: NativeBigInt}});
        nativeBigInt = new NativeBigInt();
        value = nativeBigInt instanceof Object ? nativeBigInt : value61;
        items3[1] = value;
        return items3;
    }
    const value2 = a0.value;
    const value3 = value_1002.value;
    const value4 = 0;
    if (value4 === value3) {
        throw new global.Error('Cannot divide by zero');
    }
    const isSmall = a0.isSmall;
    const isSmall2 = value_1002.isSmall;
    if (isSmall) {
        if (isSmall2) {
            value = truncate_973(value2 / value3);
            prototype = SmallInteger.prototype;
            value56 = Object.create(prototype, {constructor: {value: SmallInteger}});
            smallInteger = new SmallInteger();
            value = smallInteger instanceof Object ? smallInteger : value56;
            items3 = [value];
            value = value2 % value3;
            prototype = SmallInteger.prototype;
            value57 = Object.create(prototype, {constructor: {value: SmallInteger}});
            smallInteger = new SmallInteger();
            value = smallInteger instanceof Object ? smallInteger : value57;
            items3[1] = value;
            r3 = items3;
        } else {
            r3 = [Integer[value4], a0];
        }
        return r3;
    }
    if (isSmall2) {
        if (value3 === 1) {
            return [a0, Integer[value4]];
        }
        if (value3 == -1) {
            items3 = [a0.negate()];
            items3[1] = Integer[value4];
            return items3;
        }
        Math = global.Math;
        value5 = Math.abs(value3);
        if (value5 < 10000000) {
            arrayToSmallBinding = arrayToSmall;
            value49 = divModSmall(value2, value5);
            value50 = arrayToSmallBinding(value49[value4]);
            property = value49[1];
            sign = a0.sign;
            reducibleJoin58: while (true) {
                if (sign) {
                    value51 = -property;
                    r12 = value51;
                    break reducibleJoin58;
                }
                r12 = property;
                break reducibleJoin58;
            }
            if (typeof value50 === 'number') {
                reducibleJoin62: while (true) {
                    if (a0.sign === value_1002.sign) {
                        r8 = value50;
                        break reducibleJoin62;
                    }
                    value54 = -value50;
                    r8 = value54;
                    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 = value_1002.sign;
                prototype = BigInteger.prototype;
                value52 = Object.create(prototype, {constructor: {value: BigInteger}});
                bigInteger = new BigInteger(value50, sign !== sign4);
                items3 = [bigInteger instanceof Object ? bigInteger : value52];
                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(value5);
    } else {
        r12 = value3;
    }
    const value7 = compareAbs(value2, r12);
    const value8 = -1;
    if (value8 === value7) {
        return [Integer[value4], a0];
    }
    if (value4 === value7) {
        reducibleJoin54: while (true) {
            if (a0.sign !== value_1002.sign) {
                r11 = value8;
                break reducibleJoin54;
            }
            value48 = 1;
            r11 = value48;
            break reducibleJoin54;
        }
        return [Integer[r11], Integer[value4]];
    }
    let length = value2.length;
    if (length + r12.length <= 200) {
        length = value2.length;
        length4 = r12.length;
        array = createArray(r12.length);
        value20 = 1;
        property = r12[length4 - value20];
        Math = global.Math;
        value21 = Math.ceil(10000000 / (2 * property));
        multiplySmallBinding = multiplySmall;
        value22 = multiplySmallBinding(value2, value21);
        value23 = multiplySmallBinding(r12, value21);
        reducibleJoin24: while (true) {
            if (value22.length <= length) {
                push = value22.push;
                Reflect.apply(push, value22, [value4]);
                break reducibleJoin24;
            }
            break reducibleJoin24;
        }
        value23.push(value4);
        property = value23[length4 - value20];
        value24 = length - length4;
        if (value24 >= value4) {
            r16 = value24;
            reducibleLoop25: while (true) {
                reducibleJoin27: while (true) {
                    if (value22[r16 + length4] === property) {
                        r23 = 9999999;
                        break reducibleJoin27;
                    }
                    Math = global.Math;
                    floor = Math.floor;
                    value26 = value22[r16 + length4] * 10000000;
                    value27 = Reflect.apply(floor, Math, [(value26 + value22[r16 + length4 - value20]) / property]);
                    r23 = value27;
                    break reducibleJoin27;
                }
                length = value23.length;
                if (value4 < length) {
                    r24 = value4;
                    r27 = value4;
                    r28 = value4;
                    reducibleLoop28: while (true) {
                        value28 = r28 + r23 * value23[r24];
                        Math = global.Math;
                        floor = Math.floor;
                        value29 = Reflect.apply(floor, Math, [value28 / 10000000]);
                        property2 = value22[r16 + r24];
                        value30 = r27 + (property2 - (value28 - value29 * 10000000));
                        if (value30 < value4) {
                            value31 = r16 + r24;
                            value22[value31] = value30 + 10000000;
                            r29 = value8;
                        } else {
                            value22[r16 + r24] = value30;
                            r29 = value4;
                        }
                        value32 = typeof r24 === 'bigint' ? r24 + 1n : +r24 + 1;
                        if (value32 < length) {
                            r24 = value32;
                            r27 = r29;
                            r28 = value29;
                            continue reducibleLoop28;
                        }
                        r25 = r29;
                        break reducibleLoop28;
                    }
                } else {
                    r25 = value4;
                }
                if (value4 !== r25) {
                    r24 = r23;
                    reducibleLoop33: while (true) {
                        value33 = r24 - value20;
                        if (value4 < length) {
                            r29 = value4;
                            r30 = value4;
                            reducibleLoop34: while (true) {
                                value34 = value22[r16 + r29] - 10000000;
                                value35 = r30 + (value34 + value23[r29]);
                                if (value35 < value4) {
                                    value36 = r16 + r29;
                                    value22[value36] = value35 + 10000000;
                                    r31 = value4;
                                } else {
                                    value22[r16 + r29] = value35;
                                    r31 = value20;
                                }
                                value37 = typeof r29 === 'bigint' ? r29 + 1n : +r29 + 1;
                                if (value37 < length) {
                                    r29 = value37;
                                    r30 = r31;
                                    continue reducibleLoop34;
                                }
                                r28 = r31;
                                break reducibleLoop34;
                            }
                        } else {
                            r28 = value4;
                        }
                        value38 = r25 + r28;
                        if (value4 !== value38) {
                            r24 = value33;
                            r25 = value38;
                            continue reducibleLoop33;
                        }
                        r23 = value33;
                        break reducibleLoop33;
                    }
                }
                array[r16] = r23;
                value39 = typeof r16 === 'bigint' ? r16 - 1n : +r16 - 1;
                if (value39 >= value4) {
                    r16 = value39;
                    continue reducibleLoop25;
                }
                break reducibleLoop25;
            }
        }
        property = divModSmall(value22, value21)[value4];
        arrayToSmallBinding = arrayToSmall;
        r13 = [arrayToSmallBinding(array), arrayToSmallBinding(property)];
    } else {
        length = value2.length;
        length3 = r12.length;
        items3 = [];
        items2 = [];
        if (length) {
            r7 = items2;
            r24 = length;
            reducibleLoop12: while (true) {
                unshift = r7.unshift;
                value9 = typeof r24 === 'bigint' ? r24 - 1n : +r24 - 1;
                Reflect.apply(unshift, r7, [value2[value9]]);
                trim_971(r7);
                compareAbsBinding = compareAbs;
                if (compareAbsBinding(r7, r12) < value4) {
                    push = items3.push;
                    Reflect.apply(push, items3, [value4]);
                    r25 = r7;
                } else {
                    length = r7.length;
                    value10 = r7[length - 1] * 10000000;
                    value11 = value10 + r7[length - 2];
                    value12 = r12[length3 - 1] * 10000000;
                    value13 = value12 + r12[length3 - 2];
                    reducibleJoin15: while (true) {
                        if (length > length3) {
                            value14 = (value11 + 1) * 10000000;
                            r28 = value14;
                            break reducibleJoin15;
                        }
                        r28 = value11;
                        break reducibleJoin15;
                    }
                    Math = global.Math;
                    ceil = Math.ceil;
                    value15 = Reflect.apply(ceil, Math, [r28 / value13]);
                    r25 = value15;
                    reducibleLoop16: while (true) {
                        compareAbsBinding = compareAbs;
                        value16 = multiplySmall(r12, r25);
                        if (compareAbsBinding(value16, r7) <= value4) {
                            r29 = r25;
                            break reducibleLoop16;
                        }
                        value17 = typeof r25 === 'bigint' ? r25 - 1n : +r25 - 1;
                        if (value17) {
                            r25 = value17;
                            continue reducibleLoop16;
                        }
                        r29 = value17;
                        break reducibleLoop16;
                    }
                    push = items3.push;
                    Reflect.apply(push, items3, [r29]);
                    value18 = subtract_977(r7, value16);
                    r25 = value18;
                }
                if (value9) {
                    r7 = r25;
                    r24 = value9;
                    continue reducibleLoop12;
                }
                r12 = r25;
                break reducibleLoop12;
            }
        } else {
            r12 = items2;
        }
        items3.reverse();
        arrayToSmallBinding = arrayToSmall;
        items3 = [arrayToSmallBinding(items3), arrayToSmallBinding(r12)];
        r13 = items3;
    }
    property = r13[value4];
    const value41 = a0.sign !== value_1002.sign;
    const property3 = r13[1];
    sign = a0.sign;
    if (typeof property === 'number') {
        reducibleJoin45: while (true) {
            if (value41) {
                value44 = -property;
                r17 = value44;
                break reducibleJoin45;
            }
            r17 = property;
            break reducibleJoin45;
        }
        smallInteger = new SmallInteger();
    } else {
        bigInteger = new BigInteger(property, value41);
    }
    if (typeof property3 === 'number') {
        reducibleJoin50: while (true) {
            if (sign) {
                value47 = -property3;
                r15 = value47;
                break reducibleJoin50;
            }
            r15 = property3;
            break reducibleJoin50;
        }
        r12 = new SmallInteger();
    } else {
        r12 = new BigInteger(property3);
    }
    return [r13, r12];
}

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 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 value5;
    var value6;
    var value7;
    var value8;
    var value9;
    var property2;
    var push;
    var multiply;
    var add;
    var binding;
    var value11;
    let value = a0;
    const value_1002 = parseValue_1002(a1);
    const isNegative2 = value.isNegative();
    const isNegative3 = value_1002.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 = value_1002.not;
            value = Reflect.apply(not, value_1002, []);
            r11 = value;
            break reducibleJoin4;
        }
        r11 = value_1002;
        break reducibleJoin4;
    }
    const items2 = [];
    value = r12.isZero();
    const value3 = 0;
    const value4 = 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[value4];
                toJSNumber = property.toJSNumber;
                value5 = Reflect.apply(toJSNumber, property, []);
                reducibleJoin8: while (true) {
                    if (isNegative2) {
                        value6 = env0_6 - value4 - value5;
                        r14 = value6;
                        break reducibleJoin8;
                    }
                    r14 = value5;
                    break reducibleJoin8;
                }
                value7 = divModAny(r9, env0_6);
                property = value7[value4];
                toJSNumber = property.toJSNumber;
                value8 = Reflect.apply(toJSNumber, property, []);
                reducibleJoin10: while (true) {
                    if (isNegative3) {
                        value9 = env0_6 - value4 - value8;
                        r1 = value9;
                        break reducibleJoin10;
                    }
                    r1 = value8;
                    break reducibleJoin10;
                }
                property = value[value3];
                property2 = value7[value3];
                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[value4];
            toJSNumber = property.toJSNumber;
            value5 = Reflect.apply(toJSNumber, property, []);
            reducibleJoin8: while (true) {
                if (isNegative2) {
                    value6 = env0_6 - value4 - value5;
                    r14 = value6;
                    break reducibleJoin8;
                }
                r14 = value5;
                break reducibleJoin8;
            }
            value7 = divModAny(r9, env0_6);
            property = value7[value4];
            toJSNumber = property.toJSNumber;
            value8 = Reflect.apply(toJSNumber, property, []);
            reducibleJoin10: while (true) {
                if (isNegative3) {
                    value9 = env0_6 - value4 - value8;
                    r1 = value9;
                    break reducibleJoin10;
                }
                r1 = value8;
                break reducibleJoin10;
            }
            property = value[value3];
            property2 = value7[value3];
            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 ? value4 : value3;
    let r0 = isNegative3 ? value4 : value3;
    if (value3 !== a2(r1, r0)) {
        value = environment.__proto__;
        value = env1_0(-1);
        r0 = value;
    } else {
        value = environment.__proto__;
        value = env1_0(value3);
        r0 = value;
    }
    value = items2.length - value4;
    if (value >= value3) {
        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])]);
            value11 = r3 - value4;
            if (value11 >= value3) {
                r1 = value;
                r3 = value11;
                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 object2 = {};
    value = environment.__proto__;
    object2.p = env1_0(1);
    object2.e = 0;
    return object2;
}

function max_994(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 parseValue_1002Binding = parseValue_1002;
    const value_1002Binding = parseValue_1002Binding(a0);
    const value_1002 = parseValue_1002Binding(a1);
    return value_1002Binding.greater(value_1002) ? value_1002Binding : value_1002;
}

function min_995(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 parseValue_1002Binding = parseValue_1002;
    const value_1002Binding = parseValue_1002Binding(a0);
    const value_1002 = parseValue_1002Binding(a1);
    return value_1002Binding.lesser(value_1002) ? value_1002Binding : value_1002;
}

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 min_995Binding;
    var roughLOBBinding;
    var value4;
    var value5;
    var divide;
    var value6;
    var value7;
    var multiply;
    var value8;
    var value9;
    var value10;
    var greater;
    var subtract;
    var value11;
    let value = environment;
    const parseValue_1002Binding = parseValue_1002;
    const value2 = parseValue_1002Binding(a0).abs();
    const value3 = parseValue_1002Binding(a1).abs();
    if (value2.equals(value3)) {
        return value2;
    }
    let isZero = value2.isZero;
    if (Reflect.apply(isZero, value2, [])) {
        return value3;
    }
    if (value3.isZero()) {
        return value2;
    }
    const property = Integer[1];
    let isEven = value2.isEven;
    reducibleJoin7: while (true) {
        if (!Reflect.apply(isEven, value2, [])) {
            r3 = value2;
            r5 = property;
            r9 = value3;
            break reducibleJoin7;
        }
        isEven = value3.isEven;
        if (!Reflect.apply(isEven, value3, [])) {
            r3 = value2;
            r5 = property;
            r9 = value3;
            break reducibleJoin7;
        }
        r4 = property;
        r6 = value3;
        r10 = value2;
        reducibleLoop5: while (true) {
            min_995Binding = min_995;
            roughLOBBinding = roughLOB;
            value4 = roughLOBBinding(r10);
            value5 = min_995Binding(value4, roughLOBBinding(r6));
            divide = r10.divide;
            value6 = Reflect.apply(divide, r10, [value5]);
            divide = r6.divide;
            value7 = Reflect.apply(divide, r6, [value5]);
            multiply = r4.multiply;
            value8 = Reflect.apply(multiply, r4, [value5]);
            isEven = value6.isEven;
            if (Reflect.apply(isEven, value6, [])) {
                isEven = value7.isEven;
                if (Reflect.apply(isEven, value7, [])) {
                    r4 = value8;
                    r6 = value7;
                    r10 = value6;
                    continue reducibleLoop5;
                }
                r3 = value6;
                r5 = value8;
                r9 = value7;
                break reducibleJoin7;
            }
            r3 = value6;
            r5 = value8;
            r9 = value7;
            break reducibleJoin7;
        }
    }
    isEven = r3.isEven;
    if (Reflect.apply(isEven, r3, [])) {
        r4 = r3;
        reducibleLoop8: while (true) {
            divide = r4.divide;
            value9 = Reflect.apply(divide, r4, [roughLOB(r4)]);
            isEven = value9.isEven;
            if (Reflect.apply(isEven, value9, [])) {
                r4 = value9;
                continue reducibleLoop8;
            }
            r3 = r9;
            r6 = value9;
            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;
                value10 = Reflect.apply(divide, r9, [roughLOB(r9)]);
                isEven = value10.isEven;
                if (Reflect.apply(isEven, value10, [])) {
                    r9 = value10;
                    continue reducibleLoop10;
                }
                r2 = value10;
                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;
        value11 = Reflect.apply(subtract, r9, [r4]);
        isZero = value11.isZero;
        if (Reflect.apply(isZero, value11, [])) {
            break reducibleLoop9;
        }
        r3 = value11;
        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 object3 = {};
    object3.value = object.reverse();
    object3.isNegative = r0;
    return object3;
}

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 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_973(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_973(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_971(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_1002(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_973(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 value_1002 = parseValue_1002(a0);
    if (this.sign !== value_1002.sign) {
        return this.subtract(value_1002.negate());
    }
    const value2 = this.value;
    const value3 = value_1002.value;
    return value_1002.isSmall ? new BigInteger(addSmall(value2, global.Math.abs(value3)),
        this.sign) : new BigInteger(addAny(value2, value3), 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 value8;
    var smallInteger;
    var value;
    const value_1002 = parseValue_1002(a0);
    const value2 = this.value;
    if (value2 < 0 !== value_1002.sign) {
        return this.subtract(value_1002.negate());
    }
    const value4 = value_1002.value;
    if (value_1002.isSmall) {
        if (isPrecise(value2 + value4)) {
            value = value2 + value4;
            value8 = Object.create(SmallInteger.prototype, {constructor: {value: SmallInteger}});
            smallInteger = new SmallInteger();
            return smallInteger instanceof Object ? smallInteger : value8;
        }
        smallToArrayBinding = smallToArray;
        Math = global.Math;
        abs = Math.abs;
        r9 = smallToArrayBinding(Reflect.apply(abs, Math, [value4]));
        addSmallBinding = addSmall;
        Math = global.Math;
        abs = Math.abs;
        value = addSmallBinding(r9, Reflect.apply(abs, Math, [value2]));
    } else {
        r9 = value4;
        addSmallBinding = addSmall;
        Math = global.Math;
        value = addSmallBinding(r9, Math.abs(value2));
    }
    const value6 = value2 < 0;
    const value7 = Object.create(BigInteger.prototype, {constructor: {value: BigInteger}});
    const bigInteger = new BigInteger();
    return bigInteger instanceof Object ? bigInteger : value7;
}

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_1002(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 value5;
    var value6;
    var subtractSmallBinding;
    var value;
    const value_1002 = parseValue_1002(a0);
    let sign = this.sign;
    if (sign !== value_1002.sign) {
        return this.add(value_1002.negate());
    }
    const value2 = this.value;
    const value3 = value_1002.value;
    if (value_1002.isSmall) {
        subtractSmallBinding = subtractSmall;
        value = global.Math.abs(value3);
        value = subtractSmallBinding(value2, value, this.sign);
        r0 = value;
    } else {
        sign = this.sign;
        if (compareAbs(value2, value3) >= 0) {
            r4 = subtract_977(value2, value3);
            r5 = sign;
        } else {
            value5 = subtract_977(value3, value2);
            value6 = !sign;
            r4 = value5;
            r5 = value6;
        }
        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 value_1002 = parseValue_1002(a0);
    const value2 = this.value;
    if (value2 < 0 !== value_1002.sign) {
        return this.add(value_1002.negate());
    }
    const value4 = value_1002.value;
    if (value_1002.isSmall) {
        value = value2 - value4;
        r0 = new SmallInteger();
    } else {
        subtractSmallBinding = subtractSmall;
        value = global.Math.abs(value2);
        value = subtractSmallBinding(value4, value, value2 >= 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_1002(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_1009() { // 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_1015(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 value5;
    var bigInteger;
    var value12;
    var value;
    const value_1002 = parseValue_1002(a0);
    const value2 = this.value;
    const value3 = value_1002.value;
    const value4 = this.sign !== value_1002.sign;
    if (value_1002.isSmall) {
        if (value3 === 0) {
            return Integer[0];
        }
        if (value3 === 1) {
            return this;
        }
        if (value3 === -1) {
            return this.negate();
        }
        value5 = global.Math.abs(value3);
        if (value5 < 10000000) {
            value = multiplySmall(value2, value5);
            value12 = Object.create(BigInteger.prototype, {constructor: {value: BigInteger}});
            bigInteger = new BigInteger(value, value4);
            return bigInteger instanceof Object ? bigInteger : value12;
        }
        r9 = smallToArray(value5);
    } else {
        r9 = value3;
    }
    const length = value2.length;
    const length2 = r9.length;
    return -0.012 * length - 0.012 * length2 + 0.000015 * length * length2 > 0 ? new BigInteger(multiplyKaratsuba(value2,
        r9), value4) : new BigInteger(multiplyLong(value2, r9), value4);
}

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_1002(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_1002(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_1024(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_1002(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_1026(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_1002(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 value6;
    var property;
    var times;
    var value7;
    var value8;
    var square;
    var value9;
    var value10;
    var value11;
    var smallInteger;
    let value = this;
    const value_1002 = parseValue_1002(a0);
    const value3 = value.value;
    const value4 = value_1002.value;
    if (value4 === 0) {
        return Integer[1];
    }
    if (value3 === 0) {
        return Integer[0];
    }
    if (value3 === 1) {
        return Integer[1];
    }
    if (value3 === -1) {
        return value_1002.isEven() ? Integer[1] : Integer[-1];
    }
    if (value_1002.sign) {
        return Integer[0];
    }
    if (value_1002.isSmall) {
        if (value.isSmall) {
            isPreciseBinding = isPrecise;
            value6 = global.Math.pow(value3, value4);
            reducibleJoin9: while (true) {
                if (isPreciseBinding(value6)) {
                    value = truncate_973(value6);
                    value11 = Object.create(SmallInteger.prototype, {constructor: {value: SmallInteger}});
                    smallInteger = new SmallInteger(value);
                    return smallInteger instanceof Object ? smallInteger : value11;
                }
                break reducibleJoin9;
            }
        }
        property = Integer[1];
        reducibleJoin11: while (true) {
            if (true & value4) {
                times = property.times;
                value7 = Reflect.apply(times, property, [value]);
                value8 = typeof value4 === 'bigint' ? value4 - 1n : +value4 - 1;
                r4 = value7;
                r11 = value8;
                break reducibleJoin11;
            }
            r4 = property;
            r11 = value4;
            break reducibleJoin11;
        }
        if (r11 !== 0) {
            r7 = r4;
            r9 = value;
            reducibleLoop12: while (true) {
                value = r11 / 2;
                square = r9.square;
                value9 = Reflect.apply(square, r9, []);
                reducibleJoin14: while (true) {
                    if (true & value) {
                        times = r7.times;
                        value10 = Reflect.apply(times, r7, [value9]);
                        value = typeof value === 'bigint' ? value - 1n : +value - 1;
                        r11 = value;
                        r13 = value10;
                        break reducibleJoin14;
                    }
                    r11 = value;
                    r13 = r7;
                    break reducibleJoin14;
                }
                if (r11 !== 0) {
                    r7 = r13;
                    r9 = value9;
                    continue reducibleLoop12;
                }
                r4 = r13;
                break reducibleLoop12;
            }
        }
        return r4;
    }
    const Error = global.Error;
    value = value_1002.toString();
    value = 'The exponent ' + value;
    const value5 = Object.create(Error.prototype, {constructor: {value: Error}});
    value += ' is too large.';
    const error = new Error(value);
    throw error instanceof Object ? error : value5;
}

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 value8;
    var value9;
    var value10;
    var value11;
    var nativeBigInt;
    let value = this;
    const value_1002 = parseValue_1002(a0);
    const value3 = value.value;
    const value4 = value_1002.value;
    let BigInt = global.BigInt;
    const value5 = BigInt(0);
    BigInt = global.BigInt;
    const value6 = BigInt(1);
    BigInt = global.BigInt;
    const value7 = BigInt(2);
    if (value4 === value5) {
        return Integer[1];
    }
    if (value3 === value5) {
        return Integer[0];
    }
    if (value3 === value6) {
        return Integer[1];
    }
    BigInt = global.BigInt;
    if (value3 === BigInt(-1)) {
        return value_1002.isEven() ? Integer[1] : Integer[-1];
    }
    if (value_1002.isNegative()) {
        value = Object.create(NativeBigInt.prototype, {constructor: {value: NativeBigInt}});
        nativeBigInt = new NativeBigInt(value5);
        return nativeBigInt instanceof Object ? nativeBigInt : value;
    }
    const property = Integer[1];
    if ((value4 & value6) !== value6) {
        r4 = property;
        r9 = value4;
    } else {
        value8 = property.times(value);
        value9 = typeof value4 === 'bigint' ? value4 - 1n : +value4 - 1;
        r4 = value8;
        r9 = value9;
    }
    if (r9 !== value5) {
        r6 = r4;
        r8 = value;
        while (true) {
            value = r9 / value7;
            value10 = r8.square();
            if ((value & value6) !== value6) {
                r9 = value;
                r12 = r6;
            } else {
                value11 = r6.times(value10);
                value = typeof value === 'bigint' ? value - 1n : +value - 1;
                r9 = value;
                r12 = value11;
            }
            if (r9 !== value5) {
                r6 = r12;
                r8 = value10;
                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 value3;
    var value4;
    var isOdd;
    var value5;
    var value6;
    var divide;
    var value7;
    var square;
    var value8;
    var value9;
    const parseValue_1002Binding = parseValue_1002;
    const value_1002 = parseValue_1002Binding(a0);
    const value_10022 = parseValue_1002Binding(a1);
    let isZero = value_10022.isZero;
    if (Reflect.apply(isZero, value_10022, [])) {
        throw new global.Error('Cannot take modPow with modulus 0');
    }
    const property = Integer[1];
    const value2 = this.mod(value_10022);
    if (value_1002.isNegative()) {
        value3 = value_1002.multiply(Integer[-1]);
        value4 = value2.modInv(value_10022);
        r3 = value3;
        r6 = value4;
    } else {
        r3 = value_1002;
        r6 = value2;
    }
    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;
            value5 = Reflect.apply(multiply, r3, [r6]);
            value6 = value5.mod(value_10022);
            r8 = value6;
            divide = r4.divide;
            value7 = Reflect.apply(divide, r4, [2]);
            square = r6.square;
            value8 = Reflect.apply(square, r6, []);
            value9 = value8.mod(value_10022);
            isPositive = value7.isPositive;
            if (Reflect.apply(isPositive, value7, [])) {
                r3 = r8;
                r4 = value7;
                r6 = value9;
                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 value_1002 = parseValue_1002(a0);
    return value_1002.isSmall ? 1 : compareAbs(this.value, value_1002.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_1002(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_1002(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 value_1002 = parseValue_1002(a0);
    if (this.sign !== value_1002.sign) {
        r0 = value_1002.sign ? 1 : -1;
    } else if (value_1002.isSmall) {
        r0 = this.sign ? -1 : 1;
    } else {
        value = compareAbs(this.value, value_1002.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_1002 = parseValue_1002(a0);
    const value2 = this.value;
    const value3 = value_1002.value;
    const isSmall = value_1002.isSmall;
    const value4 = 0;
    return isSmall ? value2 == value3 ? value4 : value2 > value3 ? 1 : -1 : value2 < value4 !== value_1002.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_1002(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_1002(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_1002(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_1063() { // 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_1066() { // 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 value5;
    let value = this;
    const value3 = parseValue_1002(a0).toJSNumber();
    if (shift_isSmall(value3)) {
        if (value3 < 0) {
            return value.shiftRight(-value3);
        }
        if (value.isZero()) {
            return value;
        }
        if (value3 >= length) {
            r6 = value;
            r7 = value3;
            reducibleLoop5: while (true) {
                multiply = r6.multiply;
                value = Reflect.apply(multiply, r6, [env0_6]);
                value5 = r7 - (length - 1);
                if (value5 >= length) {
                    r6 = value;
                    r7 = value5;
                    continue reducibleLoop5;
                }
                r4 = value;
                r5 = value5;
                break reducibleLoop5;
            }
        } else {
            r4 = value;
            r5 = value3;
        }
        return r4.multiply(env0_4[r5]);
    }
    const Error = global.Error;
    const String = global.String;
    value = String(value3);
    value += ' is too large for shifting.';
    const value4 = Object.create(Error.prototype, {constructor: {value: Error}});
    const error = new Error(value);
    throw error instanceof Object ? error : value4;
}

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 value3 = parseValue_1002(a0).toJSNumber();
    if (shift_isSmall(value3)) {
        if (value3 < 0) {
            return value.shiftLeft(-value3);
        }
        if (value3 >= length) {
            r10 = value;
            r11 = value3;
            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 = value3;
        }
        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(value3);
    value += ' is too large for shifting.';
    const value4 = Object.create(Error.prototype, {constructor: {value: Error}});
    const error = new Error(value);
    throw error instanceof Object ? error : value4;
}

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_1074(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 value9;
    var push;
    var slice;
    var value11;
    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 object2 = {};
    const length2 = r5.length;
    const value3 = 0;
    if (value3 < length2) {
        r1 = value3;
        reducibleLoop5: while (true) {
            object2[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 object2) {
                        if (object2[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 value_1002 = parseValue_1002(a1);
    const items2 = [];
    const value8 = r12[value3] === '-';
    let r10 = value8 ? value5 : value3;
    length = r12.length;
    if (r10 < length) {
        reducibleLoop16: while (true) {
            property = r12[r10];
            if (property in object2) {
                push = items2.push;
                Reflect.apply(push, items2, [parseValue_1002(object2[property])]);
                r5 = r10;
            } else {
                if (property !== '<') {
                    throw new global.Error(property + ' is not a valid character');
                }
                r16 = r10;
                reducibleLoop18: while (true) {
                    value9 = typeof r16 === 'bigint' ? r16 + 1n : +r16 + 1;
                    if (r12[value9] === '>') {
                        break reducibleLoop18;
                    }
                    length = r12.length;
                    if (value9 < length) {
                        r16 = value9;
                        continue reducibleLoop18;
                    }
                    break reducibleLoop18;
                }
                push = items2.push;
                parseValue_1002Binding = parseValue_1002;
                slice = r12.slice;
                Reflect.apply(push, items2, [parseValue_1002Binding(Reflect.apply(slice, r12, [r10 + value5,
                    value9]))]);
                r5 = value9;
            }
            value11 = typeof r5 === 'bigint' ? r5 + 1n : +r5 + 1;
            length = r12.length;
            if (!(value11 < length)) {
                return parseBaseFromArray(items2, value_1002, value8);
            }
            r10 = value11;
            continue reducibleLoop16;
        }
    }
    return parseBaseFromArray(items2, value_1002, value8);
}

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 parseValue_1002Binding = parseValue_1002;
    const value2 = parseValue_1002Binding(a0).abs();
    const value3 = parseValue_1002Binding(a1).abs();
    return value2.divide(gcd(value2, value3)).multiply(value3);
}

function isInstance_1090(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 value11;
    var value12;
    let value = a2;
    const parseValue_1002Binding = parseValue_1002;
    const value_1002 = parseValue_1002Binding(a0);
    const value_10022 = parseValue_1002Binding(a1);
    const r6 = value || global.Math.random;
    value = min_995(value_1002, value_10022);
    const value4 = max_994(value_1002, value_10022).subtract(value);
    let add = value4.add;
    const value5 = Reflect.apply(add, value4, [1]);
    if (value5.isSmall) {
        add = value.add;
        Math = global.Math;
        return Reflect.apply(add, value, [Math.floor(r6() * value5)]);
    }
    const toBaseBinding = toBase;
    const value6 = 10000000;
    const value7 = toBaseBinding(value5, value6).value;
    const items2 = [];
    let length = value7.length;
    const value8 = 0;
    const value9 = false;
    if (value8 < length) {
        r4 = true;
        r10 = value8;
        while (true) {
            if (r4) {
                property = value7[r10];
                r12 = property;
            } else {
                r12 = value6;
            }
            value11 = truncate_973(r6() * r12);
            items2.push(value11);
            if (value11 < r12) {
                r4 = value9;
                continue;
            }
            continue;
            value12 = typeof r10 === 'bigint' ? r10 + 1n : +r10 + 1;
            length = value7.length;
            if (value12 < length) {
                r10 = value12;
                continue;
            }
            break;
        }
    }
    return value.add(Integer.fromArray(items2, value6, value9));
}

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 + '>';
}