{"mappings":"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","names":["require_BigInteger","__commonJSMin","exports","module","bigInt","undefined","BASE","LOG_BASE","MAX_INT","MAX_INT_ARR","smallToArray","DEFAULT_ALPHABET","supportsNativeBigInt","Integer","v","radix","alphabet","caseSensitive","parseValue","parseBase","BigInteger","value","sign","SmallInteger","NativeBigInt","isPrecise","n","arrayToSmall","arr","trim","length","compareAbs","i","createArray","x","truncate","add","a","b","l_a","l_b","r","carry","base","sum","addAny","addSmall","l","subtract","a_l","b_l","borrow","difference","subtractAny","subtractSmall","small","multiplyLong","product","a_i","b_j","j","multiplySmall","shiftLeft","multiplyKaratsuba","y","d","c","ac","bd","abcd","useKaratsuba","l1","l2","abs","multiplySmallAndArray","square","a_j","divMod1","result","divisorMostSignificantDigit","lambda","remainder","divisor","quotientDigit","shift","q","divModSmall","divMod2","part","guess","xlen","highx","highy","check","quotient","divModAny","self","comparison","qSign","mod","mSign","_0","_1","_2","exp","isBasicPrime","millerRabinTest","nPrev","t","next","strict","isPrime","bits","logN","iterations","rng","newT","newR","lastT","lastR","powersOfTwo","powers2Length","highestPower2","shift_isSmall","remQuo","bitwise","fn","xSign","ySign","xRem","yRem","xDigit","yDigit","xDivMod","yDivMod","LOBMASK_I","LOBMASK_BI","roughLOB","integerLogarithm","tmp","p","e","max","min","gcd","lcm","randBetween","usedRNG","low","high","range","digits","toBase","restricted","top","digit","text","absBase","alphabetValues","isNegative","start","parseBaseFromArray","val","pow","stringify","neg","out","left","divmod","toBaseString","str","zeros","parseStringValue","split","decimalPlace","isValid","parseNumberValue","cjsm","endpoint_default"],"sources":["../esm/npm/big-integer@1.6.51/node_modules/big-integer/BigInteger.js","endpoint.js"],"sourcesContent":["var bigInt = (function (undefined) {\r\n    \"use strict\";\r\n\r\n    var BASE = 1e7,\r\n        LOG_BASE = 7,\r\n        MAX_INT = 9007199254740992,\r\n        MAX_INT_ARR = smallToArray(MAX_INT),\r\n        DEFAULT_ALPHABET = \"0123456789abcdefghijklmnopqrstuvwxyz\";\r\n\r\n    var supportsNativeBigInt = typeof BigInt === \"function\";\r\n\r\n    function Integer(v, radix, alphabet, caseSensitive) {\r\n        if (typeof v === \"undefined\") return Integer[0];\r\n        if (typeof radix !== \"undefined\") return +radix === 10 \u0026\u0026 !alphabet ? parseValue(v) : parseBase(v, radix, alphabet, caseSensitive);\r\n        return parseValue(v);\r\n    }\r\n\r\n    function BigInteger(value, sign) {\r\n        this.value = value;\r\n        this.sign = sign;\r\n        this.isSmall = false;\r\n    }\r\n    BigInteger.prototype = Object.create(Integer.prototype);\r\n\r\n    function SmallInteger(value) {\r\n        this.value = value;\r\n        this.sign = value \u003c 0;\r\n        this.isSmall = true;\r\n    }\r\n    SmallInteger.prototype = Object.create(Integer.prototype);\r\n\r\n    function NativeBigInt(value) {\r\n        this.value = value;\r\n    }\r\n    NativeBigInt.prototype = Object.create(Integer.prototype);\r\n\r\n    function isPrecise(n) {\r\n        return -MAX_INT \u003c n \u0026\u0026 n \u003c MAX_INT;\r\n    }\r\n\r\n    function smallToArray(n) { // For performance reasons doesn't reference BASE, need to change this function if BASE changes\r\n        if (n \u003c 1e7)\r\n            return [n];\r\n        if (n \u003c 1e14)\r\n            return [n % 1e7, Math.floor(n / 1e7)];\r\n        return [n % 1e7, Math.floor(n / 1e7) % 1e7, Math.floor(n / 1e14)];\r\n    }\r\n\r\n    function arrayToSmall(arr) { // If BASE changes this function may need to change\r\n        trim(arr);\r\n        var length = arr.length;\r\n        if (length \u003c 4 \u0026\u0026 compareAbs(arr, MAX_INT_ARR) \u003c 0) {\r\n            switch (length) {\r\n                case 0: return 0;\r\n                case 1: return arr[0];\r\n                case 2: return arr[0] + arr[1] * BASE;\r\n                default: return arr[0] + (arr[1] + arr[2] * BASE) * BASE;\r\n            }\r\n        }\r\n        return arr;\r\n    }\r\n\r\n    function trim(v) {\r\n        var i = v.length;\r\n        while (v[--i] === 0);\r\n        v.length = i + 1;\r\n    }\r\n\r\n    function createArray(length) { // function shamelessly stolen from Yaffle's library https://github.com/Yaffle/BigInteger\r\n        var x = new Array(length);\r\n        var i = -1;\r\n        while (++i \u003c length) {\r\n            x[i] = 0;\r\n        }\r\n        return x;\r\n    }\r\n\r\n    function truncate(n) {\r\n        if (n \u003e 0) return Math.floor(n);\r\n        return Math.ceil(n);\r\n    }\r\n\r\n    function add(a, b) { // assumes a and b are arrays with a.length \u003e= b.length\r\n        var l_a = a.length,\r\n            l_b = b.length,\r\n            r = new Array(l_a),\r\n            carry = 0,\r\n            base = BASE,\r\n            sum, i;\r\n        for (i = 0; i \u003c l_b; i++) {\r\n            sum = a[i] + b[i] + carry;\r\n            carry = sum \u003e= base ? 1 : 0;\r\n            r[i] = sum - carry * base;\r\n        }\r\n        while (i \u003c l_a) {\r\n            sum = a[i] + carry;\r\n            carry = sum === base ? 1 : 0;\r\n            r[i++] = sum - carry * base;\r\n        }\r\n        if (carry \u003e 0) r.push(carry);\r\n        return r;\r\n    }\r\n\r\n    function addAny(a, b) {\r\n        if (a.length \u003e= b.length) return add(a, b);\r\n        return add(b, a);\r\n    }\r\n\r\n    function addSmall(a, carry) { // assumes a is array, carry is number with 0 \u003c= carry \u003c MAX_INT\r\n        var l = a.length,\r\n            r = new Array(l),\r\n            base = BASE,\r\n            sum, i;\r\n        for (i = 0; i \u003c l; i++) {\r\n            sum = a[i] - base + carry;\r\n            carry = Math.floor(sum / base);\r\n            r[i] = sum - carry * base;\r\n            carry += 1;\r\n        }\r\n        while (carry \u003e 0) {\r\n            r[i++] = carry % base;\r\n            carry = Math.floor(carry / base);\r\n        }\r\n        return r;\r\n    }\r\n\r\n    BigInteger.prototype.add = function (v) {\r\n        var n = parseValue(v);\r\n        if (this.sign !== n.sign) {\r\n            return this.subtract(n.negate());\r\n        }\r\n        var a = this.value, b = n.value;\r\n        if (n.isSmall) {\r\n            return new BigInteger(addSmall(a, Math.abs(b)), this.sign);\r\n        }\r\n        return new BigInteger(addAny(a, b), this.sign);\r\n    };\r\n    BigInteger.prototype.plus = BigInteger.prototype.add;\r\n\r\n    SmallInteger.prototype.add = function (v) {\r\n        var n = parseValue(v);\r\n        var a = this.value;\r\n        if (a \u003c 0 !== n.sign) {\r\n            return this.subtract(n.negate());\r\n        }\r\n        var b = n.value;\r\n        if (n.isSmall) {\r\n            if (isPrecise(a + b)) return new SmallInteger(a + b);\r\n            b = smallToArray(Math.abs(b));\r\n        }\r\n        return new BigInteger(addSmall(b, Math.abs(a)), a \u003c 0);\r\n    };\r\n    SmallInteger.prototype.plus = SmallInteger.prototype.add;\r\n\r\n    NativeBigInt.prototype.add = function (v) {\r\n        return new NativeBigInt(this.value + parseValue(v).value);\r\n    }\r\n    NativeBigInt.prototype.plus = NativeBigInt.prototype.add;\r\n\r\n    function subtract(a, b) { // assumes a and b are arrays with a \u003e= b\r\n        var a_l = a.length,\r\n            b_l = b.length,\r\n            r = new Array(a_l),\r\n            borrow = 0,\r\n            base = BASE,\r\n            i, difference;\r\n        for (i = 0; i \u003c b_l; i++) {\r\n            difference = a[i] - borrow - b[i];\r\n            if (difference \u003c 0) {\r\n                difference += base;\r\n                borrow = 1;\r\n            } else borrow = 0;\r\n            r[i] = difference;\r\n        }\r\n        for (i = b_l; i \u003c a_l; i++) {\r\n            difference = a[i] - borrow;\r\n            if (difference \u003c 0) difference += base;\r\n            else {\r\n                r[i++] = difference;\r\n                break;\r\n            }\r\n            r[i] = difference;\r\n        }\r\n        for (; i \u003c a_l; i++) {\r\n            r[i] = a[i];\r\n        }\r\n        trim(r);\r\n        return r;\r\n    }\r\n\r\n    function subtractAny(a, b, sign) {\r\n        var value;\r\n        if (compareAbs(a, b) \u003e= 0) {\r\n            value = subtract(a, b);\r\n        } else {\r\n            value = subtract(b, a);\r\n            sign = !sign;\r\n        }\r\n        value = arrayToSmall(value);\r\n        if (typeof value === \"number\") {\r\n            if (sign) value = -value;\r\n            return new SmallInteger(value);\r\n        }\r\n        return new BigInteger(value, sign);\r\n    }\r\n\r\n    function subtractSmall(a, b, sign) { // assumes a is array, b is number with 0 \u003c= b \u003c MAX_INT\r\n        var l = a.length,\r\n            r = new Array(l),\r\n            carry = -b,\r\n            base = BASE,\r\n            i, difference;\r\n        for (i = 0; i \u003c l; i++) {\r\n            difference = a[i] + carry;\r\n            carry = Math.floor(difference / base);\r\n            difference %= base;\r\n            r[i] = difference \u003c 0 ? difference + base : difference;\r\n        }\r\n        r = arrayToSmall(r);\r\n        if (typeof r === \"number\") {\r\n            if (sign) r = -r;\r\n            return new SmallInteger(r);\r\n        } return new BigInteger(r, sign);\r\n    }\r\n\r\n    BigInteger.prototype.subtract = function (v) {\r\n        var n = parseValue(v);\r\n        if (this.sign !== n.sign) {\r\n            return this.add(n.negate());\r\n        }\r\n        var a = this.value, b = n.value;\r\n        if (n.isSmall)\r\n            return subtractSmall(a, Math.abs(b), this.sign);\r\n        return subtractAny(a, b, this.sign);\r\n    };\r\n    BigInteger.prototype.minus = BigInteger.prototype.subtract;\r\n\r\n    SmallInteger.prototype.subtract = function (v) {\r\n        var n = parseValue(v);\r\n        var a = this.value;\r\n        if (a \u003c 0 !== n.sign) {\r\n            return this.add(n.negate());\r\n        }\r\n        var b = n.value;\r\n        if (n.isSmall) {\r\n            return new SmallInteger(a - b);\r\n        }\r\n        return subtractSmall(b, Math.abs(a), a \u003e= 0);\r\n    };\r\n    SmallInteger.prototype.minus = SmallInteger.prototype.subtract;\r\n\r\n    NativeBigInt.prototype.subtract = function (v) {\r\n        return new NativeBigInt(this.value - parseValue(v).value);\r\n    }\r\n    NativeBigInt.prototype.minus = NativeBigInt.prototype.subtract;\r\n\r\n    BigInteger.prototype.negate = function () {\r\n        return new BigInteger(this.value, !this.sign);\r\n    };\r\n    SmallInteger.prototype.negate = function () {\r\n        var sign = this.sign;\r\n        var small = new SmallInteger(-this.value);\r\n        small.sign = !sign;\r\n        return small;\r\n    };\r\n    NativeBigInt.prototype.negate = function () {\r\n        return new NativeBigInt(-this.value);\r\n    }\r\n\r\n    BigInteger.prototype.abs = function () {\r\n        return new BigInteger(this.value, false);\r\n    };\r\n    SmallInteger.prototype.abs = function () {\r\n        return new SmallInteger(Math.abs(this.value));\r\n    };\r\n    NativeBigInt.prototype.abs = function () {\r\n        return new NativeBigInt(this.value \u003e= 0 ? this.value : -this.value);\r\n    }\r\n\r\n\r\n    function multiplyLong(a, b) {\r\n        var a_l = a.length,\r\n            b_l = b.length,\r\n            l = a_l + b_l,\r\n            r = createArray(l),\r\n            base = BASE,\r\n            product, carry, i, a_i, b_j;\r\n        for (i = 0; i \u003c a_l; ++i) {\r\n            a_i = a[i];\r\n            for (var j = 0; j \u003c b_l; ++j) {\r\n                b_j = b[j];\r\n                product = a_i * b_j + r[i + j];\r\n                carry = Math.floor(product / base);\r\n                r[i + j] = product - carry * base;\r\n                r[i + j + 1] += carry;\r\n            }\r\n        }\r\n        trim(r);\r\n        return r;\r\n    }\r\n\r\n    function multiplySmall(a, b) { // assumes a is array, b is number with |b| \u003c BASE\r\n        var l = a.length,\r\n            r = new Array(l),\r\n            base = BASE,\r\n            carry = 0,\r\n            product, i;\r\n        for (i = 0; i \u003c l; i++) {\r\n            product = a[i] * b + carry;\r\n            carry = Math.floor(product / base);\r\n            r[i] = product - carry * base;\r\n        }\r\n        while (carry \u003e 0) {\r\n            r[i++] = carry % base;\r\n            carry = Math.floor(carry / base);\r\n        }\r\n        return r;\r\n    }\r\n\r\n    function shiftLeft(x, n) {\r\n        var r = [];\r\n        while (n-- \u003e 0) r.push(0);\r\n        return r.concat(x);\r\n    }\r\n\r\n    function multiplyKaratsuba(x, y) {\r\n        var n = Math.max(x.length, y.length);\r\n\r\n        if (n \u003c= 30) return multiplyLong(x, y);\r\n        n = Math.ceil(n / 2);\r\n\r\n        var b = x.slice(n),\r\n            a = x.slice(0, n),\r\n            d = y.slice(n),\r\n            c = y.slice(0, n);\r\n\r\n        var ac = multiplyKaratsuba(a, c),\r\n            bd = multiplyKaratsuba(b, d),\r\n            abcd = multiplyKaratsuba(addAny(a, b), addAny(c, d));\r\n\r\n        var product = addAny(addAny(ac, shiftLeft(subtract(subtract(abcd, ac), bd), n)), shiftLeft(bd, 2 * n));\r\n        trim(product);\r\n        return product;\r\n    }\r\n\r\n    // The following function is derived from a surface fit of a graph plotting the performance difference\r\n    // between long multiplication and karatsuba multiplication versus the lengths of the two arrays.\r\n    function useKaratsuba(l1, l2) {\r\n        return -0.012 * l1 - 0.012 * l2 + 0.000015 * l1 * l2 \u003e 0;\r\n    }\r\n\r\n    BigInteger.prototype.multiply = function (v) {\r\n        var n = parseValue(v),\r\n            a = this.value, b = n.value,\r\n            sign = this.sign !== n.sign,\r\n            abs;\r\n        if (n.isSmall) {\r\n            if (b === 0) return Integer[0];\r\n            if (b === 1) return this;\r\n            if (b === -1) return this.negate();\r\n            abs = Math.abs(b);\r\n            if (abs \u003c BASE) {\r\n                return new BigInteger(multiplySmall(a, abs), sign);\r\n            }\r\n            b = smallToArray(abs);\r\n        }\r\n        if (useKaratsuba(a.length, b.length)) // Karatsuba is only faster for certain array sizes\r\n            return new BigInteger(multiplyKaratsuba(a, b), sign);\r\n        return new BigInteger(multiplyLong(a, b), sign);\r\n    };\r\n\r\n    BigInteger.prototype.times = BigInteger.prototype.multiply;\r\n\r\n    function multiplySmallAndArray(a, b, sign) { // a \u003e= 0\r\n        if (a \u003c BASE) {\r\n            return new BigInteger(multiplySmall(b, a), sign);\r\n        }\r\n        return new BigInteger(multiplyLong(b, smallToArray(a)), sign);\r\n    }\r\n    SmallInteger.prototype._multiplyBySmall = function (a) {\r\n        if (isPrecise(a.value * this.value)) {\r\n            return new SmallInteger(a.value * this.value);\r\n        }\r\n        return multiplySmallAndArray(Math.abs(a.value), smallToArray(Math.abs(this.value)), this.sign !== a.sign);\r\n    };\r\n    BigInteger.prototype._multiplyBySmall = function (a) {\r\n        if (a.value === 0) return Integer[0];\r\n        if (a.value === 1) return this;\r\n        if (a.value === -1) return this.negate();\r\n        return multiplySmallAndArray(Math.abs(a.value), this.value, this.sign !== a.sign);\r\n    };\r\n    SmallInteger.prototype.multiply = function (v) {\r\n        return parseValue(v)._multiplyBySmall(this);\r\n    };\r\n    SmallInteger.prototype.times = SmallInteger.prototype.multiply;\r\n\r\n    NativeBigInt.prototype.multiply = function (v) {\r\n        return new NativeBigInt(this.value * parseValue(v).value);\r\n    }\r\n    NativeBigInt.prototype.times = NativeBigInt.prototype.multiply;\r\n\r\n    function square(a) {\r\n        //console.assert(2 * BASE * BASE \u003c MAX_INT);\r\n        var l = a.length,\r\n            r = createArray(l + l),\r\n            base = BASE,\r\n            product, carry, i, a_i, a_j;\r\n        for (i = 0; i \u003c l; i++) {\r\n            a_i = a[i];\r\n            carry = 0 - a_i * a_i;\r\n            for (var j = i; j \u003c l; j++) {\r\n                a_j = a[j];\r\n                product = 2 * (a_i * a_j) + r[i + j] + carry;\r\n                carry = Math.floor(product / base);\r\n                r[i + j] = product - carry * base;\r\n            }\r\n            r[i + l] = carry;\r\n        }\r\n        trim(r);\r\n        return r;\r\n    }\r\n\r\n    BigInteger.prototype.square = function () {\r\n        return new BigInteger(square(this.value), false);\r\n    };\r\n\r\n    SmallInteger.prototype.square = function () {\r\n        var value = this.value * this.value;\r\n        if (isPrecise(value)) return new SmallInteger(value);\r\n        return new BigInteger(square(smallToArray(Math.abs(this.value))), false);\r\n    };\r\n\r\n    NativeBigInt.prototype.square = function (v) {\r\n        return new NativeBigInt(this.value * this.value);\r\n    }\r\n\r\n    function divMod1(a, b) { // Left over from previous version. Performs faster than divMod2 on smaller input sizes.\r\n        var a_l = a.length,\r\n            b_l = b.length,\r\n            base = BASE,\r\n            result = createArray(b.length),\r\n            divisorMostSignificantDigit = b[b_l - 1],\r\n            // normalization\r\n            lambda = Math.ceil(base / (2 * divisorMostSignificantDigit)),\r\n            remainder = multiplySmall(a, lambda),\r\n            divisor = multiplySmall(b, lambda),\r\n            quotientDigit, shift, carry, borrow, i, l, q;\r\n        if (remainder.length \u003c= a_l) remainder.push(0);\r\n        divisor.push(0);\r\n        divisorMostSignificantDigit = divisor[b_l - 1];\r\n        for (shift = a_l - b_l; shift \u003e= 0; shift--) {\r\n            quotientDigit = base - 1;\r\n            if (remainder[shift + b_l] !== divisorMostSignificantDigit) {\r\n                quotientDigit = Math.floor((remainder[shift + b_l] * base + remainder[shift + b_l - 1]) / divisorMostSignificantDigit);\r\n            }\r\n            // quotientDigit \u003c= base - 1\r\n            carry = 0;\r\n            borrow = 0;\r\n            l = divisor.length;\r\n            for (i = 0; i \u003c l; i++) {\r\n                carry += quotientDigit * divisor[i];\r\n                q = Math.floor(carry / base);\r\n                borrow += remainder[shift + i] - (carry - q * base);\r\n                carry = q;\r\n                if (borrow \u003c 0) {\r\n                    remainder[shift + i] = borrow + base;\r\n                    borrow = -1;\r\n                } else {\r\n                    remainder[shift + i] = borrow;\r\n                    borrow = 0;\r\n                }\r\n            }\r\n            while (borrow !== 0) {\r\n                quotientDigit -= 1;\r\n                carry = 0;\r\n                for (i = 0; i \u003c l; i++) {\r\n                    carry += remainder[shift + i] - base + divisor[i];\r\n                    if (carry \u003c 0) {\r\n                        remainder[shift + i] = carry + base;\r\n                        carry = 0;\r\n                    } else {\r\n                        remainder[shift + i] = carry;\r\n                        carry = 1;\r\n                    }\r\n                }\r\n                borrow += carry;\r\n            }\r\n            result[shift] = quotientDigit;\r\n        }\r\n        // denormalization\r\n        remainder = divModSmall(remainder, lambda)[0];\r\n        return [arrayToSmall(result), arrayToSmall(remainder)];\r\n    }\r\n\r\n    function divMod2(a, b) { // Implementation idea shamelessly stolen from Silent Matt's library http://silentmatt.com/biginteger/\r\n        // Performs faster than divMod1 on larger input sizes.\r\n        var a_l = a.length,\r\n            b_l = b.length,\r\n            result = [],\r\n            part = [],\r\n            base = BASE,\r\n            guess, xlen, highx, highy, check;\r\n        while (a_l) {\r\n            part.unshift(a[--a_l]);\r\n            trim(part);\r\n            if (compareAbs(part, b) \u003c 0) {\r\n                result.push(0);\r\n                continue;\r\n            }\r\n            xlen = part.length;\r\n            highx = part[xlen - 1] * base + part[xlen - 2];\r\n            highy = b[b_l - 1] * base + b[b_l - 2];\r\n            if (xlen \u003e b_l) {\r\n                highx = (highx + 1) * base;\r\n            }\r\n            guess = Math.ceil(highx / highy);\r\n            do {\r\n                check = multiplySmall(b, guess);\r\n                if (compareAbs(check, part) \u003c= 0) break;\r\n                guess--;\r\n            } while (guess);\r\n            result.push(guess);\r\n            part = subtract(part, check);\r\n        }\r\n        result.reverse();\r\n        return [arrayToSmall(result), arrayToSmall(part)];\r\n    }\r\n\r\n    function divModSmall(value, lambda) {\r\n        var length = value.length,\r\n            quotient = createArray(length),\r\n            base = BASE,\r\n            i, q, remainder, divisor;\r\n        remainder = 0;\r\n        for (i = length - 1; i \u003e= 0; --i) {\r\n            divisor = remainder * base + value[i];\r\n            q = truncate(divisor / lambda);\r\n            remainder = divisor - q * lambda;\r\n            quotient[i] = q | 0;\r\n        }\r\n        return [quotient, remainder | 0];\r\n    }\r\n\r\n    function divModAny(self, v) {\r\n        var value, n = parseValue(v);\r\n        if (supportsNativeBigInt) {\r\n            return [new NativeBigInt(self.value / n.value), new NativeBigInt(self.value % n.value)];\r\n        }\r\n        var a = self.value, b = n.value;\r\n        var quotient;\r\n        if (b === 0) throw new Error(\"Cannot divide by zero\");\r\n        if (self.isSmall) {\r\n            if (n.isSmall) {\r\n                return [new SmallInteger(truncate(a / b)), new SmallInteger(a % b)];\r\n            }\r\n            return [Integer[0], self];\r\n        }\r\n        if (n.isSmall) {\r\n            if (b === 1) return [self, Integer[0]];\r\n            if (b == -1) return [self.negate(), Integer[0]];\r\n            var abs = Math.abs(b);\r\n            if (abs \u003c BASE) {\r\n                value = divModSmall(a, abs);\r\n                quotient = arrayToSmall(value[0]);\r\n                var remainder = value[1];\r\n                if (self.sign) remainder = -remainder;\r\n                if (typeof quotient === \"number\") {\r\n                    if (self.sign !== n.sign) quotient = -quotient;\r\n                    return [new SmallInteger(quotient), new SmallInteger(remainder)];\r\n                }\r\n                return [new BigInteger(quotient, self.sign !== n.sign), new SmallInteger(remainder)];\r\n            }\r\n            b = smallToArray(abs);\r\n        }\r\n        var comparison = compareAbs(a, b);\r\n        if (comparison === -1) return [Integer[0], self];\r\n        if (comparison === 0) return [Integer[self.sign === n.sign ? 1 : -1], Integer[0]];\r\n\r\n        // divMod1 is faster on smaller input sizes\r\n        if (a.length + b.length \u003c= 200)\r\n            value = divMod1(a, b);\r\n        else value = divMod2(a, b);\r\n\r\n        quotient = value[0];\r\n        var qSign = self.sign !== n.sign,\r\n            mod = value[1],\r\n            mSign = self.sign;\r\n        if (typeof quotient === \"number\") {\r\n            if (qSign) quotient = -quotient;\r\n            quotient = new SmallInteger(quotient);\r\n        } else quotient = new BigInteger(quotient, qSign);\r\n        if (typeof mod === \"number\") {\r\n            if (mSign) mod = -mod;\r\n            mod = new SmallInteger(mod);\r\n        } else mod = new BigInteger(mod, mSign);\r\n        return [quotient, mod];\r\n    }\r\n\r\n    BigInteger.prototype.divmod = function (v) {\r\n        var result = divModAny(this, v);\r\n        return {\r\n            quotient: result[0],\r\n            remainder: result[1]\r\n        };\r\n    };\r\n    NativeBigInt.prototype.divmod = SmallInteger.prototype.divmod = BigInteger.prototype.divmod;\r\n\r\n\r\n    BigInteger.prototype.divide = function (v) {\r\n        return divModAny(this, v)[0];\r\n    };\r\n    NativeBigInt.prototype.over = NativeBigInt.prototype.divide = function (v) {\r\n        return new NativeBigInt(this.value / parseValue(v).value);\r\n    };\r\n    SmallInteger.prototype.over = SmallInteger.prototype.divide = BigInteger.prototype.over = BigInteger.prototype.divide;\r\n\r\n    BigInteger.prototype.mod = function (v) {\r\n        return divModAny(this, v)[1];\r\n    };\r\n    NativeBigInt.prototype.mod = NativeBigInt.prototype.remainder = function (v) {\r\n        return new NativeBigInt(this.value % parseValue(v).value);\r\n    };\r\n    SmallInteger.prototype.remainder = SmallInteger.prototype.mod = BigInteger.prototype.remainder = BigInteger.prototype.mod;\r\n\r\n    BigInteger.prototype.pow = function (v) {\r\n        var n = parseValue(v),\r\n            a = this.value,\r\n            b = n.value,\r\n            value, x, y;\r\n        if (b === 0) return Integer[1];\r\n        if (a === 0) return Integer[0];\r\n        if (a === 1) return Integer[1];\r\n        if (a === -1) return n.isEven() ? Integer[1] : Integer[-1];\r\n        if (n.sign) {\r\n            return Integer[0];\r\n        }\r\n        if (!n.isSmall) throw new Error(\"The exponent \" + n.toString() + \" is too large.\");\r\n        if (this.isSmall) {\r\n            if (isPrecise(value = Math.pow(a, b)))\r\n                return new SmallInteger(truncate(value));\r\n        }\r\n        x = this;\r\n        y = Integer[1];\r\n        while (true) {\r\n            if (b \u0026 1 === 1) {\r\n                y = y.times(x);\r\n                --b;\r\n            }\r\n            if (b === 0) break;\r\n            b /= 2;\r\n            x = x.square();\r\n        }\r\n        return y;\r\n    };\r\n    SmallInteger.prototype.pow = BigInteger.prototype.pow;\r\n\r\n    NativeBigInt.prototype.pow = function (v) {\r\n        var n = parseValue(v);\r\n        var a = this.value, b = n.value;\r\n        var _0 = BigInt(0), _1 = BigInt(1), _2 = BigInt(2);\r\n        if (b === _0) return Integer[1];\r\n        if (a === _0) return Integer[0];\r\n        if (a === _1) return Integer[1];\r\n        if (a === BigInt(-1)) return n.isEven() ? Integer[1] : Integer[-1];\r\n        if (n.isNegative()) return new NativeBigInt(_0);\r\n        var x = this;\r\n        var y = Integer[1];\r\n        while (true) {\r\n            if ((b \u0026 _1) === _1) {\r\n                y = y.times(x);\r\n                --b;\r\n            }\r\n            if (b === _0) break;\r\n            b /= _2;\r\n            x = x.square();\r\n        }\r\n        return y;\r\n    }\r\n\r\n    BigInteger.prototype.modPow = function (exp, mod) {\r\n        exp = parseValue(exp);\r\n        mod = parseValue(mod);\r\n        if (mod.isZero()) throw new Error(\"Cannot take modPow with modulus 0\");\r\n        var r = Integer[1],\r\n            base = this.mod(mod);\r\n        if (exp.isNegative()) {\r\n            exp = exp.multiply(Integer[-1]);\r\n            base = base.modInv(mod);\r\n        }\r\n        while (exp.isPositive()) {\r\n            if (base.isZero()) return Integer[0];\r\n            if (exp.isOdd()) r = r.multiply(base).mod(mod);\r\n            exp = exp.divide(2);\r\n            base = base.square().mod(mod);\r\n        }\r\n        return r;\r\n    };\r\n    NativeBigInt.prototype.modPow = SmallInteger.prototype.modPow = BigInteger.prototype.modPow;\r\n\r\n    function compareAbs(a, b) {\r\n        if (a.length !== b.length) {\r\n            return a.length \u003e b.length ? 1 : -1;\r\n        }\r\n        for (var i = a.length - 1; i \u003e= 0; i--) {\r\n            if (a[i] !== b[i]) return a[i] \u003e b[i] ? 1 : -1;\r\n        }\r\n        return 0;\r\n    }\r\n\r\n    BigInteger.prototype.compareAbs = function (v) {\r\n        var n = parseValue(v),\r\n            a = this.value,\r\n            b = n.value;\r\n        if (n.isSmall) return 1;\r\n        return compareAbs(a, b);\r\n    };\r\n    SmallInteger.prototype.compareAbs = function (v) {\r\n        var n = parseValue(v),\r\n            a = Math.abs(this.value),\r\n            b = n.value;\r\n        if (n.isSmall) {\r\n            b = Math.abs(b);\r\n            return a === b ? 0 : a \u003e b ? 1 : -1;\r\n        }\r\n        return -1;\r\n    };\r\n    NativeBigInt.prototype.compareAbs = function (v) {\r\n        var a = this.value;\r\n        var b = parseValue(v).value;\r\n        a = a \u003e= 0 ? a : -a;\r\n        b = b \u003e= 0 ? b : -b;\r\n        return a === b ? 0 : a \u003e b ? 1 : -1;\r\n    }\r\n\r\n    BigInteger.prototype.compare = function (v) {\r\n        // See discussion about comparison with Infinity:\r\n        // https://github.com/peterolson/BigInteger.js/issues/61\r\n        if (v === Infinity) {\r\n            return -1;\r\n        }\r\n        if (v === -Infinity) {\r\n            return 1;\r\n        }\r\n\r\n        var n = parseValue(v),\r\n            a = this.value,\r\n            b = n.value;\r\n        if (this.sign !== n.sign) {\r\n            return n.sign ? 1 : -1;\r\n        }\r\n        if (n.isSmall) {\r\n            return this.sign ? -1 : 1;\r\n        }\r\n        return compareAbs(a, b) * (this.sign ? -1 : 1);\r\n    };\r\n    BigInteger.prototype.compareTo = BigInteger.prototype.compare;\r\n\r\n    SmallInteger.prototype.compare = function (v) {\r\n        if (v === Infinity) {\r\n            return -1;\r\n        }\r\n        if (v === -Infinity) {\r\n            return 1;\r\n        }\r\n\r\n        var n = parseValue(v),\r\n            a = this.value,\r\n            b = n.value;\r\n        if (n.isSmall) {\r\n            return a == b ? 0 : a \u003e b ? 1 : -1;\r\n        }\r\n        if (a \u003c 0 !== n.sign) {\r\n            return a \u003c 0 ? -1 : 1;\r\n        }\r\n        return a \u003c 0 ? 1 : -1;\r\n    };\r\n    SmallInteger.prototype.compareTo = SmallInteger.prototype.compare;\r\n\r\n    NativeBigInt.prototype.compare = function (v) {\r\n        if (v === Infinity) {\r\n            return -1;\r\n        }\r\n        if (v === -Infinity) {\r\n            return 1;\r\n        }\r\n        var a = this.value;\r\n        var b = parseValue(v).value;\r\n        return a === b ? 0 : a \u003e b ? 1 : -1;\r\n    }\r\n    NativeBigInt.prototype.compareTo = NativeBigInt.prototype.compare;\r\n\r\n    BigInteger.prototype.equals = function (v) {\r\n        return this.compare(v) === 0;\r\n    };\r\n    NativeBigInt.prototype.eq = NativeBigInt.prototype.equals = SmallInteger.prototype.eq = SmallInteger.prototype.equals = BigInteger.prototype.eq = BigInteger.prototype.equals;\r\n\r\n    BigInteger.prototype.notEquals = function (v) {\r\n        return this.compare(v) !== 0;\r\n    };\r\n    NativeBigInt.prototype.neq = NativeBigInt.prototype.notEquals = SmallInteger.prototype.neq = SmallInteger.prototype.notEquals = BigInteger.prototype.neq = BigInteger.prototype.notEquals;\r\n\r\n    BigInteger.prototype.greater = function (v) {\r\n        return this.compare(v) \u003e 0;\r\n    };\r\n    NativeBigInt.prototype.gt = NativeBigInt.prototype.greater = SmallInteger.prototype.gt = SmallInteger.prototype.greater = BigInteger.prototype.gt = BigInteger.prototype.greater;\r\n\r\n    BigInteger.prototype.lesser = function (v) {\r\n        return this.compare(v) \u003c 0;\r\n    };\r\n    NativeBigInt.prototype.lt = NativeBigInt.prototype.lesser = SmallInteger.prototype.lt = SmallInteger.prototype.lesser = BigInteger.prototype.lt = BigInteger.prototype.lesser;\r\n\r\n    BigInteger.prototype.greaterOrEquals = function (v) {\r\n        return this.compare(v) \u003e= 0;\r\n    };\r\n    NativeBigInt.prototype.geq = NativeBigInt.prototype.greaterOrEquals = SmallInteger.prototype.geq = SmallInteger.prototype.greaterOrEquals = BigInteger.prototype.geq = BigInteger.prototype.greaterOrEquals;\r\n\r\n    BigInteger.prototype.lesserOrEquals = function (v) {\r\n        return this.compare(v) \u003c= 0;\r\n    };\r\n    NativeBigInt.prototype.leq = NativeBigInt.prototype.lesserOrEquals = SmallInteger.prototype.leq = SmallInteger.prototype.lesserOrEquals = BigInteger.prototype.leq = BigInteger.prototype.lesserOrEquals;\r\n\r\n    BigInteger.prototype.isEven = function () {\r\n        return (this.value[0] \u0026 1) === 0;\r\n    };\r\n    SmallInteger.prototype.isEven = function () {\r\n        return (this.value \u0026 1) === 0;\r\n    };\r\n    NativeBigInt.prototype.isEven = function () {\r\n        return (this.value \u0026 BigInt(1)) === BigInt(0);\r\n    }\r\n\r\n    BigInteger.prototype.isOdd = function () {\r\n        return (this.value[0] \u0026 1) === 1;\r\n    };\r\n    SmallInteger.prototype.isOdd = function () {\r\n        return (this.value \u0026 1) === 1;\r\n    };\r\n    NativeBigInt.prototype.isOdd = function () {\r\n        return (this.value \u0026 BigInt(1)) === BigInt(1);\r\n    }\r\n\r\n    BigInteger.prototype.isPositive = function () {\r\n        return !this.sign;\r\n    };\r\n    SmallInteger.prototype.isPositive = function () {\r\n        return this.value \u003e 0;\r\n    };\r\n    NativeBigInt.prototype.isPositive = SmallInteger.prototype.isPositive;\r\n\r\n    BigInteger.prototype.isNegative = function () {\r\n        return this.sign;\r\n    };\r\n    SmallInteger.prototype.isNegative = function () {\r\n        return this.value \u003c 0;\r\n    };\r\n    NativeBigInt.prototype.isNegative = SmallInteger.prototype.isNegative;\r\n\r\n    BigInteger.prototype.isUnit = function () {\r\n        return false;\r\n    };\r\n    SmallInteger.prototype.isUnit = function () {\r\n        return Math.abs(this.value) === 1;\r\n    };\r\n    NativeBigInt.prototype.isUnit = function () {\r\n        return this.abs().value === BigInt(1);\r\n    }\r\n\r\n    BigInteger.prototype.isZero = function () {\r\n        return false;\r\n    };\r\n    SmallInteger.prototype.isZero = function () {\r\n        return this.value === 0;\r\n    };\r\n    NativeBigInt.prototype.isZero = function () {\r\n        return this.value === BigInt(0);\r\n    }\r\n\r\n    BigInteger.prototype.isDivisibleBy = function (v) {\r\n        var n = parseValue(v);\r\n        if (n.isZero()) return false;\r\n        if (n.isUnit()) return true;\r\n        if (n.compareAbs(2) === 0) return this.isEven();\r\n        return this.mod(n).isZero();\r\n    };\r\n    NativeBigInt.prototype.isDivisibleBy = SmallInteger.prototype.isDivisibleBy = BigInteger.prototype.isDivisibleBy;\r\n\r\n    function isBasicPrime(v) {\r\n        var n = v.abs();\r\n        if (n.isUnit()) return false;\r\n        if (n.equals(2) || n.equals(3) || n.equals(5)) return true;\r\n        if (n.isEven() || n.isDivisibleBy(3) || n.isDivisibleBy(5)) return false;\r\n        if (n.lesser(49)) return true;\r\n        // we don't know if it's prime: let the other functions figure it out\r\n    }\r\n\r\n    function millerRabinTest(n, a) {\r\n        var nPrev = n.prev(),\r\n            b = nPrev,\r\n            r = 0,\r\n            d, t, i, x;\r\n        while (b.isEven()) b = b.divide(2), r++;\r\n        next: for (i = 0; i \u003c a.length; i++) {\r\n            if (n.lesser(a[i])) continue;\r\n            x = bigInt(a[i]).modPow(b, n);\r\n            if (x.isUnit() || x.equals(nPrev)) continue;\r\n            for (d = r - 1; d != 0; d--) {\r\n                x = x.square().mod(n);\r\n                if (x.isUnit()) return false;\r\n                if (x.equals(nPrev)) continue next;\r\n            }\r\n            return false;\r\n        }\r\n        return true;\r\n    }\r\n\r\n    // Set \"strict\" to true to force GRH-supported lower bound of 2*log(N)^2\r\n    BigInteger.prototype.isPrime = function (strict) {\r\n        var isPrime = isBasicPrime(this);\r\n        if (isPrime !== undefined) return isPrime;\r\n        var n = this.abs();\r\n        var bits = n.bitLength();\r\n        if (bits \u003c= 64)\r\n            return millerRabinTest(n, [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37]);\r\n        var logN = Math.log(2) * bits.toJSNumber();\r\n        var t = Math.ceil((strict === true) ? (2 * Math.pow(logN, 2)) : logN);\r\n        for (var a = [], i = 0; i \u003c t; i++) {\r\n            a.push(bigInt(i + 2));\r\n        }\r\n        return millerRabinTest(n, a);\r\n    };\r\n    NativeBigInt.prototype.isPrime = SmallInteger.prototype.isPrime = BigInteger.prototype.isPrime;\r\n\r\n    BigInteger.prototype.isProbablePrime = function (iterations, rng) {\r\n        var isPrime = isBasicPrime(this);\r\n        if (isPrime !== undefined) return isPrime;\r\n        var n = this.abs();\r\n        var t = iterations === undefined ? 5 : iterations;\r\n        for (var a = [], i = 0; i \u003c t; i++) {\r\n            a.push(bigInt.randBetween(2, n.minus(2), rng));\r\n        }\r\n        return millerRabinTest(n, a);\r\n    };\r\n    NativeBigInt.prototype.isProbablePrime = SmallInteger.prototype.isProbablePrime = BigInteger.prototype.isProbablePrime;\r\n\r\n    BigInteger.prototype.modInv = function (n) {\r\n        var t = bigInt.zero, newT = bigInt.one, r = parseValue(n), newR = this.abs(), q, lastT, lastR;\r\n        while (!newR.isZero()) {\r\n            q = r.divide(newR);\r\n            lastT = t;\r\n            lastR = r;\r\n            t = newT;\r\n            r = newR;\r\n            newT = lastT.subtract(q.multiply(newT));\r\n            newR = lastR.subtract(q.multiply(newR));\r\n        }\r\n        if (!r.isUnit()) throw new Error(this.toString() + \" and \" + n.toString() + \" are not co-prime\");\r\n        if (t.compare(0) === -1) {\r\n            t = t.add(n);\r\n        }\r\n        if (this.isNegative()) {\r\n            return t.negate();\r\n        }\r\n        return t;\r\n    };\r\n\r\n    NativeBigInt.prototype.modInv = SmallInteger.prototype.modInv = BigInteger.prototype.modInv;\r\n\r\n    BigInteger.prototype.next = function () {\r\n        var value = this.value;\r\n        if (this.sign) {\r\n            return subtractSmall(value, 1, this.sign);\r\n        }\r\n        return new BigInteger(addSmall(value, 1), this.sign);\r\n    };\r\n    SmallInteger.prototype.next = function () {\r\n        var value = this.value;\r\n        if (value + 1 \u003c MAX_INT) return new SmallInteger(value + 1);\r\n        return new BigInteger(MAX_INT_ARR, false);\r\n    };\r\n    NativeBigInt.prototype.next = function () {\r\n        return new NativeBigInt(this.value + BigInt(1));\r\n    }\r\n\r\n    BigInteger.prototype.prev = function () {\r\n        var value = this.value;\r\n        if (this.sign) {\r\n            return new BigInteger(addSmall(value, 1), true);\r\n        }\r\n        return subtractSmall(value, 1, this.sign);\r\n    };\r\n    SmallInteger.prototype.prev = function () {\r\n        var value = this.value;\r\n        if (value - 1 \u003e -MAX_INT) return new SmallInteger(value - 1);\r\n        return new BigInteger(MAX_INT_ARR, true);\r\n    };\r\n    NativeBigInt.prototype.prev = function () {\r\n        return new NativeBigInt(this.value - BigInt(1));\r\n    }\r\n\r\n    var powersOfTwo = [1];\r\n    while (2 * powersOfTwo[powersOfTwo.length - 1] \u003c= BASE) powersOfTwo.push(2 * powersOfTwo[powersOfTwo.length - 1]);\r\n    var powers2Length = powersOfTwo.length, highestPower2 = powersOfTwo[powers2Length - 1];\r\n\r\n    function shift_isSmall(n) {\r\n        return Math.abs(n) \u003c= BASE;\r\n    }\r\n\r\n    BigInteger.prototype.shiftLeft = function (v) {\r\n        var n = parseValue(v).toJSNumber();\r\n        if (!shift_isSmall(n)) {\r\n            throw new Error(String(n) + \" is too large for shifting.\");\r\n        }\r\n        if (n \u003c 0) return this.shiftRight(-n);\r\n        var result = this;\r\n        if (result.isZero()) return result;\r\n        while (n \u003e= powers2Length) {\r\n            result = result.multiply(highestPower2);\r\n            n -= powers2Length - 1;\r\n        }\r\n        return result.multiply(powersOfTwo[n]);\r\n    };\r\n    NativeBigInt.prototype.shiftLeft = SmallInteger.prototype.shiftLeft = BigInteger.prototype.shiftLeft;\r\n\r\n    BigInteger.prototype.shiftRight = function (v) {\r\n        var remQuo;\r\n        var n = parseValue(v).toJSNumber();\r\n        if (!shift_isSmall(n)) {\r\n            throw new Error(String(n) + \" is too large for shifting.\");\r\n        }\r\n        if (n \u003c 0) return this.shiftLeft(-n);\r\n        var result = this;\r\n        while (n \u003e= powers2Length) {\r\n            if (result.isZero() || (result.isNegative() \u0026\u0026 result.isUnit())) return result;\r\n            remQuo = divModAny(result, highestPower2);\r\n            result = remQuo[1].isNegative() ? remQuo[0].prev() : remQuo[0];\r\n            n -= powers2Length - 1;\r\n        }\r\n        remQuo = divModAny(result, powersOfTwo[n]);\r\n        return remQuo[1].isNegative() ? remQuo[0].prev() : remQuo[0];\r\n    };\r\n    NativeBigInt.prototype.shiftRight = SmallInteger.prototype.shiftRight = BigInteger.prototype.shiftRight;\r\n\r\n    function bitwise(x, y, fn) {\r\n        y = parseValue(y);\r\n        var xSign = x.isNegative(), ySign = y.isNegative();\r\n        var xRem = xSign ? x.not() : x,\r\n            yRem = ySign ? y.not() : y;\r\n        var xDigit = 0, yDigit = 0;\r\n        var xDivMod = null, yDivMod = null;\r\n        var result = [];\r\n        while (!xRem.isZero() || !yRem.isZero()) {\r\n            xDivMod = divModAny(xRem, highestPower2);\r\n            xDigit = xDivMod[1].toJSNumber();\r\n            if (xSign) {\r\n                xDigit = highestPower2 - 1 - xDigit; // two's complement for negative numbers\r\n            }\r\n\r\n            yDivMod = divModAny(yRem, highestPower2);\r\n            yDigit = yDivMod[1].toJSNumber();\r\n            if (ySign) {\r\n                yDigit = highestPower2 - 1 - yDigit; // two's complement for negative numbers\r\n            }\r\n\r\n            xRem = xDivMod[0];\r\n            yRem = yDivMod[0];\r\n            result.push(fn(xDigit, yDigit));\r\n        }\r\n        var sum = fn(xSign ? 1 : 0, ySign ? 1 : 0) !== 0 ? bigInt(-1) : bigInt(0);\r\n        for (var i = result.length - 1; i \u003e= 0; i -= 1) {\r\n            sum = sum.multiply(highestPower2).add(bigInt(result[i]));\r\n        }\r\n        return sum;\r\n    }\r\n\r\n    BigInteger.prototype.not = function () {\r\n        return this.negate().prev();\r\n    };\r\n    NativeBigInt.prototype.not = SmallInteger.prototype.not = BigInteger.prototype.not;\r\n\r\n    BigInteger.prototype.and = function (n) {\r\n        return bitwise(this, n, function (a, b) { return a \u0026 b; });\r\n    };\r\n    NativeBigInt.prototype.and = SmallInteger.prototype.and = BigInteger.prototype.and;\r\n\r\n    BigInteger.prototype.or = function (n) {\r\n        return bitwise(this, n, function (a, b) { return a | b; });\r\n    };\r\n    NativeBigInt.prototype.or = SmallInteger.prototype.or = BigInteger.prototype.or;\r\n\r\n    BigInteger.prototype.xor = function (n) {\r\n        return bitwise(this, n, function (a, b) { return a ^ b; });\r\n    };\r\n    NativeBigInt.prototype.xor = SmallInteger.prototype.xor = BigInteger.prototype.xor;\r\n\r\n    var LOBMASK_I = 1 \u003c\u003c 30, LOBMASK_BI = (BASE \u0026 -BASE) * (BASE \u0026 -BASE) | LOBMASK_I;\r\n    function roughLOB(n) { // get lowestOneBit (rough)\r\n        // SmallInteger: return Min(lowestOneBit(n), 1 \u003c\u003c 30)\r\n        // BigInteger: return Min(lowestOneBit(n), 1 \u003c\u003c 14) [BASE=1e7]\r\n        var v = n.value,\r\n            x = typeof v === \"number\" ? v | LOBMASK_I :\r\n                typeof v === \"bigint\" ? v | BigInt(LOBMASK_I) :\r\n                    v[0] + v[1] * BASE | LOBMASK_BI;\r\n        return x \u0026 -x;\r\n    }\r\n\r\n    function integerLogarithm(value, base) {\r\n        if (base.compareTo(value) \u003c= 0) {\r\n            var tmp = integerLogarithm(value, base.square(base));\r\n            var p = tmp.p;\r\n            var e = tmp.e;\r\n            var t = p.multiply(base);\r\n            return t.compareTo(value) \u003c= 0 ? { p: t, e: e * 2 + 1 } : { p: p, e: e * 2 };\r\n        }\r\n        return { p: bigInt(1), e: 0 };\r\n    }\r\n\r\n    BigInteger.prototype.bitLength = function () {\r\n        var n = this;\r\n        if (n.compareTo(bigInt(0)) \u003c 0) {\r\n            n = n.negate().subtract(bigInt(1));\r\n        }\r\n        if (n.compareTo(bigInt(0)) === 0) {\r\n            return bigInt(0);\r\n        }\r\n        return bigInt(integerLogarithm(n, bigInt(2)).e).add(bigInt(1));\r\n    }\r\n    NativeBigInt.prototype.bitLength = SmallInteger.prototype.bitLength = BigInteger.prototype.bitLength;\r\n\r\n    function max(a, b) {\r\n        a = parseValue(a);\r\n        b = parseValue(b);\r\n        return a.greater(b) ? a : b;\r\n    }\r\n    function min(a, b) {\r\n        a = parseValue(a);\r\n        b = parseValue(b);\r\n        return a.lesser(b) ? a : b;\r\n    }\r\n    function gcd(a, b) {\r\n        a = parseValue(a).abs();\r\n        b = parseValue(b).abs();\r\n        if (a.equals(b)) return a;\r\n        if (a.isZero()) return b;\r\n        if (b.isZero()) return a;\r\n        var c = Integer[1], d, t;\r\n        while (a.isEven() \u0026\u0026 b.isEven()) {\r\n            d = min(roughLOB(a), roughLOB(b));\r\n            a = a.divide(d);\r\n            b = b.divide(d);\r\n            c = c.multiply(d);\r\n        }\r\n        while (a.isEven()) {\r\n            a = a.divide(roughLOB(a));\r\n        }\r\n        do {\r\n            while (b.isEven()) {\r\n                b = b.divide(roughLOB(b));\r\n            }\r\n            if (a.greater(b)) {\r\n                t = b; b = a; a = t;\r\n            }\r\n            b = b.subtract(a);\r\n        } while (!b.isZero());\r\n        return c.isUnit() ? a : a.multiply(c);\r\n    }\r\n    function lcm(a, b) {\r\n        a = parseValue(a).abs();\r\n        b = parseValue(b).abs();\r\n        return a.divide(gcd(a, b)).multiply(b);\r\n    }\r\n    function randBetween(a, b, rng) {\r\n        a = parseValue(a);\r\n        b = parseValue(b);\r\n        var usedRNG = rng || Math.random;\r\n        var low = min(a, b), high = max(a, b);\r\n        var range = high.subtract(low).add(1);\r\n        if (range.isSmall) return low.add(Math.floor(usedRNG() * range));\r\n        var digits = toBase(range, BASE).value;\r\n        var result = [], restricted = true;\r\n        for (var i = 0; i \u003c digits.length; i++) {\r\n            var top = restricted ? digits[i] + (i + 1 \u003c digits.length ? digits[i + 1] / BASE : 0) : BASE;\r\n            var digit = truncate(usedRNG() * top);\r\n            result.push(digit);\r\n            if (digit \u003c digits[i]) restricted = false;\r\n        }\r\n        return low.add(Integer.fromArray(result, BASE, false));\r\n    }\r\n\r\n    var parseBase = function (text, base, alphabet, caseSensitive) {\r\n        alphabet = alphabet || DEFAULT_ALPHABET;\r\n        text = String(text);\r\n        if (!caseSensitive) {\r\n            text = text.toLowerCase();\r\n            alphabet = alphabet.toLowerCase();\r\n        }\r\n        var length = text.length;\r\n        var i;\r\n        var absBase = Math.abs(base);\r\n        var alphabetValues = {};\r\n        for (i = 0; i \u003c alphabet.length; i++) {\r\n            alphabetValues[alphabet[i]] = i;\r\n        }\r\n        for (i = 0; i \u003c length; i++) {\r\n            var c = text[i];\r\n            if (c === \"-\") continue;\r\n            if (c in alphabetValues) {\r\n                if (alphabetValues[c] \u003e= absBase) {\r\n                    if (c === \"1\" \u0026\u0026 absBase === 1) continue;\r\n                    throw new Error(c + \" is not a valid digit in base \" + base + \".\");\r\n                }\r\n            }\r\n        }\r\n        base = parseValue(base);\r\n        var digits = [];\r\n        var isNegative = text[0] === \"-\";\r\n        for (i = isNegative ? 1 : 0; i \u003c text.length; i++) {\r\n            var c = text[i];\r\n            if (c in alphabetValues) digits.push(parseValue(alphabetValues[c]));\r\n            else if (c === \"\u003c\") {\r\n                var start = i;\r\n                do { i++; } while (text[i] !== \"\u003e\" \u0026\u0026 i \u003c text.length);\r\n                digits.push(parseValue(text.slice(start + 1, i)));\r\n            }\r\n            else throw new Error(c + \" is not a valid character\");\r\n        }\r\n        return parseBaseFromArray(digits, base, isNegative);\r\n    };\r\n\r\n    function parseBaseFromArray(digits, base, isNegative) {\r\n        var val = Integer[0], pow = Integer[1], i;\r\n        for (i = digits.length - 1; i \u003e= 0; i--) {\r\n            val = val.add(digits[i].times(pow));\r\n            pow = pow.times(base);\r\n        }\r\n        return isNegative ? val.negate() : val;\r\n    }\r\n\r\n    function stringify(digit, alphabet) {\r\n        alphabet = alphabet || DEFAULT_ALPHABET;\r\n        if (digit \u003c alphabet.length) {\r\n            return alphabet[digit];\r\n        }\r\n        return \"\u003c\" + digit + \"\u003e\";\r\n    }\r\n\r\n    function toBase(n, base) {\r\n        base = bigInt(base);\r\n        if (base.isZero()) {\r\n            if (n.isZero()) return { value: [0], isNegative: false };\r\n            throw new Error(\"Cannot convert nonzero numbers to base 0.\");\r\n        }\r\n        if (base.equals(-1)) {\r\n            if (n.isZero()) return { value: [0], isNegative: false };\r\n            if (n.isNegative())\r\n                return {\r\n                    value: [].concat.apply([], Array.apply(null, Array(-n.toJSNumber()))\r\n                        .map(Array.prototype.valueOf, [1, 0])\r\n                    ),\r\n                    isNegative: false\r\n                };\r\n\r\n            var arr = Array.apply(null, Array(n.toJSNumber() - 1))\r\n                .map(Array.prototype.valueOf, [0, 1]);\r\n            arr.unshift([1]);\r\n            return {\r\n                value: [].concat.apply([], arr),\r\n                isNegative: false\r\n            };\r\n        }\r\n\r\n        var neg = false;\r\n        if (n.isNegative() \u0026\u0026 base.isPositive()) {\r\n            neg = true;\r\n            n = n.abs();\r\n        }\r\n        if (base.isUnit()) {\r\n            if (n.isZero()) return { value: [0], isNegative: false };\r\n\r\n            return {\r\n                value: Array.apply(null, Array(n.toJSNumber()))\r\n                    .map(Number.prototype.valueOf, 1),\r\n                isNegative: neg\r\n            };\r\n        }\r\n        var out = [];\r\n        var left = n, divmod;\r\n        while (left.isNegative() || left.compareAbs(base) \u003e= 0) {\r\n            divmod = left.divmod(base);\r\n            left = divmod.quotient;\r\n            var digit = divmod.remainder;\r\n            if (digit.isNegative()) {\r\n                digit = base.minus(digit).abs();\r\n                left = left.next();\r\n            }\r\n            out.push(digit.toJSNumber());\r\n        }\r\n        out.push(left.toJSNumber());\r\n        return { value: out.reverse(), isNegative: neg };\r\n    }\r\n\r\n    function toBaseString(n, base, alphabet) {\r\n        var arr = toBase(n, base);\r\n        return (arr.isNegative ? \"-\" : \"\") + arr.value.map(function (x) {\r\n            return stringify(x, alphabet);\r\n        }).join('');\r\n    }\r\n\r\n    BigInteger.prototype.toArray = function (radix) {\r\n        return toBase(this, radix);\r\n    };\r\n\r\n    SmallInteger.prototype.toArray = function (radix) {\r\n        return toBase(this, radix);\r\n    };\r\n\r\n    NativeBigInt.prototype.toArray = function (radix) {\r\n        return toBase(this, radix);\r\n    };\r\n\r\n    BigInteger.prototype.toString = function (radix, alphabet) {\r\n        if (radix === undefined) radix = 10;\r\n        if (radix !== 10) return toBaseString(this, radix, alphabet);\r\n        var v = this.value, l = v.length, str = String(v[--l]), zeros = \"0000000\", digit;\r\n        while (--l \u003e= 0) {\r\n            digit = String(v[l]);\r\n            str += zeros.slice(digit.length) + digit;\r\n        }\r\n        var sign = this.sign ? \"-\" : \"\";\r\n        return sign + str;\r\n    };\r\n\r\n    SmallInteger.prototype.toString = function (radix, alphabet) {\r\n        if (radix === undefined) radix = 10;\r\n        if (radix != 10) return toBaseString(this, radix, alphabet);\r\n        return String(this.value);\r\n    };\r\n\r\n    NativeBigInt.prototype.toString = SmallInteger.prototype.toString;\r\n\r\n    NativeBigInt.prototype.toJSON = BigInteger.prototype.toJSON = SmallInteger.prototype.toJSON = function () { return this.toString(); }\r\n\r\n    BigInteger.prototype.valueOf = function () {\r\n        return parseInt(this.toString(), 10);\r\n    };\r\n    BigInteger.prototype.toJSNumber = BigInteger.prototype.valueOf;\r\n\r\n    SmallInteger.prototype.valueOf = function () {\r\n        return this.value;\r\n    };\r\n    SmallInteger.prototype.toJSNumber = SmallInteger.prototype.valueOf;\r\n    NativeBigInt.prototype.valueOf = NativeBigInt.prototype.toJSNumber = function () {\r\n        return parseInt(this.toString(), 10);\r\n    }\r\n\r\n    function parseStringValue(v) {\r\n        if (isPrecise(+v)) {\r\n            var x = +v;\r\n            if (x === truncate(x))\r\n                return supportsNativeBigInt ? new NativeBigInt(BigInt(x)) : new SmallInteger(x);\r\n            throw new Error(\"Invalid integer: \" + v);\r\n        }\r\n        var sign = v[0] === \"-\";\r\n        if (sign) v = v.slice(1);\r\n        var split = v.split(/e/i);\r\n        if (split.length \u003e 2) throw new Error(\"Invalid integer: \" + split.join(\"e\"));\r\n        if (split.length === 2) {\r\n            var exp = split[1];\r\n            if (exp[0] === \"+\") exp = exp.slice(1);\r\n            exp = +exp;\r\n            if (exp !== truncate(exp) || !isPrecise(exp)) throw new Error(\"Invalid integer: \" + exp + \" is not a valid exponent.\");\r\n            var text = split[0];\r\n            var decimalPlace = text.indexOf(\".\");\r\n            if (decimalPlace \u003e= 0) {\r\n                exp -= text.length - decimalPlace - 1;\r\n                text = text.slice(0, decimalPlace) + text.slice(decimalPlace + 1);\r\n            }\r\n            if (exp \u003c 0) throw new Error(\"Cannot include negative exponent part for integers\");\r\n            text += (new Array(exp + 1)).join(\"0\");\r\n            v = text;\r\n        }\r\n        var isValid = /^([0-9][0-9]*)$/.test(v);\r\n        if (!isValid) throw new Error(\"Invalid integer: \" + v);\r\n        if (supportsNativeBigInt) {\r\n            return new NativeBigInt(BigInt(sign ? \"-\" + v : v));\r\n        }\r\n        var r = [], max = v.length, l = LOG_BASE, min = max - l;\r\n        while (max \u003e 0) {\r\n            r.push(+v.slice(min, max));\r\n            min -= l;\r\n            if (min \u003c 0) min = 0;\r\n            max -= l;\r\n        }\r\n        trim(r);\r\n        return new BigInteger(r, sign);\r\n    }\r\n\r\n    function parseNumberValue(v) {\r\n        if (supportsNativeBigInt) {\r\n            return new NativeBigInt(BigInt(v));\r\n        }\r\n        if (isPrecise(v)) {\r\n            if (v !== truncate(v)) throw new Error(v + \" is not an integer.\");\r\n            return new SmallInteger(v);\r\n        }\r\n        return parseStringValue(v.toString());\r\n    }\r\n\r\n    function parseValue(v) {\r\n        if (typeof v === \"number\") {\r\n            return parseNumberValue(v);\r\n        }\r\n        if (typeof v === \"string\") {\r\n            return parseStringValue(v);\r\n        }\r\n        if (typeof v === \"bigint\") {\r\n            return new NativeBigInt(v);\r\n        }\r\n        return v;\r\n    }\r\n    // Pre-define numbers in range [-999,999]\r\n    for (var i = 0; i \u003c 1000; i++) {\r\n        Integer[i] = parseValue(i);\r\n        if (i \u003e 0) Integer[-i] = parseValue(-i);\r\n    }\r\n    // Backwards compatibility\r\n    Integer.one = Integer[1];\r\n    Integer.zero = Integer[0];\r\n    Integer.minusOne = Integer[-1];\r\n    Integer.max = max;\r\n    Integer.min = min;\r\n    Integer.gcd = gcd;\r\n    Integer.lcm = lcm;\r\n    Integer.isInstance = function (x) { return x instanceof BigInteger || x instanceof SmallInteger || x instanceof NativeBigInt; };\r\n    Integer.randBetween = randBetween;\r\n\r\n    Integer.fromArray = function (digits, base, isNegative) {\r\n        return parseBaseFromArray(digits.map(parseValue), parseValue(base || 10), isNegative);\r\n    };\r\n\r\n    return Integer;\r\n})();\r\n\r\n// Node.js check\r\nif (typeof module !== \"undefined\" \u0026\u0026 module.hasOwnProperty(\"exports\")) {\r\n    module.exports = bigInt;\r\n}\r\n\r\n//amd check\r\nif (typeof define === \"function\" \u0026\u0026 define.amd) {\r\n    define( function () {\r\n        return bigInt;\r\n    });\r\n}\r\n","import * as cjsm from \"big-integer\";export default cjsm.default ?? cjsm;"],"version":3}