{"version":3,"sources":["node_modules/bignumber.js/bignumber.mjs"],"sourcesContent":["/*\r\n * bignumber.js v9.1.2\r\n * A JavaScript library for arbitrary-precision arithmetic.\r\n * https://github.com/MikeMcl/bignumber.js\r\n * Copyright (c) 2022 Michael Mclaughlin \r\n * MIT Licensed.\r\n *\r\n * BigNumber.prototype methods | BigNumber methods\r\n * |\r\n * absoluteValue abs | clone\r\n * comparedTo | config set\r\n * decimalPlaces dp | DECIMAL_PLACES\r\n * dividedBy div | ROUNDING_MODE\r\n * dividedToIntegerBy idiv | EXPONENTIAL_AT\r\n * exponentiatedBy pow | RANGE\r\n * integerValue | CRYPTO\r\n * isEqualTo eq | MODULO_MODE\r\n * isFinite | POW_PRECISION\r\n * isGreaterThan gt | FORMAT\r\n * isGreaterThanOrEqualTo gte | ALPHABET\r\n * isInteger | isBigNumber\r\n * isLessThan lt | maximum max\r\n * isLessThanOrEqualTo lte | minimum min\r\n * isNaN | random\r\n * isNegative | sum\r\n * isPositive |\r\n * isZero |\r\n * minus |\r\n * modulo mod |\r\n * multipliedBy times |\r\n * negated |\r\n * plus |\r\n * precision sd |\r\n * shiftedBy |\r\n * squareRoot sqrt |\r\n * toExponential |\r\n * toFixed |\r\n * toFormat |\r\n * toFraction |\r\n * toJSON |\r\n * toNumber |\r\n * toPrecision |\r\n * toString |\r\n * valueOf |\r\n *\r\n */\n\nvar isNumeric = /^-?(?:\\d+(?:\\.\\d*)?|\\.\\d+)(?:e[+-]?\\d+)?$/i,\n mathceil = Math.ceil,\n mathfloor = Math.floor,\n bignumberError = '[BigNumber Error] ',\n tooManyDigits = bignumberError + 'Number primitive has more than 15 significant digits: ',\n BASE = 1e14,\n LOG_BASE = 14,\n MAX_SAFE_INTEGER = 0x1fffffffffffff,\n // 2^53 - 1\n // MAX_INT32 = 0x7fffffff, // 2^31 - 1\n POWS_TEN = [1, 10, 100, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, 1e10, 1e11, 1e12, 1e13],\n SQRT_BASE = 1e7,\n // EDITABLE\n // The limit on the value of DECIMAL_PLACES, TO_EXP_NEG, TO_EXP_POS, MIN_EXP, MAX_EXP, and\n // the arguments to toExponential, toFixed, toFormat, and toPrecision.\n MAX = 1E9; // 0 to MAX_INT32\n\n/*\r\n * Create and return a BigNumber constructor.\r\n */\nfunction clone(configObject) {\n var div,\n convertBase,\n parseNumeric,\n P = BigNumber.prototype = {\n constructor: BigNumber,\n toString: null,\n valueOf: null\n },\n ONE = new BigNumber(1),\n //----------------------------- EDITABLE CONFIG DEFAULTS -------------------------------\n\n // The default values below must be integers within the inclusive ranges stated.\n // The values can also be changed at run-time using BigNumber.set.\n\n // The maximum number of decimal places for operations involving division.\n DECIMAL_PLACES = 20,\n // 0 to MAX\n\n // The rounding mode used when rounding to the above decimal places, and when using\n // toExponential, toFixed, toFormat and toPrecision, and round (default value).\n // UP 0 Away from zero.\n // DOWN 1 Towards zero.\n // CEIL 2 Towards +Infinity.\n // FLOOR 3 Towards -Infinity.\n // HALF_UP 4 Towards nearest neighbour. If equidistant, up.\n // HALF_DOWN 5 Towards nearest neighbour. If equidistant, down.\n // HALF_EVEN 6 Towards nearest neighbour. If equidistant, towards even neighbour.\n // HALF_CEIL 7 Towards nearest neighbour. If equidistant, towards +Infinity.\n // HALF_FLOOR 8 Towards nearest neighbour. If equidistant, towards -Infinity.\n ROUNDING_MODE = 4,\n // 0 to 8\n\n // EXPONENTIAL_AT : [TO_EXP_NEG , TO_EXP_POS]\n\n // The exponent value at and beneath which toString returns exponential notation.\n // Number type: -7\n TO_EXP_NEG = -7,\n // 0 to -MAX\n\n // The exponent value at and above which toString returns exponential notation.\n // Number type: 21\n TO_EXP_POS = 21,\n // 0 to MAX\n\n // RANGE : [MIN_EXP, MAX_EXP]\n\n // The minimum exponent value, beneath which underflow to zero occurs.\n // Number type: -324 (5e-324)\n MIN_EXP = -1e7,\n // -1 to -MAX\n\n // The maximum exponent value, above which overflow to Infinity occurs.\n // Number type: 308 (1.7976931348623157e+308)\n // For MAX_EXP > 1e7, e.g. new BigNumber('1e100000000').plus(1) may be slow.\n MAX_EXP = 1e7,\n // 1 to MAX\n\n // Whether to use cryptographically-secure random number generation, if available.\n CRYPTO = false,\n // true or false\n\n // The modulo mode used when calculating the modulus: a mod n.\n // The quotient (q = a / n) is calculated according to the corresponding rounding mode.\n // The remainder (r) is calculated as: r = a - n * q.\n //\n // UP 0 The remainder is positive if the dividend is negative, else is negative.\n // DOWN 1 The remainder has the same sign as the dividend.\n // This modulo mode is commonly known as 'truncated division' and is\n // equivalent to (a % n) in JavaScript.\n // FLOOR 3 The remainder has the same sign as the divisor (Python %).\n // HALF_EVEN 6 This modulo mode implements the IEEE 754 remainder function.\n // EUCLID 9 Euclidian division. q = sign(n) * floor(a / abs(n)).\n // The remainder is always positive.\n //\n // The truncated division, floored division, Euclidian division and IEEE 754 remainder\n // modes are commonly used for the modulus operation.\n // Although the other rounding modes can also be used, they may not give useful results.\n MODULO_MODE = 1,\n // 0 to 9\n\n // The maximum number of significant digits of the result of the exponentiatedBy operation.\n // If POW_PRECISION is 0, there will be unlimited significant digits.\n POW_PRECISION = 0,\n // 0 to MAX\n\n // The format specification used by the BigNumber.prototype.toFormat method.\n FORMAT = {\n prefix: '',\n groupSize: 3,\n secondaryGroupSize: 0,\n groupSeparator: ',',\n decimalSeparator: '.',\n fractionGroupSize: 0,\n fractionGroupSeparator: '\\xA0',\n // non-breaking space\n suffix: ''\n },\n // The alphabet used for base conversion. It must be at least 2 characters long, with no '+',\n // '-', '.', whitespace, or repeated character.\n // '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ$_'\n ALPHABET = '0123456789abcdefghijklmnopqrstuvwxyz',\n alphabetHasNormalDecimalDigits = true;\n\n //------------------------------------------------------------------------------------------\n\n // CONSTRUCTOR\n\n /*\r\n * The BigNumber constructor and exported function.\r\n * Create and return a new instance of a BigNumber object.\r\n *\r\n * v {number|string|BigNumber} A numeric value.\r\n * [b] {number} The base of v. Integer, 2 to ALPHABET.length inclusive.\r\n */\n function BigNumber(v, b) {\n var alphabet,\n c,\n caseChanged,\n e,\n i,\n isNum,\n len,\n str,\n x = this;\n\n // Enable constructor call without `new`.\n if (!(x instanceof BigNumber)) return new BigNumber(v, b);\n if (b == null) {\n if (v && v._isBigNumber === true) {\n x.s = v.s;\n if (!v.c || v.e > MAX_EXP) {\n x.c = x.e = null;\n } else if (v.e < MIN_EXP) {\n x.c = [x.e = 0];\n } else {\n x.e = v.e;\n x.c = v.c.slice();\n }\n return;\n }\n if ((isNum = typeof v == 'number') && v * 0 == 0) {\n // Use `1 / n` to handle minus zero also.\n x.s = 1 / v < 0 ? (v = -v, -1) : 1;\n\n // Fast path for integers, where n < 2147483648 (2**31).\n if (v === ~~v) {\n for (e = 0, i = v; i >= 10; i /= 10, e++);\n if (e > MAX_EXP) {\n x.c = x.e = null;\n } else {\n x.e = e;\n x.c = [v];\n }\n return;\n }\n str = String(v);\n } else {\n if (!isNumeric.test(str = String(v))) return parseNumeric(x, str, isNum);\n x.s = str.charCodeAt(0) == 45 ? (str = str.slice(1), -1) : 1;\n }\n\n // Decimal point?\n if ((e = str.indexOf('.')) > -1) str = str.replace('.', '');\n\n // Exponential form?\n if ((i = str.search(/e/i)) > 0) {\n // Determine exponent.\n if (e < 0) e = i;\n e += +str.slice(i + 1);\n str = str.substring(0, i);\n } else if (e < 0) {\n // Integer.\n e = str.length;\n }\n } else {\n // '[BigNumber Error] Base {not a primitive number|not an integer|out of range}: {b}'\n intCheck(b, 2, ALPHABET.length, 'Base');\n\n // Allow exponential notation to be used with base 10 argument, while\n // also rounding to DECIMAL_PLACES as with other bases.\n if (b == 10 && alphabetHasNormalDecimalDigits) {\n x = new BigNumber(v);\n return round(x, DECIMAL_PLACES + x.e + 1, ROUNDING_MODE);\n }\n str = String(v);\n if (isNum = typeof v == 'number') {\n // Avoid potential interpretation of Infinity and NaN as base 44+ values.\n if (v * 0 != 0) return parseNumeric(x, str, isNum, b);\n x.s = 1 / v < 0 ? (str = str.slice(1), -1) : 1;\n\n // '[BigNumber Error] Number primitive has more than 15 significant digits: {n}'\n if (BigNumber.DEBUG && str.replace(/^0\\.0*|\\./, '').length > 15) {\n throw Error(tooManyDigits + v);\n }\n } else {\n x.s = str.charCodeAt(0) === 45 ? (str = str.slice(1), -1) : 1;\n }\n alphabet = ALPHABET.slice(0, b);\n e = i = 0;\n\n // Check that str is a valid base b number.\n // Don't use RegExp, so alphabet can contain special characters.\n for (len = str.length; i < len; i++) {\n if (alphabet.indexOf(c = str.charAt(i)) < 0) {\n if (c == '.') {\n // If '.' is not the first character and it has not be found before.\n if (i > e) {\n e = len;\n continue;\n }\n } else if (!caseChanged) {\n // Allow e.g. hexadecimal 'FF' as well as 'ff'.\n if (str == str.toUpperCase() && (str = str.toLowerCase()) || str == str.toLowerCase() && (str = str.toUpperCase())) {\n caseChanged = true;\n i = -1;\n e = 0;\n continue;\n }\n }\n return parseNumeric(x, String(v), isNum, b);\n }\n }\n\n // Prevent later check for length on converted number.\n isNum = false;\n str = convertBase(str, b, 10, x.s);\n\n // Decimal point?\n if ((e = str.indexOf('.')) > -1) str = str.replace('.', '');else e = str.length;\n }\n\n // Determine leading zeros.\n for (i = 0; str.charCodeAt(i) === 48; i++);\n\n // Determine trailing zeros.\n for (len = str.length; str.charCodeAt(--len) === 48;);\n if (str = str.slice(i, ++len)) {\n len -= i;\n\n // '[BigNumber Error] Number primitive has more than 15 significant digits: {n}'\n if (isNum && BigNumber.DEBUG && len > 15 && (v > MAX_SAFE_INTEGER || v !== mathfloor(v))) {\n throw Error(tooManyDigits + x.s * v);\n }\n\n // Overflow?\n if ((e = e - i - 1) > MAX_EXP) {\n // Infinity.\n x.c = x.e = null;\n\n // Underflow?\n } else if (e < MIN_EXP) {\n // Zero.\n x.c = [x.e = 0];\n } else {\n x.e = e;\n x.c = [];\n\n // Transform base\n\n // e is the base 10 exponent.\n // i is where to slice str to get the first element of the coefficient array.\n i = (e + 1) % LOG_BASE;\n if (e < 0) i += LOG_BASE; // i < 1\n\n if (i < len) {\n if (i) x.c.push(+str.slice(0, i));\n for (len -= LOG_BASE; i < len;) {\n x.c.push(+str.slice(i, i += LOG_BASE));\n }\n i = LOG_BASE - (str = str.slice(i)).length;\n } else {\n i -= len;\n }\n for (; i--; str += '0');\n x.c.push(+str);\n }\n } else {\n // Zero.\n x.c = [x.e = 0];\n }\n }\n\n // CONSTRUCTOR PROPERTIES\n\n BigNumber.clone = clone;\n BigNumber.ROUND_UP = 0;\n BigNumber.ROUND_DOWN = 1;\n BigNumber.ROUND_CEIL = 2;\n BigNumber.ROUND_FLOOR = 3;\n BigNumber.ROUND_HALF_UP = 4;\n BigNumber.ROUND_HALF_DOWN = 5;\n BigNumber.ROUND_HALF_EVEN = 6;\n BigNumber.ROUND_HALF_CEIL = 7;\n BigNumber.ROUND_HALF_FLOOR = 8;\n BigNumber.EUCLID = 9;\n\n /*\r\n * Configure infrequently-changing library-wide settings.\r\n *\r\n * Accept an object with the following optional properties (if the value of a property is\r\n * a number, it must be an integer within the inclusive range stated):\r\n *\r\n * DECIMAL_PLACES {number} 0 to MAX\r\n * ROUNDING_MODE {number} 0 to 8\r\n * EXPONENTIAL_AT {number|number[]} -MAX to MAX or [-MAX to 0, 0 to MAX]\r\n * RANGE {number|number[]} -MAX to MAX (not zero) or [-MAX to -1, 1 to MAX]\r\n * CRYPTO {boolean} true or false\r\n * MODULO_MODE {number} 0 to 9\r\n * POW_PRECISION {number} 0 to MAX\r\n * ALPHABET {string} A string of two or more unique characters which does\r\n * not contain '.'.\r\n * FORMAT {object} An object with some of the following properties:\r\n * prefix {string}\r\n * groupSize {number}\r\n * secondaryGroupSize {number}\r\n * groupSeparator {string}\r\n * decimalSeparator {string}\r\n * fractionGroupSize {number}\r\n * fractionGroupSeparator {string}\r\n * suffix {string}\r\n *\r\n * (The values assigned to the above FORMAT object properties are not checked for validity.)\r\n *\r\n * E.g.\r\n * BigNumber.config({ DECIMAL_PLACES : 20, ROUNDING_MODE : 4 })\r\n *\r\n * Ignore properties/parameters set to null or undefined, except for ALPHABET.\r\n *\r\n * Return an object with the properties current values.\r\n */\n BigNumber.config = BigNumber.set = function (obj) {\n var p, v;\n if (obj != null) {\n if (typeof obj == 'object') {\n // DECIMAL_PLACES {number} Integer, 0 to MAX inclusive.\n // '[BigNumber Error] DECIMAL_PLACES {not a primitive number|not an integer|out of range}: {v}'\n if (obj.hasOwnProperty(p = 'DECIMAL_PLACES')) {\n v = obj[p];\n intCheck(v, 0, MAX, p);\n DECIMAL_PLACES = v;\n }\n\n // ROUNDING_MODE {number} Integer, 0 to 8 inclusive.\n // '[BigNumber Error] ROUNDING_MODE {not a primitive number|not an integer|out of range}: {v}'\n if (obj.hasOwnProperty(p = 'ROUNDING_MODE')) {\n v = obj[p];\n intCheck(v, 0, 8, p);\n ROUNDING_MODE = v;\n }\n\n // EXPONENTIAL_AT {number|number[]}\n // Integer, -MAX to MAX inclusive or\n // [integer -MAX to 0 inclusive, 0 to MAX inclusive].\n // '[BigNumber Error] EXPONENTIAL_AT {not a primitive number|not an integer|out of range}: {v}'\n if (obj.hasOwnProperty(p = 'EXPONENTIAL_AT')) {\n v = obj[p];\n if (v && v.pop) {\n intCheck(v[0], -MAX, 0, p);\n intCheck(v[1], 0, MAX, p);\n TO_EXP_NEG = v[0];\n TO_EXP_POS = v[1];\n } else {\n intCheck(v, -MAX, MAX, p);\n TO_EXP_NEG = -(TO_EXP_POS = v < 0 ? -v : v);\n }\n }\n\n // RANGE {number|number[]} Non-zero integer, -MAX to MAX inclusive or\n // [integer -MAX to -1 inclusive, integer 1 to MAX inclusive].\n // '[BigNumber Error] RANGE {not a primitive number|not an integer|out of range|cannot be zero}: {v}'\n if (obj.hasOwnProperty(p = 'RANGE')) {\n v = obj[p];\n if (v && v.pop) {\n intCheck(v[0], -MAX, -1, p);\n intCheck(v[1], 1, MAX, p);\n MIN_EXP = v[0];\n MAX_EXP = v[1];\n } else {\n intCheck(v, -MAX, MAX, p);\n if (v) {\n MIN_EXP = -(MAX_EXP = v < 0 ? -v : v);\n } else {\n throw Error(bignumberError + p + ' cannot be zero: ' + v);\n }\n }\n }\n\n // CRYPTO {boolean} true or false.\n // '[BigNumber Error] CRYPTO not true or false: {v}'\n // '[BigNumber Error] crypto unavailable'\n if (obj.hasOwnProperty(p = 'CRYPTO')) {\n v = obj[p];\n if (v === !!v) {\n if (v) {\n if (typeof crypto != 'undefined' && crypto && (crypto.getRandomValues || crypto.randomBytes)) {\n CRYPTO = v;\n } else {\n CRYPTO = !v;\n throw Error(bignumberError + 'crypto unavailable');\n }\n } else {\n CRYPTO = v;\n }\n } else {\n throw Error(bignumberError + p + ' not true or false: ' + v);\n }\n }\n\n // MODULO_MODE {number} Integer, 0 to 9 inclusive.\n // '[BigNumber Error] MODULO_MODE {not a primitive number|not an integer|out of range}: {v}'\n if (obj.hasOwnProperty(p = 'MODULO_MODE')) {\n v = obj[p];\n intCheck(v, 0, 9, p);\n MODULO_MODE = v;\n }\n\n // POW_PRECISION {number} Integer, 0 to MAX inclusive.\n // '[BigNumber Error] POW_PRECISION {not a primitive number|not an integer|out of range}: {v}'\n if (obj.hasOwnProperty(p = 'POW_PRECISION')) {\n v = obj[p];\n intCheck(v, 0, MAX, p);\n POW_PRECISION = v;\n }\n\n // FORMAT {object}\n // '[BigNumber Error] FORMAT not an object: {v}'\n if (obj.hasOwnProperty(p = 'FORMAT')) {\n v = obj[p];\n if (typeof v == 'object') FORMAT = v;else throw Error(bignumberError + p + ' not an object: ' + v);\n }\n\n // ALPHABET {string}\n // '[BigNumber Error] ALPHABET invalid: {v}'\n if (obj.hasOwnProperty(p = 'ALPHABET')) {\n v = obj[p];\n\n // Disallow if less than two characters,\n // or if it contains '+', '-', '.', whitespace, or a repeated character.\n if (typeof v == 'string' && !/^.?$|[+\\-.\\s]|(.).*\\1/.test(v)) {\n alphabetHasNormalDecimalDigits = v.slice(0, 10) == '0123456789';\n ALPHABET = v;\n } else {\n throw Error(bignumberError + p + ' invalid: ' + v);\n }\n }\n } else {\n // '[BigNumber Error] Object expected: {v}'\n throw Error(bignumberError + 'Object expected: ' + obj);\n }\n }\n return {\n DECIMAL_PLACES: DECIMAL_PLACES,\n ROUNDING_MODE: ROUNDING_MODE,\n EXPONENTIAL_AT: [TO_EXP_NEG, TO_EXP_POS],\n RANGE: [MIN_EXP, MAX_EXP],\n CRYPTO: CRYPTO,\n MODULO_MODE: MODULO_MODE,\n POW_PRECISION: POW_PRECISION,\n FORMAT: FORMAT,\n ALPHABET: ALPHABET\n };\n };\n\n /*\r\n * Return true if v is a BigNumber instance, otherwise return false.\r\n *\r\n * If BigNumber.DEBUG is true, throw if a BigNumber instance is not well-formed.\r\n *\r\n * v {any}\r\n *\r\n * '[BigNumber Error] Invalid BigNumber: {v}'\r\n */\n BigNumber.isBigNumber = function (v) {\n if (!v || v._isBigNumber !== true) return false;\n if (!BigNumber.DEBUG) return true;\n var i,\n n,\n c = v.c,\n e = v.e,\n s = v.s;\n out: if ({}.toString.call(c) == '[object Array]') {\n if ((s === 1 || s === -1) && e >= -MAX && e <= MAX && e === mathfloor(e)) {\n // If the first element is zero, the BigNumber value must be zero.\n if (c[0] === 0) {\n if (e === 0 && c.length === 1) return true;\n break out;\n }\n\n // Calculate number of digits that c[0] should have, based on the exponent.\n i = (e + 1) % LOG_BASE;\n if (i < 1) i += LOG_BASE;\n\n // Calculate number of digits of c[0].\n //if (Math.ceil(Math.log(c[0] + 1) / Math.LN10) == i) {\n if (String(c[0]).length == i) {\n for (i = 0; i < c.length; i++) {\n n = c[i];\n if (n < 0 || n >= BASE || n !== mathfloor(n)) break out;\n }\n\n // Last element cannot be zero, unless it is the only element.\n if (n !== 0) return true;\n }\n }\n\n // Infinity/NaN\n } else if (c === null && e === null && (s === null || s === 1 || s === -1)) {\n return true;\n }\n throw Error(bignumberError + 'Invalid BigNumber: ' + v);\n };\n\n /*\r\n * Return a new BigNumber whose value is the maximum of the arguments.\r\n *\r\n * arguments {number|string|BigNumber}\r\n */\n BigNumber.maximum = BigNumber.max = function () {\n return maxOrMin(arguments, -1);\n };\n\n /*\r\n * Return a new BigNumber whose value is the minimum of the arguments.\r\n *\r\n * arguments {number|string|BigNumber}\r\n */\n BigNumber.minimum = BigNumber.min = function () {\n return maxOrMin(arguments, 1);\n };\n\n /*\r\n * Return a new BigNumber with a random value equal to or greater than 0 and less than 1,\r\n * and with dp, or DECIMAL_PLACES if dp is omitted, decimal places (or less if trailing\r\n * zeros are produced).\r\n *\r\n * [dp] {number} Decimal places. Integer, 0 to MAX inclusive.\r\n *\r\n * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {dp}'\r\n * '[BigNumber Error] crypto unavailable'\r\n */\n BigNumber.random = function () {\n var pow2_53 = 0x20000000000000;\n\n // Return a 53 bit integer n, where 0 <= n < 9007199254740992.\n // Check if Math.random() produces more than 32 bits of randomness.\n // If it does, assume at least 53 bits are produced, otherwise assume at least 30 bits.\n // 0x40000000 is 2^30, 0x800000 is 2^23, 0x1fffff is 2^21 - 1.\n var random53bitInt = Math.random() * pow2_53 & 0x1fffff ? function () {\n return mathfloor(Math.random() * pow2_53);\n } : function () {\n return (Math.random() * 0x40000000 | 0) * 0x800000 + (Math.random() * 0x800000 | 0);\n };\n return function (dp) {\n var a,\n b,\n e,\n k,\n v,\n i = 0,\n c = [],\n rand = new BigNumber(ONE);\n if (dp == null) dp = DECIMAL_PLACES;else intCheck(dp, 0, MAX);\n k = mathceil(dp / LOG_BASE);\n if (CRYPTO) {\n // Browsers supporting crypto.getRandomValues.\n if (crypto.getRandomValues) {\n a = crypto.getRandomValues(new Uint32Array(k *= 2));\n for (; i < k;) {\n // 53 bits:\n // ((Math.pow(2, 32) - 1) * Math.pow(2, 21)).toString(2)\n // 11111 11111111 11111111 11111111 11100000 00000000 00000000\n // ((Math.pow(2, 32) - 1) >>> 11).toString(2)\n // 11111 11111111 11111111\n // 0x20000 is 2^21.\n v = a[i] * 0x20000 + (a[i + 1] >>> 11);\n\n // Rejection sampling:\n // 0 <= v < 9007199254740992\n // Probability that v >= 9e15, is\n // 7199254740992 / 9007199254740992 ~= 0.0008, i.e. 1 in 1251\n if (v >= 9e15) {\n b = crypto.getRandomValues(new Uint32Array(2));\n a[i] = b[0];\n a[i + 1] = b[1];\n } else {\n // 0 <= v <= 8999999999999999\n // 0 <= (v % 1e14) <= 99999999999999\n c.push(v % 1e14);\n i += 2;\n }\n }\n i = k / 2;\n\n // Node.js supporting crypto.randomBytes.\n } else if (crypto.randomBytes) {\n // buffer\n a = crypto.randomBytes(k *= 7);\n for (; i < k;) {\n // 0x1000000000000 is 2^48, 0x10000000000 is 2^40\n // 0x100000000 is 2^32, 0x1000000 is 2^24\n // 11111 11111111 11111111 11111111 11111111 11111111 11111111\n // 0 <= v < 9007199254740992\n v = (a[i] & 31) * 0x1000000000000 + a[i + 1] * 0x10000000000 + a[i + 2] * 0x100000000 + a[i + 3] * 0x1000000 + (a[i + 4] << 16) + (a[i + 5] << 8) + a[i + 6];\n if (v >= 9e15) {\n crypto.randomBytes(7).copy(a, i);\n } else {\n // 0 <= (v % 1e14) <= 99999999999999\n c.push(v % 1e14);\n i += 7;\n }\n }\n i = k / 7;\n } else {\n CRYPTO = false;\n throw Error(bignumberError + 'crypto unavailable');\n }\n }\n\n // Use Math.random.\n if (!CRYPTO) {\n for (; i < k;) {\n v = random53bitInt();\n if (v < 9e15) c[i++] = v % 1e14;\n }\n }\n k = c[--i];\n dp %= LOG_BASE;\n\n // Convert trailing digits to zeros according to dp.\n if (k && dp) {\n v = POWS_TEN[LOG_BASE - dp];\n c[i] = mathfloor(k / v) * v;\n }\n\n // Remove trailing elements which are zero.\n for (; c[i] === 0; c.pop(), i--);\n\n // Zero?\n if (i < 0) {\n c = [e = 0];\n } else {\n // Remove leading elements which are zero and adjust exponent accordingly.\n for (e = -1; c[0] === 0; c.splice(0, 1), e -= LOG_BASE);\n\n // Count the digits of the first element of c to determine leading zeros, and...\n for (i = 1, v = c[0]; v >= 10; v /= 10, i++);\n\n // adjust the exponent accordingly.\n if (i < LOG_BASE) e -= LOG_BASE - i;\n }\n rand.e = e;\n rand.c = c;\n return rand;\n };\n }();\n\n /*\r\n * Return a BigNumber whose value is the sum of the arguments.\r\n *\r\n * arguments {number|string|BigNumber}\r\n */\n BigNumber.sum = function () {\n var i = 1,\n args = arguments,\n sum = new BigNumber(args[0]);\n for (; i < args.length;) sum = sum.plus(args[i++]);\n return sum;\n };\n\n // PRIVATE FUNCTIONS\n\n // Called by BigNumber and BigNumber.prototype.toString.\n convertBase = function () {\n var decimal = '0123456789';\n\n /*\r\n * Convert string of baseIn to an array of numbers of baseOut.\r\n * Eg. toBaseOut('255', 10, 16) returns [15, 15].\r\n * Eg. toBaseOut('ff', 16, 10) returns [2, 5, 5].\r\n */\n function toBaseOut(str, baseIn, baseOut, alphabet) {\n var j,\n arr = [0],\n arrL,\n i = 0,\n len = str.length;\n for (; i < len;) {\n for (arrL = arr.length; arrL--; arr[arrL] *= baseIn);\n arr[0] += alphabet.indexOf(str.charAt(i++));\n for (j = 0; j < arr.length; j++) {\n if (arr[j] > baseOut - 1) {\n if (arr[j + 1] == null) arr[j + 1] = 0;\n arr[j + 1] += arr[j] / baseOut | 0;\n arr[j] %= baseOut;\n }\n }\n }\n return arr.reverse();\n }\n\n // Convert a numeric string of baseIn to a numeric string of baseOut.\n // If the caller is toString, we are converting from base 10 to baseOut.\n // If the caller is BigNumber, we are converting from baseIn to base 10.\n return function (str, baseIn, baseOut, sign, callerIsToString) {\n var alphabet,\n d,\n e,\n k,\n r,\n x,\n xc,\n y,\n i = str.indexOf('.'),\n dp = DECIMAL_PLACES,\n rm = ROUNDING_MODE;\n\n // Non-integer.\n if (i >= 0) {\n k = POW_PRECISION;\n\n // Unlimited precision.\n POW_PRECISION = 0;\n str = str.replace('.', '');\n y = new BigNumber(baseIn);\n x = y.pow(str.length - i);\n POW_PRECISION = k;\n\n // Convert str as if an integer, then restore the fraction part by dividing the\n // result by its base raised to a power.\n\n y.c = toBaseOut(toFixedPoint(coeffToString(x.c), x.e, '0'), 10, baseOut, decimal);\n y.e = y.c.length;\n }\n\n // Convert the number as integer.\n\n xc = toBaseOut(str, baseIn, baseOut, callerIsToString ? (alphabet = ALPHABET, decimal) : (alphabet = decimal, ALPHABET));\n\n // xc now represents str as an integer and converted to baseOut. e is the exponent.\n e = k = xc.length;\n\n // Remove trailing zeros.\n for (; xc[--k] == 0; xc.pop());\n\n // Zero?\n if (!xc[0]) return alphabet.charAt(0);\n\n // Does str represent an integer? If so, no need for the division.\n if (i < 0) {\n --e;\n } else {\n x.c = xc;\n x.e = e;\n\n // The sign is needed for correct rounding.\n x.s = sign;\n x = div(x, y, dp, rm, baseOut);\n xc = x.c;\n r = x.r;\n e = x.e;\n }\n\n // xc now represents str converted to baseOut.\n\n // THe index of the rounding digit.\n d = e + dp + 1;\n\n // The rounding digit: the digit to the right of the digit that may be rounded up.\n i = xc[d];\n\n // Look at the rounding digits and mode to determine whether to round up.\n\n k = baseOut / 2;\n r = r || d < 0 || xc[d + 1] != null;\n r = rm < 4 ? (i != null || r) && (rm == 0 || rm == (x.s < 0 ? 3 : 2)) : i > k || i == k && (rm == 4 || r || rm == 6 && xc[d - 1] & 1 || rm == (x.s < 0 ? 8 : 7));\n\n // If the index of the rounding digit is not greater than zero, or xc represents\n // zero, then the result of the base conversion is zero or, if rounding up, a value\n // such as 0.00001.\n if (d < 1 || !xc[0]) {\n // 1^-dp or 0\n str = r ? toFixedPoint(alphabet.charAt(1), -dp, alphabet.charAt(0)) : alphabet.charAt(0);\n } else {\n // Truncate xc to the required number of decimal places.\n xc.length = d;\n\n // Round up?\n if (r) {\n // Rounding up may mean the previous digit has to be rounded up and so on.\n for (--baseOut; ++xc[--d] > baseOut;) {\n xc[d] = 0;\n if (!d) {\n ++e;\n xc = [1].concat(xc);\n }\n }\n }\n\n // Determine trailing zeros.\n for (k = xc.length; !xc[--k];);\n\n // E.g. [4, 11, 15] becomes 4bf.\n for (i = 0, str = ''; i <= k; str += alphabet.charAt(xc[i++]));\n\n // Add leading zeros, decimal point and trailing zeros as required.\n str = toFixedPoint(str, e, alphabet.charAt(0));\n }\n\n // The caller will add the sign.\n return str;\n };\n }();\n\n // Perform division in the specified base. Called by div and convertBase.\n div = function () {\n // Assume non-zero x and k.\n function multiply(x, k, base) {\n var m,\n temp,\n xlo,\n xhi,\n carry = 0,\n i = x.length,\n klo = k % SQRT_BASE,\n khi = k / SQRT_BASE | 0;\n for (x = x.slice(); i--;) {\n xlo = x[i] % SQRT_BASE;\n xhi = x[i] / SQRT_BASE | 0;\n m = khi * xlo + xhi * klo;\n temp = klo * xlo + m % SQRT_BASE * SQRT_BASE + carry;\n carry = (temp / base | 0) + (m / SQRT_BASE | 0) + khi * xhi;\n x[i] = temp % base;\n }\n if (carry) x = [carry].concat(x);\n return x;\n }\n function compare(a, b, aL, bL) {\n var i, cmp;\n if (aL != bL) {\n cmp = aL > bL ? 1 : -1;\n } else {\n for (i = cmp = 0; i < aL; i++) {\n if (a[i] != b[i]) {\n cmp = a[i] > b[i] ? 1 : -1;\n break;\n }\n }\n }\n return cmp;\n }\n function subtract(a, b, aL, base) {\n var i = 0;\n\n // Subtract b from a.\n for (; aL--;) {\n a[aL] -= i;\n i = a[aL] < b[aL] ? 1 : 0;\n a[aL] = i * base + a[aL] - b[aL];\n }\n\n // Remove leading zeros.\n for (; !a[0] && a.length > 1; a.splice(0, 1));\n }\n\n // x: dividend, y: divisor.\n return function (x, y, dp, rm, base) {\n var cmp,\n e,\n i,\n more,\n n,\n prod,\n prodL,\n q,\n qc,\n rem,\n remL,\n rem0,\n xi,\n xL,\n yc0,\n yL,\n yz,\n s = x.s == y.s ? 1 : -1,\n xc = x.c,\n yc = y.c;\n\n // Either NaN, Infinity or 0?\n if (!xc || !xc[0] || !yc || !yc[0]) {\n return new BigNumber(\n // Return NaN if either NaN, or both Infinity or 0.\n !x.s || !y.s || (xc ? yc && xc[0] == yc[0] : !yc) ? NaN :\n // Return ±0 if x is ±0 or y is ±Infinity, or return ±Infinity as y is ±0.\n xc && xc[0] == 0 || !yc ? s * 0 : s / 0);\n }\n q = new BigNumber(s);\n qc = q.c = [];\n e = x.e - y.e;\n s = dp + e + 1;\n if (!base) {\n base = BASE;\n e = bitFloor(x.e / LOG_BASE) - bitFloor(y.e / LOG_BASE);\n s = s / LOG_BASE | 0;\n }\n\n // Result exponent may be one less then the current value of e.\n // The coefficients of the BigNumbers from convertBase may have trailing zeros.\n for (i = 0; yc[i] == (xc[i] || 0); i++);\n if (yc[i] > (xc[i] || 0)) e--;\n if (s < 0) {\n qc.push(1);\n more = true;\n } else {\n xL = xc.length;\n yL = yc.length;\n i = 0;\n s += 2;\n\n // Normalise xc and yc so highest order digit of yc is >= base / 2.\n\n n = mathfloor(base / (yc[0] + 1));\n\n // Not necessary, but to handle odd bases where yc[0] == (base / 2) - 1.\n // if (n > 1 || n++ == 1 && yc[0] < base / 2) {\n if (n > 1) {\n yc = multiply(yc, n, base);\n xc = multiply(xc, n, base);\n yL = yc.length;\n xL = xc.length;\n }\n xi = yL;\n rem = xc.slice(0, yL);\n remL = rem.length;\n\n // Add zeros to make remainder as long as divisor.\n for (; remL < yL; rem[remL++] = 0);\n yz = yc.slice();\n yz = [0].concat(yz);\n yc0 = yc[0];\n if (yc[1] >= base / 2) yc0++;\n // Not necessary, but to prevent trial digit n > base, when using base 3.\n // else if (base == 3 && yc0 == 1) yc0 = 1 + 1e-15;\n\n do {\n n = 0;\n\n // Compare divisor and remainder.\n cmp = compare(yc, rem, yL, remL);\n\n // If divisor < remainder.\n if (cmp < 0) {\n // Calculate trial digit, n.\n\n rem0 = rem[0];\n if (yL != remL) rem0 = rem0 * base + (rem[1] || 0);\n\n // n is how many times the divisor goes into the current remainder.\n n = mathfloor(rem0 / yc0);\n\n // Algorithm:\n // product = divisor multiplied by trial digit (n).\n // Compare product and remainder.\n // If product is greater than remainder:\n // Subtract divisor from product, decrement trial digit.\n // Subtract product from remainder.\n // If product was less than remainder at the last compare:\n // Compare new remainder and divisor.\n // If remainder is greater than divisor:\n // Subtract divisor from remainder, increment trial digit.\n\n if (n > 1) {\n // n may be > base only when base is 3.\n if (n >= base) n = base - 1;\n\n // product = divisor * trial digit.\n prod = multiply(yc, n, base);\n prodL = prod.length;\n remL = rem.length;\n\n // Compare product and remainder.\n // If product > remainder then trial digit n too high.\n // n is 1 too high about 5% of the time, and is not known to have\n // ever been more than 1 too high.\n while (compare(prod, rem, prodL, remL) == 1) {\n n--;\n\n // Subtract divisor from product.\n subtract(prod, yL < prodL ? yz : yc, prodL, base);\n prodL = prod.length;\n cmp = 1;\n }\n } else {\n // n is 0 or 1, cmp is -1.\n // If n is 0, there is no need to compare yc and rem again below,\n // so change cmp to 1 to avoid it.\n // If n is 1, leave cmp as -1, so yc and rem are compared again.\n if (n == 0) {\n // divisor < remainder, so n must be at least 1.\n cmp = n = 1;\n }\n\n // product = divisor\n prod = yc.slice();\n prodL = prod.length;\n }\n if (prodL < remL) prod = [0].concat(prod);\n\n // Subtract product from remainder.\n subtract(rem, prod, remL, base);\n remL = rem.length;\n\n // If product was < remainder.\n if (cmp == -1) {\n // Compare divisor and new remainder.\n // If divisor < new remainder, subtract divisor from remainder.\n // Trial digit n too low.\n // n is 1 too low about 5% of the time, and very rarely 2 too low.\n while (compare(yc, rem, yL, remL) < 1) {\n n++;\n\n // Subtract divisor from remainder.\n subtract(rem, yL < remL ? yz : yc, remL, base);\n remL = rem.length;\n }\n }\n } else if (cmp === 0) {\n n++;\n rem = [0];\n } // else cmp === 1 and n will be 0\n\n // Add the next digit, n, to the result array.\n qc[i++] = n;\n\n // Update the remainder.\n if (rem[0]) {\n rem[remL++] = xc[xi] || 0;\n } else {\n rem = [xc[xi]];\n remL = 1;\n }\n } while ((xi++ < xL || rem[0] != null) && s--);\n more = rem[0] != null;\n\n // Leading zero?\n if (!qc[0]) qc.splice(0, 1);\n }\n if (base == BASE) {\n // To calculate q.e, first get the number of digits of qc[0].\n for (i = 1, s = qc[0]; s >= 10; s /= 10, i++);\n round(q, dp + (q.e = i + e * LOG_BASE - 1) + 1, rm, more);\n\n // Caller is convertBase.\n } else {\n q.e = e;\n q.r = +more;\n }\n return q;\n };\n }();\n\n /*\r\n * Return a string representing the value of BigNumber n in fixed-point or exponential\r\n * notation rounded to the specified decimal places or significant digits.\r\n *\r\n * n: a BigNumber.\r\n * i: the index of the last digit required (i.e. the digit that may be rounded up).\r\n * rm: the rounding mode.\r\n * id: 1 (toExponential) or 2 (toPrecision).\r\n */\n function format(n, i, rm, id) {\n var c0, e, ne, len, str;\n if (rm == null) rm = ROUNDING_MODE;else intCheck(rm, 0, 8);\n if (!n.c) return n.toString();\n c0 = n.c[0];\n ne = n.e;\n if (i == null) {\n str = coeffToString(n.c);\n str = id == 1 || id == 2 && (ne <= TO_EXP_NEG || ne >= TO_EXP_POS) ? toExponential(str, ne) : toFixedPoint(str, ne, '0');\n } else {\n n = round(new BigNumber(n), i, rm);\n\n // n.e may have changed if the value was rounded up.\n e = n.e;\n str = coeffToString(n.c);\n len = str.length;\n\n // toPrecision returns exponential notation if the number of significant digits\n // specified is less than the number of digits necessary to represent the integer\n // part of the value in fixed-point notation.\n\n // Exponential notation.\n if (id == 1 || id == 2 && (i <= e || e <= TO_EXP_NEG)) {\n // Append zeros?\n for (; len < i; str += '0', len++);\n str = toExponential(str, e);\n\n // Fixed-point notation.\n } else {\n i -= ne;\n str = toFixedPoint(str, e, '0');\n\n // Append zeros?\n if (e + 1 > len) {\n if (--i > 0) for (str += '.'; i--; str += '0');\n } else {\n i += e - len;\n if (i > 0) {\n if (e + 1 == len) str += '.';\n for (; i--; str += '0');\n }\n }\n }\n }\n return n.s < 0 && c0 ? '-' + str : str;\n }\n\n // Handle BigNumber.max and BigNumber.min.\n // If any number is NaN, return NaN.\n function maxOrMin(args, n) {\n var k,\n y,\n i = 1,\n x = new BigNumber(args[0]);\n for (; i < args.length; i++) {\n y = new BigNumber(args[i]);\n if (!y.s || (k = compare(x, y)) === n || k === 0 && x.s === n) {\n x = y;\n }\n }\n return x;\n }\n\n /*\r\n * Strip trailing zeros, calculate base 10 exponent and check against MIN_EXP and MAX_EXP.\r\n * Called by minus, plus and times.\r\n */\n function normalise(n, c, e) {\n var i = 1,\n j = c.length;\n\n // Remove trailing zeros.\n for (; !c[--j]; c.pop());\n\n // Calculate the base 10 exponent. First get the number of digits of c[0].\n for (j = c[0]; j >= 10; j /= 10, i++);\n\n // Overflow?\n if ((e = i + e * LOG_BASE - 1) > MAX_EXP) {\n // Infinity.\n n.c = n.e = null;\n\n // Underflow?\n } else if (e < MIN_EXP) {\n // Zero.\n n.c = [n.e = 0];\n } else {\n n.e = e;\n n.c = c;\n }\n return n;\n }\n\n // Handle values that fail the validity test in BigNumber.\n parseNumeric = function () {\n var basePrefix = /^(-?)0([xbo])(?=\\w[\\w.]*$)/i,\n dotAfter = /^([^.]+)\\.$/,\n dotBefore = /^\\.([^.]+)$/,\n isInfinityOrNaN = /^-?(Infinity|NaN)$/,\n whitespaceOrPlus = /^\\s*\\+(?=[\\w.])|^\\s+|\\s+$/g;\n return function (x, str, isNum, b) {\n var base,\n s = isNum ? str : str.replace(whitespaceOrPlus, '');\n\n // No exception on ±Infinity or NaN.\n if (isInfinityOrNaN.test(s)) {\n x.s = isNaN(s) ? null : s < 0 ? -1 : 1;\n } else {\n if (!isNum) {\n // basePrefix = /^(-?)0([xbo])(?=\\w[\\w.]*$)/i\n s = s.replace(basePrefix, function (m, p1, p2) {\n base = (p2 = p2.toLowerCase()) == 'x' ? 16 : p2 == 'b' ? 2 : 8;\n return !b || b == base ? p1 : m;\n });\n if (b) {\n base = b;\n\n // E.g. '1.' to '1', '.1' to '0.1'\n s = s.replace(dotAfter, '$1').replace(dotBefore, '0.$1');\n }\n if (str != s) return new BigNumber(s, base);\n }\n\n // '[BigNumber Error] Not a number: {n}'\n // '[BigNumber Error] Not a base {b} number: {n}'\n if (BigNumber.DEBUG) {\n throw Error(bignumberError + 'Not a' + (b ? ' base ' + b : '') + ' number: ' + str);\n }\n\n // NaN\n x.s = null;\n }\n x.c = x.e = null;\n };\n }();\n\n /*\r\n * Round x to sd significant digits using rounding mode rm. Check for over/under-flow.\r\n * If r is truthy, it is known that there are more digits after the rounding digit.\r\n */\n function round(x, sd, rm, r) {\n var d,\n i,\n j,\n k,\n n,\n ni,\n rd,\n xc = x.c,\n pows10 = POWS_TEN;\n\n // if x is not Infinity or NaN...\n if (xc) {\n // rd is the rounding digit, i.e. the digit after the digit that may be rounded up.\n // n is a base 1e14 number, the value of the element of array x.c containing rd.\n // ni is the index of n within x.c.\n // d is the number of digits of n.\n // i is the index of rd within n including leading zeros.\n // j is the actual index of rd within n (if < 0, rd is a leading zero).\n out: {\n // Get the number of digits of the first element of xc.\n for (d = 1, k = xc[0]; k >= 10; k /= 10, d++);\n i = sd - d;\n\n // If the rounding digit is in the first element of xc...\n if (i < 0) {\n i += LOG_BASE;\n j = sd;\n n = xc[ni = 0];\n\n // Get the rounding digit at index j of n.\n rd = mathfloor(n / pows10[d - j - 1] % 10);\n } else {\n ni = mathceil((i + 1) / LOG_BASE);\n if (ni >= xc.length) {\n if (r) {\n // Needed by sqrt.\n for (; xc.length <= ni; xc.push(0));\n n = rd = 0;\n d = 1;\n i %= LOG_BASE;\n j = i - LOG_BASE + 1;\n } else {\n break out;\n }\n } else {\n n = k = xc[ni];\n\n // Get the number of digits of n.\n for (d = 1; k >= 10; k /= 10, d++);\n\n // Get the index of rd within n.\n i %= LOG_BASE;\n\n // Get the index of rd within n, adjusted for leading zeros.\n // The number of leading zeros of n is given by LOG_BASE - d.\n j = i - LOG_BASE + d;\n\n // Get the rounding digit at index j of n.\n rd = j < 0 ? 0 : mathfloor(n / pows10[d - j - 1] % 10);\n }\n }\n r = r || sd < 0 ||\n // Are there any non-zero digits after the rounding digit?\n // The expression n % pows10[d - j - 1] returns all digits of n to the right\n // of the digit at j, e.g. if n is 908714 and j is 2, the expression gives 714.\n xc[ni + 1] != null || (j < 0 ? n : n % pows10[d - j - 1]);\n r = rm < 4 ? (rd || r) && (rm == 0 || rm == (x.s < 0 ? 3 : 2)) : rd > 5 || rd == 5 && (rm == 4 || r || rm == 6 &&\n // Check whether the digit to the left of the rounding digit is odd.\n (i > 0 ? j > 0 ? n / pows10[d - j] : 0 : xc[ni - 1]) % 10 & 1 || rm == (x.s < 0 ? 8 : 7));\n if (sd < 1 || !xc[0]) {\n xc.length = 0;\n if (r) {\n // Convert sd to decimal places.\n sd -= x.e + 1;\n\n // 1, 0.1, 0.01, 0.001, 0.0001 etc.\n xc[0] = pows10[(LOG_BASE - sd % LOG_BASE) % LOG_BASE];\n x.e = -sd || 0;\n } else {\n // Zero.\n xc[0] = x.e = 0;\n }\n return x;\n }\n\n // Remove excess digits.\n if (i == 0) {\n xc.length = ni;\n k = 1;\n ni--;\n } else {\n xc.length = ni + 1;\n k = pows10[LOG_BASE - i];\n\n // E.g. 56700 becomes 56000 if 7 is the rounding digit.\n // j > 0 means i > number of leading zeros of n.\n xc[ni] = j > 0 ? mathfloor(n / pows10[d - j] % pows10[j]) * k : 0;\n }\n\n // Round up?\n if (r) {\n for (;;) {\n // If the digit to be rounded up is in the first element of xc...\n if (ni == 0) {\n // i will be the length of xc[0] before k is added.\n for (i = 1, j = xc[0]; j >= 10; j /= 10, i++);\n j = xc[0] += k;\n for (k = 1; j >= 10; j /= 10, k++);\n\n // if i != k the length has increased.\n if (i != k) {\n x.e++;\n if (xc[0] == BASE) xc[0] = 1;\n }\n break;\n } else {\n xc[ni] += k;\n if (xc[ni] != BASE) break;\n xc[ni--] = 0;\n k = 1;\n }\n }\n }\n\n // Remove trailing zeros.\n for (i = xc.length; xc[--i] === 0; xc.pop());\n }\n\n // Overflow? Infinity.\n if (x.e > MAX_EXP) {\n x.c = x.e = null;\n\n // Underflow? Zero.\n } else if (x.e < MIN_EXP) {\n x.c = [x.e = 0];\n }\n }\n return x;\n }\n function valueOf(n) {\n var str,\n e = n.e;\n if (e === null) return n.toString();\n str = coeffToString(n.c);\n str = e <= TO_EXP_NEG || e >= TO_EXP_POS ? toExponential(str, e) : toFixedPoint(str, e, '0');\n return n.s < 0 ? '-' + str : str;\n }\n\n // PROTOTYPE/INSTANCE METHODS\n\n /*\r\n * Return a new BigNumber whose value is the absolute value of this BigNumber.\r\n */\n P.absoluteValue = P.abs = function () {\n var x = new BigNumber(this);\n if (x.s < 0) x.s = 1;\n return x;\n };\n\n /*\r\n * Return\r\n * 1 if the value of this BigNumber is greater than the value of BigNumber(y, b),\r\n * -1 if the value of this BigNumber is less than the value of BigNumber(y, b),\r\n * 0 if they have the same value,\r\n * or null if the value of either is NaN.\r\n */\n P.comparedTo = function (y, b) {\n return compare(this, new BigNumber(y, b));\n };\n\n /*\r\n * If dp is undefined or null or true or false, return the number of decimal places of the\r\n * value of this BigNumber, or null if the value of this BigNumber is ±Infinity or NaN.\r\n *\r\n * Otherwise, if dp is a number, return a new BigNumber whose value is the value of this\r\n * BigNumber rounded to a maximum of dp decimal places using rounding mode rm, or\r\n * ROUNDING_MODE if rm is omitted.\r\n *\r\n * [dp] {number} Decimal places: integer, 0 to MAX inclusive.\r\n * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n *\r\n * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {dp|rm}'\r\n */\n P.decimalPlaces = P.dp = function (dp, rm) {\n var c,\n n,\n v,\n x = this;\n if (dp != null) {\n intCheck(dp, 0, MAX);\n if (rm == null) rm = ROUNDING_MODE;else intCheck(rm, 0, 8);\n return round(new BigNumber(x), dp + x.e + 1, rm);\n }\n if (!(c = x.c)) return null;\n n = ((v = c.length - 1) - bitFloor(this.e / LOG_BASE)) * LOG_BASE;\n\n // Subtract the number of trailing zeros of the last number.\n if (v = c[v]) for (; v % 10 == 0; v /= 10, n--);\n if (n < 0) n = 0;\n return n;\n };\n\n /*\r\n * n / 0 = I\r\n * n / N = N\r\n * n / I = 0\r\n * 0 / n = 0\r\n * 0 / 0 = N\r\n * 0 / N = N\r\n * 0 / I = 0\r\n * N / n = N\r\n * N / 0 = N\r\n * N / N = N\r\n * N / I = N\r\n * I / n = I\r\n * I / 0 = I\r\n * I / N = N\r\n * I / I = N\r\n *\r\n * Return a new BigNumber whose value is the value of this BigNumber divided by the value of\r\n * BigNumber(y, b), rounded according to DECIMAL_PLACES and ROUNDING_MODE.\r\n */\n P.dividedBy = P.div = function (y, b) {\n return div(this, new BigNumber(y, b), DECIMAL_PLACES, ROUNDING_MODE);\n };\n\n /*\r\n * Return a new BigNumber whose value is the integer part of dividing the value of this\r\n * BigNumber by the value of BigNumber(y, b).\r\n */\n P.dividedToIntegerBy = P.idiv = function (y, b) {\n return div(this, new BigNumber(y, b), 0, 1);\n };\n\n /*\r\n * Return a BigNumber whose value is the value of this BigNumber exponentiated by n.\r\n *\r\n * If m is present, return the result modulo m.\r\n * If n is negative round according to DECIMAL_PLACES and ROUNDING_MODE.\r\n * If POW_PRECISION is non-zero and m is not present, round to POW_PRECISION using ROUNDING_MODE.\r\n *\r\n * The modular power operation works efficiently when x, n, and m are integers, otherwise it\r\n * is equivalent to calculating x.exponentiatedBy(n).modulo(m) with a POW_PRECISION of 0.\r\n *\r\n * n {number|string|BigNumber} The exponent. An integer.\r\n * [m] {number|string|BigNumber} The modulus.\r\n *\r\n * '[BigNumber Error] Exponent not an integer: {n}'\r\n */\n P.exponentiatedBy = P.pow = function (n, m) {\n var half,\n isModExp,\n i,\n k,\n more,\n nIsBig,\n nIsNeg,\n nIsOdd,\n y,\n x = this;\n n = new BigNumber(n);\n\n // Allow NaN and ±Infinity, but not other non-integers.\n if (n.c && !n.isInteger()) {\n throw Error(bignumberError + 'Exponent not an integer: ' + valueOf(n));\n }\n if (m != null) m = new BigNumber(m);\n\n // Exponent of MAX_SAFE_INTEGER is 15.\n nIsBig = n.e > 14;\n\n // If x is NaN, ±Infinity, ±0 or ±1, or n is ±Infinity, NaN or ±0.\n if (!x.c || !x.c[0] || x.c[0] == 1 && !x.e && x.c.length == 1 || !n.c || !n.c[0]) {\n // The sign of the result of pow when x is negative depends on the evenness of n.\n // If +n overflows to ±Infinity, the evenness of n would be not be known.\n y = new BigNumber(Math.pow(+valueOf(x), nIsBig ? n.s * (2 - isOdd(n)) : +valueOf(n)));\n return m ? y.mod(m) : y;\n }\n nIsNeg = n.s < 0;\n if (m) {\n // x % m returns NaN if abs(m) is zero, or m is NaN.\n if (m.c ? !m.c[0] : !m.s) return new BigNumber(NaN);\n isModExp = !nIsNeg && x.isInteger() && m.isInteger();\n if (isModExp) x = x.mod(m);\n\n // Overflow to ±Infinity: >=2**1e10 or >=1.0000024**1e15.\n // Underflow to ±0: <=0.79**1e10 or <=0.9999975**1e15.\n } else if (n.e > 9 && (x.e > 0 || x.e < -1 || (x.e == 0\n // [1, 240000000]\n ? x.c[0] > 1 || nIsBig && x.c[1] >= 24e7\n // [80000000000000] [99999750000000]\n : x.c[0] < 8e13 || nIsBig && x.c[0] <= 9999975e7))) {\n // If x is negative and n is odd, k = -0, else k = 0.\n k = x.s < 0 && isOdd(n) ? -0 : 0;\n\n // If x >= 1, k = ±Infinity.\n if (x.e > -1) k = 1 / k;\n\n // If n is negative return ±0, else return ±Infinity.\n return new BigNumber(nIsNeg ? 1 / k : k);\n } else if (POW_PRECISION) {\n // Truncating each coefficient array to a length of k after each multiplication\n // equates to truncating significant digits to POW_PRECISION + [28, 41],\n // i.e. there will be a minimum of 28 guard digits retained.\n k = mathceil(POW_PRECISION / LOG_BASE + 2);\n }\n if (nIsBig) {\n half = new BigNumber(0.5);\n if (nIsNeg) n.s = 1;\n nIsOdd = isOdd(n);\n } else {\n i = Math.abs(+valueOf(n));\n nIsOdd = i % 2;\n }\n y = new BigNumber(ONE);\n\n // Performs 54 loop iterations for n of 9007199254740991.\n for (;;) {\n if (nIsOdd) {\n y = y.times(x);\n if (!y.c) break;\n if (k) {\n if (y.c.length > k) y.c.length = k;\n } else if (isModExp) {\n y = y.mod(m); //y = y.minus(div(y, m, 0, MODULO_MODE).times(m));\n }\n }\n if (i) {\n i = mathfloor(i / 2);\n if (i === 0) break;\n nIsOdd = i % 2;\n } else {\n n = n.times(half);\n round(n, n.e + 1, 1);\n if (n.e > 14) {\n nIsOdd = isOdd(n);\n } else {\n i = +valueOf(n);\n if (i === 0) break;\n nIsOdd = i % 2;\n }\n }\n x = x.times(x);\n if (k) {\n if (x.c && x.c.length > k) x.c.length = k;\n } else if (isModExp) {\n x = x.mod(m); //x = x.minus(div(x, m, 0, MODULO_MODE).times(m));\n }\n }\n if (isModExp) return y;\n if (nIsNeg) y = ONE.div(y);\n return m ? y.mod(m) : k ? round(y, POW_PRECISION, ROUNDING_MODE, more) : y;\n };\n\n /*\r\n * Return a new BigNumber whose value is the value of this BigNumber rounded to an integer\r\n * using rounding mode rm, or ROUNDING_MODE if rm is omitted.\r\n *\r\n * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n *\r\n * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {rm}'\r\n */\n P.integerValue = function (rm) {\n var n = new BigNumber(this);\n if (rm == null) rm = ROUNDING_MODE;else intCheck(rm, 0, 8);\n return round(n, n.e + 1, rm);\n };\n\n /*\r\n * Return true if the value of this BigNumber is equal to the value of BigNumber(y, b),\r\n * otherwise return false.\r\n */\n P.isEqualTo = P.eq = function (y, b) {\n return compare(this, new BigNumber(y, b)) === 0;\n };\n\n /*\r\n * Return true if the value of this BigNumber is a finite number, otherwise return false.\r\n */\n P.isFinite = function () {\n return !!this.c;\n };\n\n /*\r\n * Return true if the value of this BigNumber is greater than the value of BigNumber(y, b),\r\n * otherwise return false.\r\n */\n P.isGreaterThan = P.gt = function (y, b) {\n return compare(this, new BigNumber(y, b)) > 0;\n };\n\n /*\r\n * Return true if the value of this BigNumber is greater than or equal to the value of\r\n * BigNumber(y, b), otherwise return false.\r\n */\n P.isGreaterThanOrEqualTo = P.gte = function (y, b) {\n return (b = compare(this, new BigNumber(y, b))) === 1 || b === 0;\n };\n\n /*\r\n * Return true if the value of this BigNumber is an integer, otherwise return false.\r\n */\n P.isInteger = function () {\n return !!this.c && bitFloor(this.e / LOG_BASE) > this.c.length - 2;\n };\n\n /*\r\n * Return true if the value of this BigNumber is less than the value of BigNumber(y, b),\r\n * otherwise return false.\r\n */\n P.isLessThan = P.lt = function (y, b) {\n return compare(this, new BigNumber(y, b)) < 0;\n };\n\n /*\r\n * Return true if the value of this BigNumber is less than or equal to the value of\r\n * BigNumber(y, b), otherwise return false.\r\n */\n P.isLessThanOrEqualTo = P.lte = function (y, b) {\n return (b = compare(this, new BigNumber(y, b))) === -1 || b === 0;\n };\n\n /*\r\n * Return true if the value of this BigNumber is NaN, otherwise return false.\r\n */\n P.isNaN = function () {\n return !this.s;\n };\n\n /*\r\n * Return true if the value of this BigNumber is negative, otherwise return false.\r\n */\n P.isNegative = function () {\n return this.s < 0;\n };\n\n /*\r\n * Return true if the value of this BigNumber is positive, otherwise return false.\r\n */\n P.isPositive = function () {\n return this.s > 0;\n };\n\n /*\r\n * Return true if the value of this BigNumber is 0 or -0, otherwise return false.\r\n */\n P.isZero = function () {\n return !!this.c && this.c[0] == 0;\n };\n\n /*\r\n * n - 0 = n\r\n * n - N = N\r\n * n - I = -I\r\n * 0 - n = -n\r\n * 0 - 0 = 0\r\n * 0 - N = N\r\n * 0 - I = -I\r\n * N - n = N\r\n * N - 0 = N\r\n * N - N = N\r\n * N - I = N\r\n * I - n = I\r\n * I - 0 = I\r\n * I - N = N\r\n * I - I = N\r\n *\r\n * Return a new BigNumber whose value is the value of this BigNumber minus the value of\r\n * BigNumber(y, b).\r\n */\n P.minus = function (y, b) {\n var i,\n j,\n t,\n xLTy,\n x = this,\n a = x.s;\n y = new BigNumber(y, b);\n b = y.s;\n\n // Either NaN?\n if (!a || !b) return new BigNumber(NaN);\n\n // Signs differ?\n if (a != b) {\n y.s = -b;\n return x.plus(y);\n }\n var xe = x.e / LOG_BASE,\n ye = y.e / LOG_BASE,\n xc = x.c,\n yc = y.c;\n if (!xe || !ye) {\n // Either Infinity?\n if (!xc || !yc) return xc ? (y.s = -b, y) : new BigNumber(yc ? x : NaN);\n\n // Either zero?\n if (!xc[0] || !yc[0]) {\n // Return y if y is non-zero, x if x is non-zero, or zero if both are zero.\n return yc[0] ? (y.s = -b, y) : new BigNumber(xc[0] ? x :\n // IEEE 754 (2008) 6.3: n - n = -0 when rounding to -Infinity\n ROUNDING_MODE == 3 ? -0 : 0);\n }\n }\n xe = bitFloor(xe);\n ye = bitFloor(ye);\n xc = xc.slice();\n\n // Determine which is the bigger number.\n if (a = xe - ye) {\n if (xLTy = a < 0) {\n a = -a;\n t = xc;\n } else {\n ye = xe;\n t = yc;\n }\n t.reverse();\n\n // Prepend zeros to equalise exponents.\n for (b = a; b--; t.push(0));\n t.reverse();\n } else {\n // Exponents equal. Check digit by digit.\n j = (xLTy = (a = xc.length) < (b = yc.length)) ? a : b;\n for (a = b = 0; b < j; b++) {\n if (xc[b] != yc[b]) {\n xLTy = xc[b] < yc[b];\n break;\n }\n }\n }\n\n // x < y? Point xc to the array of the bigger number.\n if (xLTy) {\n t = xc;\n xc = yc;\n yc = t;\n y.s = -y.s;\n }\n b = (j = yc.length) - (i = xc.length);\n\n // Append zeros to xc if shorter.\n // No need to add zeros to yc if shorter as subtract only needs to start at yc.length.\n if (b > 0) for (; b--; xc[i++] = 0);\n b = BASE - 1;\n\n // Subtract yc from xc.\n for (; j > a;) {\n if (xc[--j] < yc[j]) {\n for (i = j; i && !xc[--i]; xc[i] = b);\n --xc[i];\n xc[j] += BASE;\n }\n xc[j] -= yc[j];\n }\n\n // Remove leading zeros and adjust exponent accordingly.\n for (; xc[0] == 0; xc.splice(0, 1), --ye);\n\n // Zero?\n if (!xc[0]) {\n // Following IEEE 754 (2008) 6.3,\n // n - n = +0 but n - n = -0 when rounding towards -Infinity.\n y.s = ROUNDING_MODE == 3 ? -1 : 1;\n y.c = [y.e = 0];\n return y;\n }\n\n // No need to check for Infinity as +x - +y != Infinity && -x - -y != Infinity\n // for finite x and y.\n return normalise(y, xc, ye);\n };\n\n /*\r\n * n % 0 = N\r\n * n % N = N\r\n * n % I = n\r\n * 0 % n = 0\r\n * -0 % n = -0\r\n * 0 % 0 = N\r\n * 0 % N = N\r\n * 0 % I = 0\r\n * N % n = N\r\n * N % 0 = N\r\n * N % N = N\r\n * N % I = N\r\n * I % n = N\r\n * I % 0 = N\r\n * I % N = N\r\n * I % I = N\r\n *\r\n * Return a new BigNumber whose value is the value of this BigNumber modulo the value of\r\n * BigNumber(y, b). The result depends on the value of MODULO_MODE.\r\n */\n P.modulo = P.mod = function (y, b) {\n var q,\n s,\n x = this;\n y = new BigNumber(y, b);\n\n // Return NaN if x is Infinity or NaN, or y is NaN or zero.\n if (!x.c || !y.s || y.c && !y.c[0]) {\n return new BigNumber(NaN);\n\n // Return x if y is Infinity or x is zero.\n } else if (!y.c || x.c && !x.c[0]) {\n return new BigNumber(x);\n }\n if (MODULO_MODE == 9) {\n // Euclidian division: q = sign(y) * floor(x / abs(y))\n // r = x - qy where 0 <= r < abs(y)\n s = y.s;\n y.s = 1;\n q = div(x, y, 0, 3);\n y.s = s;\n q.s *= s;\n } else {\n q = div(x, y, 0, MODULO_MODE);\n }\n y = x.minus(q.times(y));\n\n // To match JavaScript %, ensure sign of zero is sign of dividend.\n if (!y.c[0] && MODULO_MODE == 1) y.s = x.s;\n return y;\n };\n\n /*\r\n * n * 0 = 0\r\n * n * N = N\r\n * n * I = I\r\n * 0 * n = 0\r\n * 0 * 0 = 0\r\n * 0 * N = N\r\n * 0 * I = N\r\n * N * n = N\r\n * N * 0 = N\r\n * N * N = N\r\n * N * I = N\r\n * I * n = I\r\n * I * 0 = N\r\n * I * N = N\r\n * I * I = I\r\n *\r\n * Return a new BigNumber whose value is the value of this BigNumber multiplied by the value\r\n * of BigNumber(y, b).\r\n */\n P.multipliedBy = P.times = function (y, b) {\n var c,\n e,\n i,\n j,\n k,\n m,\n xcL,\n xlo,\n xhi,\n ycL,\n ylo,\n yhi,\n zc,\n base,\n sqrtBase,\n x = this,\n xc = x.c,\n yc = (y = new BigNumber(y, b)).c;\n\n // Either NaN, ±Infinity or ±0?\n if (!xc || !yc || !xc[0] || !yc[0]) {\n // Return NaN if either is NaN, or one is 0 and the other is Infinity.\n if (!x.s || !y.s || xc && !xc[0] && !yc || yc && !yc[0] && !xc) {\n y.c = y.e = y.s = null;\n } else {\n y.s *= x.s;\n\n // Return ±Infinity if either is ±Infinity.\n if (!xc || !yc) {\n y.c = y.e = null;\n\n // Return ±0 if either is ±0.\n } else {\n y.c = [0];\n y.e = 0;\n }\n }\n return y;\n }\n e = bitFloor(x.e / LOG_BASE) + bitFloor(y.e / LOG_BASE);\n y.s *= x.s;\n xcL = xc.length;\n ycL = yc.length;\n\n // Ensure xc points to longer array and xcL to its length.\n if (xcL < ycL) {\n zc = xc;\n xc = yc;\n yc = zc;\n i = xcL;\n xcL = ycL;\n ycL = i;\n }\n\n // Initialise the result array with zeros.\n for (i = xcL + ycL, zc = []; i--; zc.push(0));\n base = BASE;\n sqrtBase = SQRT_BASE;\n for (i = ycL; --i >= 0;) {\n c = 0;\n ylo = yc[i] % sqrtBase;\n yhi = yc[i] / sqrtBase | 0;\n for (k = xcL, j = i + k; j > i;) {\n xlo = xc[--k] % sqrtBase;\n xhi = xc[k] / sqrtBase | 0;\n m = yhi * xlo + xhi * ylo;\n xlo = ylo * xlo + m % sqrtBase * sqrtBase + zc[j] + c;\n c = (xlo / base | 0) + (m / sqrtBase | 0) + yhi * xhi;\n zc[j--] = xlo % base;\n }\n zc[j] = c;\n }\n if (c) {\n ++e;\n } else {\n zc.splice(0, 1);\n }\n return normalise(y, zc, e);\n };\n\n /*\r\n * Return a new BigNumber whose value is the value of this BigNumber negated,\r\n * i.e. multiplied by -1.\r\n */\n P.negated = function () {\n var x = new BigNumber(this);\n x.s = -x.s || null;\n return x;\n };\n\n /*\r\n * n + 0 = n\r\n * n + N = N\r\n * n + I = I\r\n * 0 + n = n\r\n * 0 + 0 = 0\r\n * 0 + N = N\r\n * 0 + I = I\r\n * N + n = N\r\n * N + 0 = N\r\n * N + N = N\r\n * N + I = N\r\n * I + n = I\r\n * I + 0 = I\r\n * I + N = N\r\n * I + I = I\r\n *\r\n * Return a new BigNumber whose value is the value of this BigNumber plus the value of\r\n * BigNumber(y, b).\r\n */\n P.plus = function (y, b) {\n var t,\n x = this,\n a = x.s;\n y = new BigNumber(y, b);\n b = y.s;\n\n // Either NaN?\n if (!a || !b) return new BigNumber(NaN);\n\n // Signs differ?\n if (a != b) {\n y.s = -b;\n return x.minus(y);\n }\n var xe = x.e / LOG_BASE,\n ye = y.e / LOG_BASE,\n xc = x.c,\n yc = y.c;\n if (!xe || !ye) {\n // Return ±Infinity if either ±Infinity.\n if (!xc || !yc) return new BigNumber(a / 0);\n\n // Either zero?\n // Return y if y is non-zero, x if x is non-zero, or zero if both are zero.\n if (!xc[0] || !yc[0]) return yc[0] ? y : new BigNumber(xc[0] ? x : a * 0);\n }\n xe = bitFloor(xe);\n ye = bitFloor(ye);\n xc = xc.slice();\n\n // Prepend zeros to equalise exponents. Faster to use reverse then do unshifts.\n if (a = xe - ye) {\n if (a > 0) {\n ye = xe;\n t = yc;\n } else {\n a = -a;\n t = xc;\n }\n t.reverse();\n for (; a--; t.push(0));\n t.reverse();\n }\n a = xc.length;\n b = yc.length;\n\n // Point xc to the longer array, and b to the shorter length.\n if (a - b < 0) {\n t = yc;\n yc = xc;\n xc = t;\n b = a;\n }\n\n // Only start adding at yc.length - 1 as the further digits of xc can be ignored.\n for (a = 0; b;) {\n a = (xc[--b] = xc[b] + yc[b] + a) / BASE | 0;\n xc[b] = BASE === xc[b] ? 0 : xc[b] % BASE;\n }\n if (a) {\n xc = [a].concat(xc);\n ++ye;\n }\n\n // No need to check for zero, as +x + +y != 0 && -x + -y != 0\n // ye = MAX_EXP + 1 possible\n return normalise(y, xc, ye);\n };\n\n /*\r\n * If sd is undefined or null or true or false, return the number of significant digits of\r\n * the value of this BigNumber, or null if the value of this BigNumber is ±Infinity or NaN.\r\n * If sd is true include integer-part trailing zeros in the count.\r\n *\r\n * Otherwise, if sd is a number, return a new BigNumber whose value is the value of this\r\n * BigNumber rounded to a maximum of sd significant digits using rounding mode rm, or\r\n * ROUNDING_MODE if rm is omitted.\r\n *\r\n * sd {number|boolean} number: significant digits: integer, 1 to MAX inclusive.\r\n * boolean: whether to count integer-part trailing zeros: true or false.\r\n * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n *\r\n * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {sd|rm}'\r\n */\n P.precision = P.sd = function (sd, rm) {\n var c,\n n,\n v,\n x = this;\n if (sd != null && sd !== !!sd) {\n intCheck(sd, 1, MAX);\n if (rm == null) rm = ROUNDING_MODE;else intCheck(rm, 0, 8);\n return round(new BigNumber(x), sd, rm);\n }\n if (!(c = x.c)) return null;\n v = c.length - 1;\n n = v * LOG_BASE + 1;\n if (v = c[v]) {\n // Subtract the number of trailing zeros of the last element.\n for (; v % 10 == 0; v /= 10, n--);\n\n // Add the number of digits of the first element.\n for (v = c[0]; v >= 10; v /= 10, n++);\n }\n if (sd && x.e + 1 > n) n = x.e + 1;\n return n;\n };\n\n /*\r\n * Return a new BigNumber whose value is the value of this BigNumber shifted by k places\r\n * (powers of 10). Shift to the right if n > 0, and to the left if n < 0.\r\n *\r\n * k {number} Integer, -MAX_SAFE_INTEGER to MAX_SAFE_INTEGER inclusive.\r\n *\r\n * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {k}'\r\n */\n P.shiftedBy = function (k) {\n intCheck(k, -MAX_SAFE_INTEGER, MAX_SAFE_INTEGER);\n return this.times('1e' + k);\n };\n\n /*\r\n * sqrt(-n) = N\r\n * sqrt(N) = N\r\n * sqrt(-I) = N\r\n * sqrt(I) = I\r\n * sqrt(0) = 0\r\n * sqrt(-0) = -0\r\n *\r\n * Return a new BigNumber whose value is the square root of the value of this BigNumber,\r\n * rounded according to DECIMAL_PLACES and ROUNDING_MODE.\r\n */\n P.squareRoot = P.sqrt = function () {\n var m,\n n,\n r,\n rep,\n t,\n x = this,\n c = x.c,\n s = x.s,\n e = x.e,\n dp = DECIMAL_PLACES + 4,\n half = new BigNumber('0.5');\n\n // Negative/NaN/Infinity/zero?\n if (s !== 1 || !c || !c[0]) {\n return new BigNumber(!s || s < 0 && (!c || c[0]) ? NaN : c ? x : 1 / 0);\n }\n\n // Initial estimate.\n s = Math.sqrt(+valueOf(x));\n\n // Math.sqrt underflow/overflow?\n // Pass x to Math.sqrt as integer, then adjust the exponent of the result.\n if (s == 0 || s == 1 / 0) {\n n = coeffToString(c);\n if ((n.length + e) % 2 == 0) n += '0';\n s = Math.sqrt(+n);\n e = bitFloor((e + 1) / 2) - (e < 0 || e % 2);\n if (s == 1 / 0) {\n n = '5e' + e;\n } else {\n n = s.toExponential();\n n = n.slice(0, n.indexOf('e') + 1) + e;\n }\n r = new BigNumber(n);\n } else {\n r = new BigNumber(s + '');\n }\n\n // Check for zero.\n // r could be zero if MIN_EXP is changed after the this value was created.\n // This would cause a division by zero (x/t) and hence Infinity below, which would cause\n // coeffToString to throw.\n if (r.c[0]) {\n e = r.e;\n s = e + dp;\n if (s < 3) s = 0;\n\n // Newton-Raphson iteration.\n for (;;) {\n t = r;\n r = half.times(t.plus(div(x, t, dp, 1)));\n if (coeffToString(t.c).slice(0, s) === (n = coeffToString(r.c)).slice(0, s)) {\n // The exponent of r may here be one less than the final result exponent,\n // e.g 0.0009999 (e-4) --> 0.001 (e-3), so adjust s so the rounding digits\n // are indexed correctly.\n if (r.e < e) --s;\n n = n.slice(s - 3, s + 1);\n\n // The 4th rounding digit may be in error by -1 so if the 4 rounding digits\n // are 9999 or 4999 (i.e. approaching a rounding boundary) continue the\n // iteration.\n if (n == '9999' || !rep && n == '4999') {\n // On the first iteration only, check to see if rounding up gives the\n // exact result as the nines may infinitely repeat.\n if (!rep) {\n round(t, t.e + DECIMAL_PLACES + 2, 0);\n if (t.times(t).eq(x)) {\n r = t;\n break;\n }\n }\n dp += 4;\n s += 4;\n rep = 1;\n } else {\n // If rounding digits are null, 0{0,4} or 50{0,3}, check for exact\n // result. If not, then there are further digits and m will be truthy.\n if (!+n || !+n.slice(1) && n.charAt(0) == '5') {\n // Truncate to the first rounding digit.\n round(r, r.e + DECIMAL_PLACES + 2, 1);\n m = !r.times(r).eq(x);\n }\n break;\n }\n }\n }\n }\n return round(r, r.e + DECIMAL_PLACES + 1, ROUNDING_MODE, m);\n };\n\n /*\r\n * Return a string representing the value of this BigNumber in exponential notation and\r\n * rounded using ROUNDING_MODE to dp fixed decimal places.\r\n *\r\n * [dp] {number} Decimal places. Integer, 0 to MAX inclusive.\r\n * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n *\r\n * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {dp|rm}'\r\n */\n P.toExponential = function (dp, rm) {\n if (dp != null) {\n intCheck(dp, 0, MAX);\n dp++;\n }\n return format(this, dp, rm, 1);\n };\n\n /*\r\n * Return a string representing the value of this BigNumber in fixed-point notation rounding\r\n * to dp fixed decimal places using rounding mode rm, or ROUNDING_MODE if rm is omitted.\r\n *\r\n * Note: as with JavaScript's number type, (-0).toFixed(0) is '0',\r\n * but e.g. (-0.00001).toFixed(0) is '-0'.\r\n *\r\n * [dp] {number} Decimal places. Integer, 0 to MAX inclusive.\r\n * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n *\r\n * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {dp|rm}'\r\n */\n P.toFixed = function (dp, rm) {\n if (dp != null) {\n intCheck(dp, 0, MAX);\n dp = dp + this.e + 1;\n }\n return format(this, dp, rm);\n };\n\n /*\r\n * Return a string representing the value of this BigNumber in fixed-point notation rounded\r\n * using rm or ROUNDING_MODE to dp decimal places, and formatted according to the properties\r\n * of the format or FORMAT object (see BigNumber.set).\r\n *\r\n * The formatting object may contain some or all of the properties shown below.\r\n *\r\n * FORMAT = {\r\n * prefix: '',\r\n * groupSize: 3,\r\n * secondaryGroupSize: 0,\r\n * groupSeparator: ',',\r\n * decimalSeparator: '.',\r\n * fractionGroupSize: 0,\r\n * fractionGroupSeparator: '\\xA0', // non-breaking space\r\n * suffix: ''\r\n * };\r\n *\r\n * [dp] {number} Decimal places. Integer, 0 to MAX inclusive.\r\n * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n * [format] {object} Formatting options. See FORMAT pbject above.\r\n *\r\n * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {dp|rm}'\r\n * '[BigNumber Error] Argument not an object: {format}'\r\n */\n P.toFormat = function (dp, rm, format) {\n var str,\n x = this;\n if (format == null) {\n if (dp != null && rm && typeof rm == 'object') {\n format = rm;\n rm = null;\n } else if (dp && typeof dp == 'object') {\n format = dp;\n dp = rm = null;\n } else {\n format = FORMAT;\n }\n } else if (typeof format != 'object') {\n throw Error(bignumberError + 'Argument not an object: ' + format);\n }\n str = x.toFixed(dp, rm);\n if (x.c) {\n var i,\n arr = str.split('.'),\n g1 = +format.groupSize,\n g2 = +format.secondaryGroupSize,\n groupSeparator = format.groupSeparator || '',\n intPart = arr[0],\n fractionPart = arr[1],\n isNeg = x.s < 0,\n intDigits = isNeg ? intPart.slice(1) : intPart,\n len = intDigits.length;\n if (g2) {\n i = g1;\n g1 = g2;\n g2 = i;\n len -= i;\n }\n if (g1 > 0 && len > 0) {\n i = len % g1 || g1;\n intPart = intDigits.substr(0, i);\n for (; i < len; i += g1) intPart += groupSeparator + intDigits.substr(i, g1);\n if (g2 > 0) intPart += groupSeparator + intDigits.slice(i);\n if (isNeg) intPart = '-' + intPart;\n }\n str = fractionPart ? intPart + (format.decimalSeparator || '') + ((g2 = +format.fractionGroupSize) ? fractionPart.replace(new RegExp('\\\\d{' + g2 + '}\\\\B', 'g'), '$&' + (format.fractionGroupSeparator || '')) : fractionPart) : intPart;\n }\n return (format.prefix || '') + str + (format.suffix || '');\n };\n\n /*\r\n * Return an array of two BigNumbers representing the value of this BigNumber as a simple\r\n * fraction with an integer numerator and an integer denominator.\r\n * The denominator will be a positive non-zero value less than or equal to the specified\r\n * maximum denominator. If a maximum denominator is not specified, the denominator will be\r\n * the lowest value necessary to represent the number exactly.\r\n *\r\n * [md] {number|string|BigNumber} Integer >= 1, or Infinity. The maximum denominator.\r\n *\r\n * '[BigNumber Error] Argument {not an integer|out of range} : {md}'\r\n */\n P.toFraction = function (md) {\n var d,\n d0,\n d1,\n d2,\n e,\n exp,\n n,\n n0,\n n1,\n q,\n r,\n s,\n x = this,\n xc = x.c;\n if (md != null) {\n n = new BigNumber(md);\n\n // Throw if md is less than one or is not an integer, unless it is Infinity.\n if (!n.isInteger() && (n.c || n.s !== 1) || n.lt(ONE)) {\n throw Error(bignumberError + 'Argument ' + (n.isInteger() ? 'out of range: ' : 'not an integer: ') + valueOf(n));\n }\n }\n if (!xc) return new BigNumber(x);\n d = new BigNumber(ONE);\n n1 = d0 = new BigNumber(ONE);\n d1 = n0 = new BigNumber(ONE);\n s = coeffToString(xc);\n\n // Determine initial denominator.\n // d is a power of 10 and the minimum max denominator that specifies the value exactly.\n e = d.e = s.length - x.e - 1;\n d.c[0] = POWS_TEN[(exp = e % LOG_BASE) < 0 ? LOG_BASE + exp : exp];\n md = !md || n.comparedTo(d) > 0 ? e > 0 ? d : n1 : n;\n exp = MAX_EXP;\n MAX_EXP = 1 / 0;\n n = new BigNumber(s);\n\n // n0 = d1 = 0\n n0.c[0] = 0;\n for (;;) {\n q = div(n, d, 0, 1);\n d2 = d0.plus(q.times(d1));\n if (d2.comparedTo(md) == 1) break;\n d0 = d1;\n d1 = d2;\n n1 = n0.plus(q.times(d2 = n1));\n n0 = d2;\n d = n.minus(q.times(d2 = d));\n n = d2;\n }\n d2 = div(md.minus(d0), d1, 0, 1);\n n0 = n0.plus(d2.times(n1));\n d0 = d0.plus(d2.times(d1));\n n0.s = n1.s = x.s;\n e = e * 2;\n\n // Determine which fraction is closer to x, n0/d0 or n1/d1\n r = div(n1, d1, e, ROUNDING_MODE).minus(x).abs().comparedTo(div(n0, d0, e, ROUNDING_MODE).minus(x).abs()) < 1 ? [n1, d1] : [n0, d0];\n MAX_EXP = exp;\n return r;\n };\n\n /*\r\n * Return the value of this BigNumber converted to a number primitive.\r\n */\n P.toNumber = function () {\n return +valueOf(this);\n };\n\n /*\r\n * Return a string representing the value of this BigNumber rounded to sd significant digits\r\n * using rounding mode rm or ROUNDING_MODE. If sd is less than the number of digits\r\n * necessary to represent the integer part of the value in fixed-point notation, then use\r\n * exponential notation.\r\n *\r\n * [sd] {number} Significant digits. Integer, 1 to MAX inclusive.\r\n * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n *\r\n * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {sd|rm}'\r\n */\n P.toPrecision = function (sd, rm) {\n if (sd != null) intCheck(sd, 1, MAX);\n return format(this, sd, rm, 2);\n };\n\n /*\r\n * Return a string representing the value of this BigNumber in base b, or base 10 if b is\r\n * omitted. If a base is specified, including base 10, round according to DECIMAL_PLACES and\r\n * ROUNDING_MODE. If a base is not specified, and this BigNumber has a positive exponent\r\n * that is equal to or greater than TO_EXP_POS, or a negative exponent equal to or less than\r\n * TO_EXP_NEG, return exponential notation.\r\n *\r\n * [b] {number} Integer, 2 to ALPHABET.length inclusive.\r\n *\r\n * '[BigNumber Error] Base {not a primitive number|not an integer|out of range}: {b}'\r\n */\n P.toString = function (b) {\n var str,\n n = this,\n s = n.s,\n e = n.e;\n\n // Infinity or NaN?\n if (e === null) {\n if (s) {\n str = 'Infinity';\n if (s < 0) str = '-' + str;\n } else {\n str = 'NaN';\n }\n } else {\n if (b == null) {\n str = e <= TO_EXP_NEG || e >= TO_EXP_POS ? toExponential(coeffToString(n.c), e) : toFixedPoint(coeffToString(n.c), e, '0');\n } else if (b === 10 && alphabetHasNormalDecimalDigits) {\n n = round(new BigNumber(n), DECIMAL_PLACES + e + 1, ROUNDING_MODE);\n str = toFixedPoint(coeffToString(n.c), n.e, '0');\n } else {\n intCheck(b, 2, ALPHABET.length, 'Base');\n str = convertBase(toFixedPoint(coeffToString(n.c), e, '0'), 10, b, s, true);\n }\n if (s < 0 && n.c[0]) str = '-' + str;\n }\n return str;\n };\n\n /*\r\n * Return as toString, but do not accept a base argument, and include the minus sign for\r\n * negative zero.\r\n */\n P.valueOf = P.toJSON = function () {\n return valueOf(this);\n };\n P._isBigNumber = true;\n P[Symbol.toStringTag] = 'BigNumber';\n\n // Node.js v10.12.0+\n P[Symbol.for('nodejs.util.inspect.custom')] = P.valueOf;\n if (configObject != null) BigNumber.set(configObject);\n return BigNumber;\n}\n\n// PRIVATE HELPER FUNCTIONS\n\n// These functions don't need access to variables,\n// e.g. DECIMAL_PLACES, in the scope of the `clone` function above.\n\nfunction bitFloor(n) {\n var i = n | 0;\n return n > 0 || n === i ? i : i - 1;\n}\n\n// Return a coefficient array as a string of base 10 digits.\nfunction coeffToString(a) {\n var s,\n z,\n i = 1,\n j = a.length,\n r = a[0] + '';\n for (; i < j;) {\n s = a[i++] + '';\n z = LOG_BASE - s.length;\n for (; z--; s = '0' + s);\n r += s;\n }\n\n // Determine trailing zeros.\n for (j = r.length; r.charCodeAt(--j) === 48;);\n return r.slice(0, j + 1 || 1);\n}\n\n// Compare the value of BigNumbers x and y.\nfunction compare(x, y) {\n var a,\n b,\n xc = x.c,\n yc = y.c,\n i = x.s,\n j = y.s,\n k = x.e,\n l = y.e;\n\n // Either NaN?\n if (!i || !j) return null;\n a = xc && !xc[0];\n b = yc && !yc[0];\n\n // Either zero?\n if (a || b) return a ? b ? 0 : -j : i;\n\n // Signs differ?\n if (i != j) return i;\n a = i < 0;\n b = k == l;\n\n // Either Infinity?\n if (!xc || !yc) return b ? 0 : !xc ^ a ? 1 : -1;\n\n // Compare exponents.\n if (!b) return k > l ^ a ? 1 : -1;\n j = (k = xc.length) < (l = yc.length) ? k : l;\n\n // Compare digit by digit.\n for (i = 0; i < j; i++) if (xc[i] != yc[i]) return xc[i] > yc[i] ^ a ? 1 : -1;\n\n // Compare lengths.\n return k == l ? 0 : k > l ^ a ? 1 : -1;\n}\n\n/*\r\n * Check that n is a primitive number, an integer, and in range, otherwise throw.\r\n */\nfunction intCheck(n, min, max, name) {\n if (n < min || n > max || n !== mathfloor(n)) {\n throw Error(bignumberError + (name || 'Argument') + (typeof n == 'number' ? n < min || n > max ? ' out of range: ' : ' not an integer: ' : ' not a primitive number: ') + String(n));\n }\n}\n\n// Assumes finite n.\nfunction isOdd(n) {\n var k = n.c.length - 1;\n return bitFloor(n.e / LOG_BASE) == k && n.c[k] % 2 != 0;\n}\nfunction toExponential(str, e) {\n return (str.length > 1 ? str.charAt(0) + '.' + str.slice(1) : str) + (e < 0 ? 'e' : 'e+') + e;\n}\nfunction toFixedPoint(str, e, z) {\n var len, zs;\n\n // Negative exponent?\n if (e < 0) {\n // Prepend zeros.\n for (zs = z + '.'; ++e; zs += z);\n str = zs + str;\n\n // Positive exponent\n } else {\n len = str.length;\n\n // Append zeros.\n if (++e > len) {\n for (zs = z, e -= len; --e; zs += z);\n str += zs;\n } else if (e < len) {\n str = str.slice(0, e) + '.' + str.slice(e);\n }\n }\n return str;\n}\n\n// EXPORT\n\nexport var BigNumber = clone();\nexport default BigNumber;"],"names":["isNumeric","mathceil","mathfloor","bignumberError","tooManyDigits","BASE","LOG_BASE","MAX_SAFE_INTEGER","POWS_TEN","SQRT_BASE","MAX","clone","configObject","div","convertBase","parseNumeric","P","BigNumber","ONE","DECIMAL_PLACES","ROUNDING_MODE","TO_EXP_NEG","TO_EXP_POS","MIN_EXP","MAX_EXP","CRYPTO","MODULO_MODE","POW_PRECISION","FORMAT","ALPHABET","alphabetHasNormalDecimalDigits","v","b","alphabet","c","caseChanged","e","i","isNum","len","str","x","intCheck","round","obj","p","n","s","out","maxOrMin","pow2_53","random53bitInt","dp","a","k","rand","args","sum","decimal","toBaseOut","baseIn","baseOut","j","arr","arrL","sign","callerIsToString","d","r","xc","y","rm","toFixedPoint","coeffToString","multiply","base","m","temp","xlo","xhi","carry","klo","khi","compare","aL","bL","cmp","subtract","more","prod","prodL","q","qc","rem","remL","rem0","xi","xL","yc0","yL","yz","yc","bitFloor","format","id","c0","ne","toExponential","normalise","basePrefix","dotAfter","dotBefore","isInfinityOrNaN","whitespaceOrPlus","p1","p2","sd","ni","rd","pows10","valueOf","half","isModExp","nIsBig","nIsNeg","nIsOdd","isOdd","xLTy","xe","ye","xcL","ycL","ylo","yhi","zc","sqrtBase","t","rep","g1","g2","groupSeparator","intPart","fractionPart","isNeg","intDigits","md","d0","d1","d2","exp","n0","n1","z","l","min","max","name","zs","bignumber_default"],"mappings":"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","debug_id":"bec53983-411a-5ade-976b-be47c0cd6216"}