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