tweb/public/npm.big-integer.363d763daad0ee4e2741.chunk.js.map

{"version":3,"file":"npm.big-integer.363d763daad0ee4e2741.chunk.js","mappings":"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","sources":["webpack://tweb/./node_modules/big-integer/BigInteger.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 && !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 < 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 < n && n < 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 < 1e7)\r\n            return [n];\r\n        if (n < 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 < 4 && compareAbs(arr, MAX_INT_ARR) < 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 < 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 > 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 >= 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 < l_b; i++) {\r\n            sum = a[i] + b[i] + carry;\r\n            carry = sum >= base ? 1 : 0;\r\n            r[i] = sum - carry * base;\r\n        }\r\n        while (i < 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 > 0) r.push(carry);\r\n        return r;\r\n    }\r\n\r\n    function addAny(a, b) {\r\n        if (a.length >= 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 <= carry < 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 < 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 > 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 < 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 < 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 >= 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 < b_l; i++) {\r\n            difference = a[i] - borrow - b[i];\r\n            if (difference < 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 < a_l; i++) {\r\n            difference = a[i] - borrow;\r\n            if (difference < 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 < 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) >= 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 <= b < 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 < l; i++) {\r\n            difference = a[i] + carry;\r\n            carry = Math.floor(difference / base);\r\n            difference %= base;\r\n            r[i] = difference < 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 < 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 >= 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 >= 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 < a_l; ++i) {\r\n            a_i = a[i];\r\n            for (var j = 0; j < 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| < 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 < 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 > 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-- > 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 <= 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 > 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 < 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 >= 0\r\n        if (a < 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 < 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 < l; i++) {\r\n            a_i = a[i];\r\n            carry = 0 - a_i * a_i;\r\n            for (var j = i; j < 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 <= 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 >= 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 <= base - 1\r\n            carry = 0;\r\n            borrow = 0;\r\n            l = divisor.length;\r\n            for (i = 0; i < 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 < 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 < l; i++) {\r\n                    carry += remainder[shift + i] - base + divisor[i];\r\n                    if (carry < 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) < 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 > 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) <= 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 >= 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 < 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 <= 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 & 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 & _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 > b.length ? 1 : -1;\r\n        }\r\n        for (var i = a.length - 1; i >= 0; i--) {\r\n            if (a[i] !== b[i]) return a[i] > 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 > 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 >= 0 ? a : -a;\r\n        b = b >= 0 ? b : -b;\r\n        return a === b ? 0 : a > 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 > b ? 1 : -1;\r\n        }\r\n        if (a < 0 !== n.sign) {\r\n            return a < 0 ? -1 : 1;\r\n        }\r\n        return a < 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 > 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) > 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) < 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) >= 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) <= 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] & 1) === 0;\r\n    };\r\n    SmallInteger.prototype.isEven = function () {\r\n        return (this.value & 1) === 0;\r\n    };\r\n    NativeBigInt.prototype.isEven = function () {\r\n        return (this.value & BigInt(1)) === BigInt(0);\r\n    }\r\n\r\n    BigInteger.prototype.isOdd = function () {\r\n        return (this.value[0] & 1) === 1;\r\n    };\r\n    SmallInteger.prototype.isOdd = function () {\r\n        return (this.value & 1) === 1;\r\n    };\r\n    NativeBigInt.prototype.isOdd = function () {\r\n        return (this.value & 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 > 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 < 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 < 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 <= 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 < 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 < 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 < 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 > -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] <= 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) <= 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 < 0) return this.shiftRight(-n);\r\n        var result = this;\r\n        if (result.isZero()) return result;\r\n        while (n >= 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 < 0) return this.shiftLeft(-n);\r\n        var result = this;\r\n        while (n >= powers2Length) {\r\n            if (result.isZero() || (result.isNegative() && 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 >= 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 & 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 << 30, LOBMASK_BI = (BASE & -BASE) * (BASE & -BASE) | LOBMASK_I;\r\n    function roughLOB(n) { // get lowestOneBit (rough)\r\n        // SmallInteger: return Min(lowestOneBit(n), 1 << 30)\r\n        // BigInteger: return Min(lowestOneBit(n), 1 << 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 & -x;\r\n    }\r\n\r\n    function integerLogarithm(value, base) {\r\n        if (base.compareTo(value) <= 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) <= 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)) < 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() && 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 < digits.length; i++) {\r\n            var top = restricted ? digits[i] + (i + 1 < digits.length ? digits[i + 1] / BASE : 0) : BASE;\r\n            var digit = truncate(usedRNG() * top);\r\n            result.push(digit);\r\n            if (digit < 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 < alphabet.length; i++) {\r\n            alphabetValues[alphabet[i]] = i;\r\n        }\r\n        for (i = 0; i < length; i++) {\r\n            var c = text[i];\r\n            if (c === \"-\") continue;\r\n            if (c in alphabetValues) {\r\n                if (alphabetValues[c] >= absBase) {\r\n                    if (c === \"1\" && 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 < 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 === \"<\") {\r\n                var start = i;\r\n                do { i++; } while (text[i] !== \">\" && i < 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 >= 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 < alphabet.length) {\r\n            return alphabet[digit];\r\n        }\r\n        return \"<\" + digit + \">\";\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() && 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) >= 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 >= 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 > 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 >= 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 < 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 > 0) {\r\n            r.push(+v.slice(min, max));\r\n            min -= l;\r\n            if (min < 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 < 1000; i++) {\r\n        Integer[i] = parseValue(i);\r\n        if (i > 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\" && module.hasOwnProperty(\"exports\")) {\r\n    module.exports = bigInt;\r\n}\r\n\r\n//amd check\r\nif (typeof define === \"function\" && define.amd) {\r\n    define( function () {\r\n        return bigInt;\r\n    });\r\n}\r\n"],"names":["BASE","MAX_INT","MAX_INT_ARR","smallToArray","DEFAULT_ALPHABET","supportsNativeBigInt","BigInt","Integer","v","radix","alphabet","caseSensitive","parseValue","parseBase","BigInteger","value","sign","this","isSmall","SmallInteger","NativeBigInt","isPrecise","n","Math","floor","arrayToSmall","arr","trim","length","compareAbs","i","createArray","x","Array","truncate","ceil","add","a","b","sum","l_a","l_b","r","carry","base","push","addAny","addSmall","l","subtract","difference","a_l","b_l","borrow","subtractSmall","multiplyLong","product","a_i","j","multiplySmall","shiftLeft","concat","multiplyKaratsuba","y","max","slice","d","c","ac","bd","abcd","multiplySmallAndArray","square","divModSmall","lambda","q","remainder","divisor","quotient","divModAny","self","Error","negate","abs","comparison","quotientDigit","shift","result","divisorMostSignificantDigit","divMod1","guess","xlen","highx","highy","check","part","unshift","reverse","divMod2","qSign","mod","mSign","isBasicPrime","isUnit","equals","isEven","isDivisibleBy","lesser","millerRabinTest","nPrev","prev","divide","next","bigInt","modPow","prototype","Object","create","plus","subtractAny","minus","small","multiply","l1","l2","times","_multiplyBySmall","divmod","over","pow","toString","_0","_1","_2","isNegative","exp","isZero","modInv","isPositive","isOdd","compare","Infinity","compareTo","eq","notEquals","neq","greater","gt","lt","greaterOrEquals","geq","lesserOrEquals","leq","isPrime","strict","undefined","bits","bitLength","logN","log","toJSNumber","t","isProbablePrime","iterations","rng","randBetween","lastT","lastR","zero","newT","one","newR","powersOfTwo","powers2Length","highestPower2","shift_isSmall","bitwise","fn","xSign","ySign","xRem","not","yRem","xDigit","yDigit","xDivMod","yDivMod","String","shiftRight","remQuo","and","or","xor","LOBMASK_I","roughLOB","integerLogarithm","tmp","p","e","min","gcd","text","toLowerCase","absBase","alphabetValues","digits","start","parseBaseFromArray","val","toBase","apply","map","valueOf","neg","Number","out","left","digit","toBaseString","stringify","join","parseStringValue","split","decimalPlace","indexOf","test","parseNumberValue","toArray","str","toJSON","parseInt","minusOne","lcm","isInstance","usedRNG","random","low","range","restricted","top","fromArray","module","hasOwnProperty","exports"],"sourceRoot":""}