{"version":3,"sources":["webpack:///./node_modules/core-js/internals/object-get-own-property-names-external.js","webpack:///./node_modules/core-js/internals/string-repeat.js","webpack:///./node_modules/core-js/modules/web.dom-collections.for-each.js","webpack:///./node_modules/core-js/internals/array-for-each.js","webpack:///./node_modules/core-js/internals/this-number-value.js","webpack:///./node_modules/core-js/internals/path.js","webpack:///./node_modules/core-js/modules/es.array.filter.js","webpack:///./node_modules/@babel/runtime/helpers/esm/defineProperty.js","webpack:///./node_modules/@babel/runtime/helpers/esm/objectSpread2.js","webpack:///./node_modules/core-js/internals/define-well-known-symbol.js","webpack:///./node_modules/bignumber.js/bignumber.js","webpack:///./node_modules/core-js/modules/es.symbol.js","webpack:///./src/format/index.js","webpack:///./node_modules/core-js/internals/array-method-is-strict.js","webpack:///./node_modules/core-js/modules/es.object.keys.js","webpack:///./node_modules/core-js/modules/es.number.to-fixed.js","webpack:///./node_modules/core-js/internals/array-iteration.js","webpack:///./node_modules/core-js/modules/es.object.get-own-property-descriptors.js","webpack:///./node_modules/core-js/modules/es.object.get-own-property-descriptor.js","webpack:///./node_modules/core-js/internals/well-known-symbol-wrapped.js"],"names":["toIndexedObject","$getOwnPropertyNames","f","toString","windowNames","window","Object","getOwnPropertyNames","getWindowNames","it","error","slice","module","exports","call","toIntegerOrInfinity","requireObjectCoercible","count","str","this","result","n","Infinity","RangeError","global","DOMIterables","DOMTokenListPrototype","forEach","createNonEnumerableProperty","handlePrototype","CollectionPrototype","COLLECTION_NAME","prototype","$forEach","arrayMethodIsStrict","STRICT_METHOD","callbackfn","arguments","length","undefined","valueOf","value","$","$filter","filter","arrayMethodHasSpeciesSupport","HAS_SPECIES_SUPPORT","target","proto","forced","_defineProperty","obj","key","defineProperty","enumerable","configurable","writable","ownKeys","object","enumerableOnly","keys","getOwnPropertySymbols","symbols","sym","getOwnPropertyDescriptor","push","apply","_objectSpread2","i","source","getOwnPropertyDescriptors","defineProperties","path","hasOwn","wrappedWellKnownSymbolModule","NAME","Symbol","globalObject","BigNumber","isNumeric","mathceil","Math","ceil","mathfloor","floor","bignumberError","tooManyDigits","BASE","LOG_BASE","MAX_SAFE_INTEGER","POWS_TEN","SQRT_BASE","MAX","clone","configObject","div","convertBase","parseNumeric","P","constructor","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","v","b","alphabet","c","caseChanged","e","isNum","len","x","_isBigNumber","s","String","test","charCodeAt","indexOf","replace","search","substring","intCheck","round","DEBUG","Error","charAt","toUpperCase","toLowerCase","format","rm","id","c0","ne","coeffToString","toExponential","toFixedPoint","maxOrMin","args","method","m","normalise","j","pop","sd","r","d","k","ni","rd","xc","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","p","hasOwnProperty","crypto","getRandomValues","randomBytes","EXPONENTIAL_AT","RANGE","isBigNumber","maximum","max","lt","minimum","min","gt","random","pow2_53","random53bitInt","dp","a","rand","Uint32Array","copy","splice","sum","plus","decimal","toBaseOut","baseIn","baseOut","arrL","arr","reverse","sign","callerIsToString","y","pow","concat","multiply","base","temp","xlo","xhi","carry","klo","khi","compare","aL","bL","cmp","subtract","more","prod","prodL","q","qc","rem","remL","rem0","xi","xL","yc0","yL","yz","yc","NaN","bitFloor","basePrefix","dotAfter","dotBefore","isInfinityOrNaN","whitespaceOrPlus","isNaN","p1","p2","absoluteValue","abs","comparedTo","decimalPlaces","dividedBy","dividedToIntegerBy","idiv","exponentiatedBy","half","isModExp","nIsBig","nIsNeg","nIsOdd","isInteger","isOdd","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","z","l","name","zs","getBuiltIn","IS_PURE","DESCRIPTORS","NATIVE_SYMBOL","fails","isArray","isCallable","isObject","isSymbol","anObject","toObject","toPropertyKey","$toString","createPropertyDescriptor","nativeObjectCreate","objectKeys","getOwnPropertyNamesModule","getOwnPropertyNamesExternal","getOwnPropertySymbolsModule","getOwnPropertyDescriptorModule","definePropertyModule","propertyIsEnumerableModule","redefine","shared","sharedKey","hiddenKeys","uid","wellKnownSymbol","defineWellKnownSymbol","setToStringTag","InternalStateModule","HIDDEN","SYMBOL","PROTOTYPE","TO_PRIMITIVE","setInternalState","getInternalState","getterFor","ObjectPrototype","$Symbol","$stringify","nativeGetOwnPropertyDescriptor","nativeDefineProperty","nativeGetOwnPropertyNames","nativePropertyIsEnumerable","AllSymbols","ObjectPrototypeSymbols","StringToSymbolRegistry","SymbolToStringRegistry","WellKnownSymbolsStore","QObject","USE_SETTER","findChild","setSymbolDescriptor","get","O","Attributes","ObjectPrototypeDescriptor","wrap","tag","description","symbol","type","$defineProperty","$defineProperties","Properties","properties","$getOwnPropertySymbols","$propertyIsEnumerable","$create","V","$getOwnPropertyDescriptor","descriptor","names","IS_OBJECT_PROTOTYPE","TypeError","setter","unsafe","sham","stat","string","keyFor","useSetter","useSimple","create","FORCED_JSON_STRINGIFY","stringify","replacer","space","$replacer","index","symbolStyle","Intl","NumberFormat","style","currency","currencyDisplay","ex","formatSiacoinString","formatted","signDisplay","minimumFractionDigits","maximumFractionDigits","formatCurrencyString","rate","code","maxDigits","formatExchangeRate","METHOD_NAME","argument","nativeKeys","FAILS_ON_PRIMITIVES","thisNumberValue","repeat","nativeToFixed","acc","log","x2","data","c2","divide","dataToString","FORCED","fractionDigits","number","fractDigits","bind","IndexedObject","lengthOfArrayLike","arraySpeciesCreate","createMethod","TYPE","IS_MAP","IS_FILTER","IS_SOME","IS_EVERY","IS_FIND_INDEX","IS_FILTER_REJECT","NO_HOLES","$this","that","specificCreate","self","boundFunction","map","some","every","find","findIndex","filterReject","createProperty"],"mappings":"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","file":"js/transaction~wallet.b17b00f7.js","sourcesContent":["/* eslint-disable es/no-object-getownpropertynames -- safe */\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar $getOwnPropertyNames = require('../internals/object-get-own-property-names').f;\n\nvar toString = {}.toString;\n\nvar windowNames = typeof window == 'object' && window && Object.getOwnPropertyNames\n  ? Object.getOwnPropertyNames(window) : [];\n\nvar getWindowNames = function (it) {\n  try {\n    return $getOwnPropertyNames(it);\n  } catch (error) {\n    return windowNames.slice();\n  }\n};\n\n// fallback for IE11 buggy Object.getOwnPropertyNames with iframe and window\nmodule.exports.f = function getOwnPropertyNames(it) {\n  return windowNames && toString.call(it) == '[object Window]'\n    ? getWindowNames(it)\n    : $getOwnPropertyNames(toIndexedObject(it));\n};\n","'use strict';\nvar toIntegerOrInfinity = require('../internals/to-integer-or-infinity');\nvar toString = require('../internals/to-string');\nvar requireObjectCoercible = require('../internals/require-object-coercible');\n\n// `String.prototype.repeat` method implementation\n// https://tc39.es/ecma262/#sec-string.prototype.repeat\nmodule.exports = function repeat(count) {\n  var str = toString(requireObjectCoercible(this));\n  var result = '';\n  var n = toIntegerOrInfinity(count);\n  if (n < 0 || n == Infinity) throw RangeError('Wrong number of repetitions');\n  for (;n > 0; (n >>>= 1) && (str += str)) if (n & 1) result += str;\n  return result;\n};\n","var global = require('../internals/global');\nvar DOMIterables = require('../internals/dom-iterables');\nvar DOMTokenListPrototype = require('../internals/dom-token-list-prototype');\nvar forEach = require('../internals/array-for-each');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\n\nvar handlePrototype = function (CollectionPrototype) {\n  // some Chrome versions have non-configurable methods on DOMTokenList\n  if (CollectionPrototype && CollectionPrototype.forEach !== forEach) try {\n    createNonEnumerableProperty(CollectionPrototype, 'forEach', forEach);\n  } catch (error) {\n    CollectionPrototype.forEach = forEach;\n  }\n};\n\nfor (var COLLECTION_NAME in DOMIterables) {\n  if (DOMIterables[COLLECTION_NAME]) {\n    handlePrototype(global[COLLECTION_NAME] && global[COLLECTION_NAME].prototype);\n  }\n}\n\nhandlePrototype(DOMTokenListPrototype);\n","'use strict';\nvar $forEach = require('../internals/array-iteration').forEach;\nvar arrayMethodIsStrict = require('../internals/array-method-is-strict');\n\nvar STRICT_METHOD = arrayMethodIsStrict('forEach');\n\n// `Array.prototype.forEach` method implementation\n// https://tc39.es/ecma262/#sec-array.prototype.foreach\nmodule.exports = !STRICT_METHOD ? function forEach(callbackfn /* , thisArg */) {\n  return $forEach(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined);\n// eslint-disable-next-line es/no-array-prototype-foreach -- safe\n} : [].forEach;\n","var valueOf = 1.0.valueOf;\n\n// `thisNumberValue` abstract operation\n// https://tc39.es/ecma262/#sec-thisnumbervalue\nmodule.exports = function (value) {\n  return valueOf.call(value);\n};\n","var global = require('../internals/global');\n\nmodule.exports = global;\n","'use strict';\nvar $ = require('../internals/export');\nvar $filter = require('../internals/array-iteration').filter;\nvar arrayMethodHasSpeciesSupport = require('../internals/array-method-has-species-support');\n\nvar HAS_SPECIES_SUPPORT = arrayMethodHasSpeciesSupport('filter');\n\n// `Array.prototype.filter` method\n// https://tc39.es/ecma262/#sec-array.prototype.filter\n// with adding support of @@species\n$({ target: 'Array', proto: true, forced: !HAS_SPECIES_SUPPORT }, {\n  filter: function filter(callbackfn /* , thisArg */) {\n    return $filter(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined);\n  }\n});\n","export default function _defineProperty(obj, key, value) {\n  if (key in obj) {\n    Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: true,\n      configurable: true,\n      writable: true\n    });\n  } else {\n    obj[key] = value;\n  }\n\n  return obj;\n}","import defineProperty from \"./defineProperty.js\";\n\nfunction ownKeys(object, enumerableOnly) {\n  var keys = Object.keys(object);\n\n  if (Object.getOwnPropertySymbols) {\n    var symbols = Object.getOwnPropertySymbols(object);\n\n    if (enumerableOnly) {\n      symbols = symbols.filter(function (sym) {\n        return Object.getOwnPropertyDescriptor(object, sym).enumerable;\n      });\n    }\n\n    keys.push.apply(keys, symbols);\n  }\n\n  return keys;\n}\n\nexport default function _objectSpread2(target) {\n  for (var i = 1; i < arguments.length; i++) {\n    var source = arguments[i] != null ? arguments[i] : {};\n\n    if (i % 2) {\n      ownKeys(Object(source), true).forEach(function (key) {\n        defineProperty(target, key, source[key]);\n      });\n    } else if (Object.getOwnPropertyDescriptors) {\n      Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));\n    } else {\n      ownKeys(Object(source)).forEach(function (key) {\n        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));\n      });\n    }\n  }\n\n  return target;\n}","var path = require('../internals/path');\nvar hasOwn = require('../internals/has-own-property');\nvar wrappedWellKnownSymbolModule = require('../internals/well-known-symbol-wrapped');\nvar defineProperty = require('../internals/object-define-property').f;\n\nmodule.exports = function (NAME) {\n  var Symbol = path.Symbol || (path.Symbol = {});\n  if (!hasOwn(Symbol, NAME)) defineProperty(Symbol, NAME, {\n    value: wrappedWellKnownSymbolModule.f(NAME)\n  });\n};\n",";(function (globalObject) {\r\n  'use strict';\r\n\r\n/*\r\n *      bignumber.js v9.0.1\r\n *      A JavaScript library for arbitrary-precision arithmetic.\r\n *      https://github.com/MikeMcl/bignumber.js\r\n *      Copyright (c) 2020 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\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) {\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              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 ? 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) t = xc, xc = yc, yc = t, y.s = -y.s;\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) zc = xc, xc = yc, yc = zc, i = xcL, xcL = ycL, ycL = i;\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) t = yc, yc = xc, xc = t, b = a;\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) i = g1, g1 = g2, g2 = i, len -= i;\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) {\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","'use strict';\nvar $ = require('../internals/export');\nvar global = require('../internals/global');\nvar getBuiltIn = require('../internals/get-built-in');\nvar IS_PURE = require('../internals/is-pure');\nvar DESCRIPTORS = require('../internals/descriptors');\nvar NATIVE_SYMBOL = require('../internals/native-symbol');\nvar fails = require('../internals/fails');\nvar hasOwn = require('../internals/has-own-property');\nvar isArray = require('../internals/is-array');\nvar isCallable = require('../internals/is-callable');\nvar isObject = require('../internals/is-object');\nvar isSymbol = require('../internals/is-symbol');\nvar anObject = require('../internals/an-object');\nvar toObject = require('../internals/to-object');\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar toPropertyKey = require('../internals/to-property-key');\nvar $toString = require('../internals/to-string');\nvar createPropertyDescriptor = require('../internals/create-property-descriptor');\nvar nativeObjectCreate = require('../internals/object-create');\nvar objectKeys = require('../internals/object-keys');\nvar getOwnPropertyNamesModule = require('../internals/object-get-own-property-names');\nvar getOwnPropertyNamesExternal = require('../internals/object-get-own-property-names-external');\nvar getOwnPropertySymbolsModule = require('../internals/object-get-own-property-symbols');\nvar getOwnPropertyDescriptorModule = require('../internals/object-get-own-property-descriptor');\nvar definePropertyModule = require('../internals/object-define-property');\nvar propertyIsEnumerableModule = require('../internals/object-property-is-enumerable');\nvar redefine = require('../internals/redefine');\nvar shared = require('../internals/shared');\nvar sharedKey = require('../internals/shared-key');\nvar hiddenKeys = require('../internals/hidden-keys');\nvar uid = require('../internals/uid');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar wrappedWellKnownSymbolModule = require('../internals/well-known-symbol-wrapped');\nvar defineWellKnownSymbol = require('../internals/define-well-known-symbol');\nvar setToStringTag = require('../internals/set-to-string-tag');\nvar InternalStateModule = require('../internals/internal-state');\nvar $forEach = require('../internals/array-iteration').forEach;\n\nvar HIDDEN = sharedKey('hidden');\nvar SYMBOL = 'Symbol';\nvar PROTOTYPE = 'prototype';\nvar TO_PRIMITIVE = wellKnownSymbol('toPrimitive');\nvar setInternalState = InternalStateModule.set;\nvar getInternalState = InternalStateModule.getterFor(SYMBOL);\nvar ObjectPrototype = Object[PROTOTYPE];\nvar $Symbol = global.Symbol;\nvar $stringify = getBuiltIn('JSON', 'stringify');\nvar nativeGetOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f;\nvar nativeDefineProperty = definePropertyModule.f;\nvar nativeGetOwnPropertyNames = getOwnPropertyNamesExternal.f;\nvar nativePropertyIsEnumerable = propertyIsEnumerableModule.f;\nvar AllSymbols = shared('symbols');\nvar ObjectPrototypeSymbols = shared('op-symbols');\nvar StringToSymbolRegistry = shared('string-to-symbol-registry');\nvar SymbolToStringRegistry = shared('symbol-to-string-registry');\nvar WellKnownSymbolsStore = shared('wks');\nvar QObject = global.QObject;\n// Don't use setters in Qt Script, https://github.com/zloirock/core-js/issues/173\nvar USE_SETTER = !QObject || !QObject[PROTOTYPE] || !QObject[PROTOTYPE].findChild;\n\n// fallback for old Android, https://code.google.com/p/v8/issues/detail?id=687\nvar setSymbolDescriptor = DESCRIPTORS && fails(function () {\n  return nativeObjectCreate(nativeDefineProperty({}, 'a', {\n    get: function () { return nativeDefineProperty(this, 'a', { value: 7 }).a; }\n  })).a != 7;\n}) ? function (O, P, Attributes) {\n  var ObjectPrototypeDescriptor = nativeGetOwnPropertyDescriptor(ObjectPrototype, P);\n  if (ObjectPrototypeDescriptor) delete ObjectPrototype[P];\n  nativeDefineProperty(O, P, Attributes);\n  if (ObjectPrototypeDescriptor && O !== ObjectPrototype) {\n    nativeDefineProperty(ObjectPrototype, P, ObjectPrototypeDescriptor);\n  }\n} : nativeDefineProperty;\n\nvar wrap = function (tag, description) {\n  var symbol = AllSymbols[tag] = nativeObjectCreate($Symbol[PROTOTYPE]);\n  setInternalState(symbol, {\n    type: SYMBOL,\n    tag: tag,\n    description: description\n  });\n  if (!DESCRIPTORS) symbol.description = description;\n  return symbol;\n};\n\nvar $defineProperty = function defineProperty(O, P, Attributes) {\n  if (O === ObjectPrototype) $defineProperty(ObjectPrototypeSymbols, P, Attributes);\n  anObject(O);\n  var key = toPropertyKey(P);\n  anObject(Attributes);\n  if (hasOwn(AllSymbols, key)) {\n    if (!Attributes.enumerable) {\n      if (!hasOwn(O, HIDDEN)) nativeDefineProperty(O, HIDDEN, createPropertyDescriptor(1, {}));\n      O[HIDDEN][key] = true;\n    } else {\n      if (hasOwn(O, HIDDEN) && O[HIDDEN][key]) O[HIDDEN][key] = false;\n      Attributes = nativeObjectCreate(Attributes, { enumerable: createPropertyDescriptor(0, false) });\n    } return setSymbolDescriptor(O, key, Attributes);\n  } return nativeDefineProperty(O, key, Attributes);\n};\n\nvar $defineProperties = function defineProperties(O, Properties) {\n  anObject(O);\n  var properties = toIndexedObject(Properties);\n  var keys = objectKeys(properties).concat($getOwnPropertySymbols(properties));\n  $forEach(keys, function (key) {\n    if (!DESCRIPTORS || $propertyIsEnumerable.call(properties, key)) $defineProperty(O, key, properties[key]);\n  });\n  return O;\n};\n\nvar $create = function create(O, Properties) {\n  return Properties === undefined ? nativeObjectCreate(O) : $defineProperties(nativeObjectCreate(O), Properties);\n};\n\nvar $propertyIsEnumerable = function propertyIsEnumerable(V) {\n  var P = toPropertyKey(V);\n  var enumerable = nativePropertyIsEnumerable.call(this, P);\n  if (this === ObjectPrototype && hasOwn(AllSymbols, P) && !hasOwn(ObjectPrototypeSymbols, P)) return false;\n  return enumerable || !hasOwn(this, P) || !hasOwn(AllSymbols, P) || hasOwn(this, HIDDEN) && this[HIDDEN][P]\n    ? enumerable : true;\n};\n\nvar $getOwnPropertyDescriptor = function getOwnPropertyDescriptor(O, P) {\n  var it = toIndexedObject(O);\n  var key = toPropertyKey(P);\n  if (it === ObjectPrototype && hasOwn(AllSymbols, key) && !hasOwn(ObjectPrototypeSymbols, key)) return;\n  var descriptor = nativeGetOwnPropertyDescriptor(it, key);\n  if (descriptor && hasOwn(AllSymbols, key) && !(hasOwn(it, HIDDEN) && it[HIDDEN][key])) {\n    descriptor.enumerable = true;\n  }\n  return descriptor;\n};\n\nvar $getOwnPropertyNames = function getOwnPropertyNames(O) {\n  var names = nativeGetOwnPropertyNames(toIndexedObject(O));\n  var result = [];\n  $forEach(names, function (key) {\n    if (!hasOwn(AllSymbols, key) && !hasOwn(hiddenKeys, key)) result.push(key);\n  });\n  return result;\n};\n\nvar $getOwnPropertySymbols = function getOwnPropertySymbols(O) {\n  var IS_OBJECT_PROTOTYPE = O === ObjectPrototype;\n  var names = nativeGetOwnPropertyNames(IS_OBJECT_PROTOTYPE ? ObjectPrototypeSymbols : toIndexedObject(O));\n  var result = [];\n  $forEach(names, function (key) {\n    if (hasOwn(AllSymbols, key) && (!IS_OBJECT_PROTOTYPE || hasOwn(ObjectPrototype, key))) {\n      result.push(AllSymbols[key]);\n    }\n  });\n  return result;\n};\n\n// `Symbol` constructor\n// https://tc39.es/ecma262/#sec-symbol-constructor\nif (!NATIVE_SYMBOL) {\n  $Symbol = function Symbol() {\n    if (this instanceof $Symbol) throw TypeError('Symbol is not a constructor');\n    var description = !arguments.length || arguments[0] === undefined ? undefined : $toString(arguments[0]);\n    var tag = uid(description);\n    var setter = function (value) {\n      if (this === ObjectPrototype) setter.call(ObjectPrototypeSymbols, value);\n      if (hasOwn(this, HIDDEN) && hasOwn(this[HIDDEN], tag)) this[HIDDEN][tag] = false;\n      setSymbolDescriptor(this, tag, createPropertyDescriptor(1, value));\n    };\n    if (DESCRIPTORS && USE_SETTER) setSymbolDescriptor(ObjectPrototype, tag, { configurable: true, set: setter });\n    return wrap(tag, description);\n  };\n\n  redefine($Symbol[PROTOTYPE], 'toString', function toString() {\n    return getInternalState(this).tag;\n  });\n\n  redefine($Symbol, 'withoutSetter', function (description) {\n    return wrap(uid(description), description);\n  });\n\n  propertyIsEnumerableModule.f = $propertyIsEnumerable;\n  definePropertyModule.f = $defineProperty;\n  getOwnPropertyDescriptorModule.f = $getOwnPropertyDescriptor;\n  getOwnPropertyNamesModule.f = getOwnPropertyNamesExternal.f = $getOwnPropertyNames;\n  getOwnPropertySymbolsModule.f = $getOwnPropertySymbols;\n\n  wrappedWellKnownSymbolModule.f = function (name) {\n    return wrap(wellKnownSymbol(name), name);\n  };\n\n  if (DESCRIPTORS) {\n    // https://github.com/tc39/proposal-Symbol-description\n    nativeDefineProperty($Symbol[PROTOTYPE], 'description', {\n      configurable: true,\n      get: function description() {\n        return getInternalState(this).description;\n      }\n    });\n    if (!IS_PURE) {\n      redefine(ObjectPrototype, 'propertyIsEnumerable', $propertyIsEnumerable, { unsafe: true });\n    }\n  }\n}\n\n$({ global: true, wrap: true, forced: !NATIVE_SYMBOL, sham: !NATIVE_SYMBOL }, {\n  Symbol: $Symbol\n});\n\n$forEach(objectKeys(WellKnownSymbolsStore), function (name) {\n  defineWellKnownSymbol(name);\n});\n\n$({ target: SYMBOL, stat: true, forced: !NATIVE_SYMBOL }, {\n  // `Symbol.for` method\n  // https://tc39.es/ecma262/#sec-symbol.for\n  'for': function (key) {\n    var string = $toString(key);\n    if (hasOwn(StringToSymbolRegistry, string)) return StringToSymbolRegistry[string];\n    var symbol = $Symbol(string);\n    StringToSymbolRegistry[string] = symbol;\n    SymbolToStringRegistry[symbol] = string;\n    return symbol;\n  },\n  // `Symbol.keyFor` method\n  // https://tc39.es/ecma262/#sec-symbol.keyfor\n  keyFor: function keyFor(sym) {\n    if (!isSymbol(sym)) throw TypeError(sym + ' is not a symbol');\n    if (hasOwn(SymbolToStringRegistry, sym)) return SymbolToStringRegistry[sym];\n  },\n  useSetter: function () { USE_SETTER = true; },\n  useSimple: function () { USE_SETTER = false; }\n});\n\n$({ target: 'Object', stat: true, forced: !NATIVE_SYMBOL, sham: !DESCRIPTORS }, {\n  // `Object.create` method\n  // https://tc39.es/ecma262/#sec-object.create\n  create: $create,\n  // `Object.defineProperty` method\n  // https://tc39.es/ecma262/#sec-object.defineproperty\n  defineProperty: $defineProperty,\n  // `Object.defineProperties` method\n  // https://tc39.es/ecma262/#sec-object.defineproperties\n  defineProperties: $defineProperties,\n  // `Object.getOwnPropertyDescriptor` method\n  // https://tc39.es/ecma262/#sec-object.getownpropertydescriptors\n  getOwnPropertyDescriptor: $getOwnPropertyDescriptor\n});\n\n$({ target: 'Object', stat: true, forced: !NATIVE_SYMBOL }, {\n  // `Object.getOwnPropertyNames` method\n  // https://tc39.es/ecma262/#sec-object.getownpropertynames\n  getOwnPropertyNames: $getOwnPropertyNames,\n  // `Object.getOwnPropertySymbols` method\n  // https://tc39.es/ecma262/#sec-object.getownpropertysymbols\n  getOwnPropertySymbols: $getOwnPropertySymbols\n});\n\n// Chrome 38 and 39 `Object.getOwnPropertySymbols` fails on primitives\n// https://bugs.chromium.org/p/v8/issues/detail?id=3443\n$({ target: 'Object', stat: true, forced: fails(function () { getOwnPropertySymbolsModule.f(1); }) }, {\n  getOwnPropertySymbols: function getOwnPropertySymbols(it) {\n    return getOwnPropertySymbolsModule.f(toObject(it));\n  }\n});\n\n// `JSON.stringify` method behavior with symbols\n// https://tc39.es/ecma262/#sec-json.stringify\nif ($stringify) {\n  var FORCED_JSON_STRINGIFY = !NATIVE_SYMBOL || fails(function () {\n    var symbol = $Symbol();\n    // MS Edge converts symbol values to JSON as {}\n    return $stringify([symbol]) != '[null]'\n      // WebKit converts symbol values to JSON as null\n      || $stringify({ a: symbol }) != '{}'\n      // V8 throws on boxed symbols\n      || $stringify(Object(symbol)) != '{}';\n  });\n\n  $({ target: 'JSON', stat: true, forced: FORCED_JSON_STRINGIFY }, {\n    // eslint-disable-next-line no-unused-vars -- required for `.length`\n    stringify: function stringify(it, replacer, space) {\n      var args = [it];\n      var index = 1;\n      var $replacer;\n      while (arguments.length > index) args.push(arguments[index++]);\n      $replacer = replacer;\n      if (!isObject(replacer) && it === undefined || isSymbol(it)) return; // IE8 returns string on undefined\n      if (!isArray(replacer)) replacer = function (key, value) {\n        if (isCallable($replacer)) value = $replacer.call(this, key, value);\n        if (!isSymbol(value)) return value;\n      };\n      args[1] = replacer;\n      return $stringify.apply(null, args);\n    }\n  });\n}\n\n// `Symbol.prototype[@@toPrimitive]` method\n// https://tc39.es/ecma262/#sec-symbol.prototype-@@toprimitive\nif (!$Symbol[PROTOTYPE][TO_PRIMITIVE]) {\n  var valueOf = $Symbol[PROTOTYPE].valueOf;\n  redefine($Symbol[PROTOTYPE], TO_PRIMITIVE, function () {\n    return valueOf.apply(this, arguments);\n  });\n}\n// `Symbol.prototype[@@toStringTag]` property\n// https://tc39.es/ecma262/#sec-symbol.prototype-@@tostringtag\nsetToStringTag($Symbol, SYMBOL);\n\nhiddenKeys[HIDDEN] = true;\n","/**\n * Safari does not support 'narrowSymbol' and will throw an exception\n */\nconst symbolStyle = (() => {\n\ttry {\n\t\tnew Intl.NumberFormat([], {\n\t\t\tstyle: 'currency',\n\t\t\tcurrency: 'usd',\n\t\t\tcurrencyDisplay: 'narrowSymbol'\n\t\t}).format(1.512);\n\n\t\treturn 'narrowSymbol';\n\t} catch (ex) {\n\t\treturn 'symbol';\n\t}\n})();\n\nexport function formatSiacoinString(v, sign = 'always') {\n\tconst formatted = new Intl.NumberFormat([], {\n\t\tsignDisplay: sign,\n\t\tminimumFractionDigits: 2,\n\t\tmaximumFractionDigits: 4\n\t}).format(v.div('1e24').toFixed(4));\n\n\treturn `${formatted} SC`;\n}\n\nexport function formatCurrencyString(v, rate = 0.015, code = 'usd', sign = 'always', maxDigits = 4) {\n\tconst value = v.div('1e24').times(rate).toFixed(4);\n\tlet formatted;\n\n\tswitch (code) {\n\tcase 'btc':\n\t\tformatted = new Intl.NumberFormat([], {\n\t\t\tsignDisplay: sign,\n\t\t\tminimumFractionDigits: 2,\n\t\t\tmaximumFractionDigits: maxDigits\n\t\t}).format(value);\n\t\treturn `${formatted} ${code.toUpperCase()}`;\n\tdefault:\n\t\treturn new Intl.NumberFormat([], {\n\t\t\tsignDisplay: sign,\n\t\t\tstyle: 'currency',\n\t\t\tcurrency: code,\n\t\t\tcurrencyDisplay: symbolStyle,\n\t\t\tminimumFractionDigits: 2,\n\t\t\tmaximumFractionDigits: maxDigits\n\t\t}).format(value);\n\t}\n}\n\nexport function formatExchangeRate(rate, code = 'usd', sign = 'always') {\n\tswitch (code.toLowerCase()) {\n\tcase 'btc':\n\t\treturn new Intl.NumberFormat([], {\n\t\t\tsignDisplay: sign,\n\t\t\tminimumFractionDigits: 0,\n\t\t\tmaximumFractionDigits: 0\n\t\t}).format(rate * 100000000) + ' SAT';\n\tdefault:\n\t\treturn new Intl.NumberFormat([], {\n\t\t\tsignDisplay: sign,\n\t\t\tstyle: 'currency',\n\t\t\tcurrency: code,\n\t\t\tcurrencyDisplay: symbolStyle,\n\t\t\tminimumFractionDigits: 2,\n\t\t\tmaximumFractionDigits: 4\n\t\t}).format(rate);\n\t}\n}","'use strict';\nvar fails = require('../internals/fails');\n\nmodule.exports = function (METHOD_NAME, argument) {\n  var method = [][METHOD_NAME];\n  return !!method && fails(function () {\n    // eslint-disable-next-line no-useless-call,no-throw-literal -- required for testing\n    method.call(null, argument || function () { throw 1; }, 1);\n  });\n};\n","var $ = require('../internals/export');\nvar toObject = require('../internals/to-object');\nvar nativeKeys = require('../internals/object-keys');\nvar fails = require('../internals/fails');\n\nvar FAILS_ON_PRIMITIVES = fails(function () { nativeKeys(1); });\n\n// `Object.keys` method\n// https://tc39.es/ecma262/#sec-object.keys\n$({ target: 'Object', stat: true, forced: FAILS_ON_PRIMITIVES }, {\n  keys: function keys(it) {\n    return nativeKeys(toObject(it));\n  }\n});\n","'use strict';\nvar $ = require('../internals/export');\nvar toIntegerOrInfinity = require('../internals/to-integer-or-infinity');\nvar thisNumberValue = require('../internals/this-number-value');\nvar repeat = require('../internals/string-repeat');\nvar fails = require('../internals/fails');\n\nvar nativeToFixed = 1.0.toFixed;\nvar floor = Math.floor;\n\nvar pow = function (x, n, acc) {\n  return n === 0 ? acc : n % 2 === 1 ? pow(x, n - 1, acc * x) : pow(x * x, n / 2, acc);\n};\n\nvar log = function (x) {\n  var n = 0;\n  var x2 = x;\n  while (x2 >= 4096) {\n    n += 12;\n    x2 /= 4096;\n  }\n  while (x2 >= 2) {\n    n += 1;\n    x2 /= 2;\n  } return n;\n};\n\nvar multiply = function (data, n, c) {\n  var index = -1;\n  var c2 = c;\n  while (++index < 6) {\n    c2 += n * data[index];\n    data[index] = c2 % 1e7;\n    c2 = floor(c2 / 1e7);\n  }\n};\n\nvar divide = function (data, n) {\n  var index = 6;\n  var c = 0;\n  while (--index >= 0) {\n    c += data[index];\n    data[index] = floor(c / n);\n    c = (c % n) * 1e7;\n  }\n};\n\nvar dataToString = function (data) {\n  var index = 6;\n  var s = '';\n  while (--index >= 0) {\n    if (s !== '' || index === 0 || data[index] !== 0) {\n      var t = String(data[index]);\n      s = s === '' ? t : s + repeat.call('0', 7 - t.length) + t;\n    }\n  } return s;\n};\n\nvar FORCED = nativeToFixed && (\n  0.00008.toFixed(3) !== '0.000' ||\n  0.9.toFixed(0) !== '1' ||\n  1.255.toFixed(2) !== '1.25' ||\n  1000000000000000128.0.toFixed(0) !== '1000000000000000128'\n) || !fails(function () {\n  // V8 ~ Android 4.3-\n  nativeToFixed.call({});\n});\n\n// `Number.prototype.toFixed` method\n// https://tc39.es/ecma262/#sec-number.prototype.tofixed\n$({ target: 'Number', proto: true, forced: FORCED }, {\n  toFixed: function toFixed(fractionDigits) {\n    var number = thisNumberValue(this);\n    var fractDigits = toIntegerOrInfinity(fractionDigits);\n    var data = [0, 0, 0, 0, 0, 0];\n    var sign = '';\n    var result = '0';\n    var e, z, j, k;\n\n    if (fractDigits < 0 || fractDigits > 20) throw RangeError('Incorrect fraction digits');\n    // eslint-disable-next-line no-self-compare -- NaN check\n    if (number != number) return 'NaN';\n    if (number <= -1e21 || number >= 1e21) return String(number);\n    if (number < 0) {\n      sign = '-';\n      number = -number;\n    }\n    if (number > 1e-21) {\n      e = log(number * pow(2, 69, 1)) - 69;\n      z = e < 0 ? number * pow(2, -e, 1) : number / pow(2, e, 1);\n      z *= 0x10000000000000;\n      e = 52 - e;\n      if (e > 0) {\n        multiply(data, 0, z);\n        j = fractDigits;\n        while (j >= 7) {\n          multiply(data, 1e7, 0);\n          j -= 7;\n        }\n        multiply(data, pow(10, j, 1), 0);\n        j = e - 1;\n        while (j >= 23) {\n          divide(data, 1 << 23);\n          j -= 23;\n        }\n        divide(data, 1 << j);\n        multiply(data, 1, 1);\n        divide(data, 2);\n        result = dataToString(data);\n      } else {\n        multiply(data, 0, z);\n        multiply(data, 1 << -e, 0);\n        result = dataToString(data) + repeat.call('0', fractDigits);\n      }\n    }\n    if (fractDigits > 0) {\n      k = result.length;\n      result = sign + (k <= fractDigits\n        ? '0.' + repeat.call('0', fractDigits - k) + result\n        : result.slice(0, k - fractDigits) + '.' + result.slice(k - fractDigits));\n    } else {\n      result = sign + result;\n    } return result;\n  }\n});\n","var bind = require('../internals/function-bind-context');\nvar IndexedObject = require('../internals/indexed-object');\nvar toObject = require('../internals/to-object');\nvar lengthOfArrayLike = require('../internals/length-of-array-like');\nvar arraySpeciesCreate = require('../internals/array-species-create');\n\nvar push = [].push;\n\n// `Array.prototype.{ forEach, map, filter, some, every, find, findIndex, filterReject }` methods implementation\nvar createMethod = function (TYPE) {\n  var IS_MAP = TYPE == 1;\n  var IS_FILTER = TYPE == 2;\n  var IS_SOME = TYPE == 3;\n  var IS_EVERY = TYPE == 4;\n  var IS_FIND_INDEX = TYPE == 6;\n  var IS_FILTER_REJECT = TYPE == 7;\n  var NO_HOLES = TYPE == 5 || IS_FIND_INDEX;\n  return function ($this, callbackfn, that, specificCreate) {\n    var O = toObject($this);\n    var self = IndexedObject(O);\n    var boundFunction = bind(callbackfn, that, 3);\n    var length = lengthOfArrayLike(self);\n    var index = 0;\n    var create = specificCreate || arraySpeciesCreate;\n    var target = IS_MAP ? create($this, length) : IS_FILTER || IS_FILTER_REJECT ? create($this, 0) : undefined;\n    var value, result;\n    for (;length > index; index++) if (NO_HOLES || index in self) {\n      value = self[index];\n      result = boundFunction(value, index, O);\n      if (TYPE) {\n        if (IS_MAP) target[index] = result; // map\n        else if (result) switch (TYPE) {\n          case 3: return true;              // some\n          case 5: return value;             // find\n          case 6: return index;             // findIndex\n          case 2: push.call(target, value); // filter\n        } else switch (TYPE) {\n          case 4: return false;             // every\n          case 7: push.call(target, value); // filterReject\n        }\n      }\n    }\n    return IS_FIND_INDEX ? -1 : IS_SOME || IS_EVERY ? IS_EVERY : target;\n  };\n};\n\nmodule.exports = {\n  // `Array.prototype.forEach` method\n  // https://tc39.es/ecma262/#sec-array.prototype.foreach\n  forEach: createMethod(0),\n  // `Array.prototype.map` method\n  // https://tc39.es/ecma262/#sec-array.prototype.map\n  map: createMethod(1),\n  // `Array.prototype.filter` method\n  // https://tc39.es/ecma262/#sec-array.prototype.filter\n  filter: createMethod(2),\n  // `Array.prototype.some` method\n  // https://tc39.es/ecma262/#sec-array.prototype.some\n  some: createMethod(3),\n  // `Array.prototype.every` method\n  // https://tc39.es/ecma262/#sec-array.prototype.every\n  every: createMethod(4),\n  // `Array.prototype.find` method\n  // https://tc39.es/ecma262/#sec-array.prototype.find\n  find: createMethod(5),\n  // `Array.prototype.findIndex` method\n  // https://tc39.es/ecma262/#sec-array.prototype.findIndex\n  findIndex: createMethod(6),\n  // `Array.prototype.filterReject` method\n  // https://github.com/tc39/proposal-array-filtering\n  filterReject: createMethod(7)\n};\n","var $ = require('../internals/export');\nvar DESCRIPTORS = require('../internals/descriptors');\nvar ownKeys = require('../internals/own-keys');\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar getOwnPropertyDescriptorModule = require('../internals/object-get-own-property-descriptor');\nvar createProperty = require('../internals/create-property');\n\n// `Object.getOwnPropertyDescriptors` method\n// https://tc39.es/ecma262/#sec-object.getownpropertydescriptors\n$({ target: 'Object', stat: true, sham: !DESCRIPTORS }, {\n  getOwnPropertyDescriptors: function getOwnPropertyDescriptors(object) {\n    var O = toIndexedObject(object);\n    var getOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f;\n    var keys = ownKeys(O);\n    var result = {};\n    var index = 0;\n    var key, descriptor;\n    while (keys.length > index) {\n      descriptor = getOwnPropertyDescriptor(O, key = keys[index++]);\n      if (descriptor !== undefined) createProperty(result, key, descriptor);\n    }\n    return result;\n  }\n});\n","var $ = require('../internals/export');\nvar fails = require('../internals/fails');\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar nativeGetOwnPropertyDescriptor = require('../internals/object-get-own-property-descriptor').f;\nvar DESCRIPTORS = require('../internals/descriptors');\n\nvar FAILS_ON_PRIMITIVES = fails(function () { nativeGetOwnPropertyDescriptor(1); });\nvar FORCED = !DESCRIPTORS || FAILS_ON_PRIMITIVES;\n\n// `Object.getOwnPropertyDescriptor` method\n// https://tc39.es/ecma262/#sec-object.getownpropertydescriptor\n$({ target: 'Object', stat: true, forced: FORCED, sham: !DESCRIPTORS }, {\n  getOwnPropertyDescriptor: function getOwnPropertyDescriptor(it, key) {\n    return nativeGetOwnPropertyDescriptor(toIndexedObject(it), key);\n  }\n});\n","var wellKnownSymbol = require('../internals/well-known-symbol');\n\nexports.f = wellKnownSymbol;\n"],"sourceRoot":""}