{"version":3,"sources":["webpack:////workdir/node_modules/debug/src/browser.js","webpack:////workdir/node_modules/debug/src/common.js","webpack:////workdir/node_modules/deepmerge/dist/cjs.js","webpack:////workdir/node_modules/debug/node_modules/ms/index.js","webpack:////workdir/node_modules/decimal.js/decimal.js"],"names":["useColors","window","process","type","__nwjs","navigator","userAgent","toLowerCase","match","document","documentElement","style","WebkitAppearance","console","firebug","exception","table","parseInt","RegExp","$1","formatArgs","args","this","namespace","module","exports","humanize","diff","c","color","splice","index","lastC","replace","save","namespaces","storage","setItem","removeItem","error","load","r","getItem","DEBUG","localstorage","localStorage","destroy","warned","warn","colors","log","debug","formatters","j","v","JSON","stringify","message","setup","env","selectColor","hash","i","length","charCodeAt","createDebug","Math","abs","prevTime","namespacesCache","enabledCache","enableOverride","enabled","self","curr","Number","Date","ms","prev","coerce","unshift","format","formatter","val","call","logFn","apply","extend","Object","defineProperty","enumerable","configurable","get","set","init","delimiter","newDebug","enable","names","skips","split","len","push","slice","disable","map","toNamespace","join","name","test","regexp","toString","substring","Error","stack","default","keys","forEach","key","isMergeableObject","value","isNonNullObject","isSpecial","stringValue","prototype","isReactElement","canUseSymbol","Symbol","for","REACT_ELEMENT_TYPE","$$typeof","emptyTarget","Array","isArray","cloneUnlessOtherwiseSpecified","options","clone","deepmerge","defaultArrayMerge","target","source","concat","element","getMergeFunction","customMerge","getEnumerableOwnPropertySymbols","getOwnPropertySymbols","filter","symbol","propertyIsEnumerable","getKeys","propertyIsOnObject","object","property","_","propertyIsUnsafe","hasOwnProperty","mergeObject","destination","arrayMerge","sourceIsArray","targetIsArray","sourceAndTargetTypesMatch","all","array","reduce","next","deepmerge_1","s","m","h","d","w","y","parse","str","String","exec","n","parseFloat","fmtShort","msAbs","round","fmtLong","plural","isPlural","isFinite","long","globalScope","Decimal","inexact","quadrant","EXP_LIMIT","MAX_DIGITS","NUMERALS","LN10","PI","DEFAULTS","precision","rounding","modulo","toExpNeg","toExpPos","minE","maxE","crypto","external","decimalError","invalidArgument","precisionLimitExceeded","cryptoUnavailable","tag","mathfloor","floor","mathpow","pow","isBinary","isHex","isOctal","isDecimal","BASE","LOG_BASE","MAX_SAFE_INTEGER","LN10_PRECISION","PI_PRECISION","P","toStringTag","digitsToString","k","ws","indexOfLastWord","getZeroString","checkInt32","min","max","checkRoundingDigits","rm","repeating","di","rd","ceil","convertBase","baseIn","baseOut","arrL","arr","strL","indexOf","charAt","reverse","cosine","Ctor","x","isZero","tinyPow","taylorSeries","times","cos2x","minus","plus","absoluteValue","constructor","finalise","e","clampedTo","clamp","NaN","gt","cmp","comparedTo","xdL","ydL","xd","yd","xs","ys","cos","pr","sd","toLessThanHalfPi","neg","cubeRoot","cbrt","rep","t","t3","t3plusx","toExponential","divide","eq","decimalPlaces","dp","dividedBy","div","dividedToIntegerBy","divToInt","equals","greaterThan","greaterThanOrEqualTo","gte","hyperbolicCosine","cosh","one","cosh2_x","d8","hyperbolicSine","sinh","sqrt","sinh2_x","d5","d16","d20","hyperbolicTangent","tanh","inverseCosine","acos","halfPi","isNeg","getPi","asin","inverseHyperbolicCosine","acosh","lte","ln","inverseHyperbolicSine","asinh","inverseHyperbolicTangent","atanh","wpr","xsd","inverseSine","atan","inverseTangent","px","x2","isInteger","isInt","isNaN","isNegative","isPositive","isPos","lessThan","lt","lessThanOrEqualTo","logarithm","base","isBase10","denominator","inf","num","arg","guard","naturalLogarithm","getLn10","sub","xe","xLTy","pop","shift","getBase10Exponent","mod","q","naturalExponential","exp","negated","add","carry","z","getPrecision","sine","sin","squareRoot","tangent","tan","mul","rL","toBinary","toStringBinary","toDecimalPlaces","toDP","finiteToString","toFixed","toFraction","maxD","d0","d1","d2","n0","n1","toHexadecimal","toHex","toNearest","toNumber","toOctal","toPower","yn","intPow","toPrecision","toSignificantDigits","toSD","truncated","trunc","valueOf","toJSON","multiplyInteger","temp","compare","a","b","aL","bL","subtract","logBase","more","prod","prodL","qd","rem","remL","rem0","xi","xL","yd0","yL","yz","sign","isTruncated","digits","roundUp","xdi","out","isExp","nonFiniteToString","zs","truncate","isOdd","maxOrMin","ltgt","sum","c0","numerator","x1","parseDecimal","search","parseOther","divisor","isFloat","p","sin2_x","isHyperbolic","u","pi","atan2","config","obj","useDefaults","defaults","ps","getRandomValues","randomBytes","isDecimalInstance","ROUND_UP","ROUND_DOWN","ROUND_CEIL","ROUND_FLOOR","ROUND_HALF_UP","ROUND_HALF_DOWN","ROUND_HALF_EVEN","ROUND_HALF_CEIL","ROUND_HALF_FLOOR","EUCLID","hypot","log10","log2","random","arguments","Uint32Array","copy"],"mappings":"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","file":"static/js/app-acd73774.js","sourcesContent":["/* eslint-env browser */\n\n/**\n * This is the web browser implementation of `debug()`.\n */\n\nexports.formatArgs = formatArgs;\nexports.save = save;\nexports.load = load;\nexports.useColors = useColors;\nexports.storage = localstorage();\nexports.destroy = (() => {\n\tlet warned = false;\n\n\treturn () => {\n\t\tif (!warned) {\n\t\t\twarned = true;\n\t\t\tconsole.warn('Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.');\n\t\t}\n\t};\n})();\n\n/**\n * Colors.\n */\n\nexports.colors = [\n\t'#0000CC',\n\t'#0000FF',\n\t'#0033CC',\n\t'#0033FF',\n\t'#0066CC',\n\t'#0066FF',\n\t'#0099CC',\n\t'#0099FF',\n\t'#00CC00',\n\t'#00CC33',\n\t'#00CC66',\n\t'#00CC99',\n\t'#00CCCC',\n\t'#00CCFF',\n\t'#3300CC',\n\t'#3300FF',\n\t'#3333CC',\n\t'#3333FF',\n\t'#3366CC',\n\t'#3366FF',\n\t'#3399CC',\n\t'#3399FF',\n\t'#33CC00',\n\t'#33CC33',\n\t'#33CC66',\n\t'#33CC99',\n\t'#33CCCC',\n\t'#33CCFF',\n\t'#6600CC',\n\t'#6600FF',\n\t'#6633CC',\n\t'#6633FF',\n\t'#66CC00',\n\t'#66CC33',\n\t'#9900CC',\n\t'#9900FF',\n\t'#9933CC',\n\t'#9933FF',\n\t'#99CC00',\n\t'#99CC33',\n\t'#CC0000',\n\t'#CC0033',\n\t'#CC0066',\n\t'#CC0099',\n\t'#CC00CC',\n\t'#CC00FF',\n\t'#CC3300',\n\t'#CC3333',\n\t'#CC3366',\n\t'#CC3399',\n\t'#CC33CC',\n\t'#CC33FF',\n\t'#CC6600',\n\t'#CC6633',\n\t'#CC9900',\n\t'#CC9933',\n\t'#CCCC00',\n\t'#CCCC33',\n\t'#FF0000',\n\t'#FF0033',\n\t'#FF0066',\n\t'#FF0099',\n\t'#FF00CC',\n\t'#FF00FF',\n\t'#FF3300',\n\t'#FF3333',\n\t'#FF3366',\n\t'#FF3399',\n\t'#FF33CC',\n\t'#FF33FF',\n\t'#FF6600',\n\t'#FF6633',\n\t'#FF9900',\n\t'#FF9933',\n\t'#FFCC00',\n\t'#FFCC33'\n];\n\n/**\n * Currently only WebKit-based Web Inspectors, Firefox >= v31,\n * and the Firebug extension (any Firefox version) are known\n * to support \"%c\" CSS customizations.\n *\n * TODO: add a `localStorage` variable to explicitly enable/disable colors\n */\n\n// eslint-disable-next-line complexity\nfunction useColors() {\n\t// NB: In an Electron preload script, document will be defined but not fully\n\t// initialized. Since we know we're in Chrome, we'll just detect this case\n\t// explicitly\n\tif (typeof window !== 'undefined' && window.process && (window.process.type === 'renderer' || window.process.__nwjs)) {\n\t\treturn true;\n\t}\n\n\t// Internet Explorer and Edge do not support colors.\n\tif (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\\/(\\d+)/)) {\n\t\treturn false;\n\t}\n\n\t// Is webkit? http://stackoverflow.com/a/16459606/376773\n\t// document is undefined in react-native: https://github.com/facebook/react-native/pull/1632\n\treturn (typeof document !== 'undefined' && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance) ||\n\t\t// Is firebug? http://stackoverflow.com/a/398120/376773\n\t\t(typeof window !== 'undefined' && window.console && (window.console.firebug || (window.console.exception && window.console.table))) ||\n\t\t// Is firefox >= v31?\n\t\t// https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages\n\t\t(typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\\/(\\d+)/) && parseInt(RegExp.$1, 10) >= 31) ||\n\t\t// Double check webkit in userAgent just in case we are in a worker\n\t\t(typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\\/(\\d+)/));\n}\n\n/**\n * Colorize log arguments if enabled.\n *\n * @api public\n */\n\nfunction formatArgs(args) {\n\targs[0] = (this.useColors ? '%c' : '') +\n\t\tthis.namespace +\n\t\t(this.useColors ? ' %c' : ' ') +\n\t\targs[0] +\n\t\t(this.useColors ? '%c ' : ' ') +\n\t\t'+' + module.exports.humanize(this.diff);\n\n\tif (!this.useColors) {\n\t\treturn;\n\t}\n\n\tconst c = 'color: ' + this.color;\n\targs.splice(1, 0, c, 'color: inherit');\n\n\t// The final \"%c\" is somewhat tricky, because there could be other\n\t// arguments passed either before or after the %c, so we need to\n\t// figure out the correct index to insert the CSS into\n\tlet index = 0;\n\tlet lastC = 0;\n\targs[0].replace(/%[a-zA-Z%]/g, match => {\n\t\tif (match === '%%') {\n\t\t\treturn;\n\t\t}\n\t\tindex++;\n\t\tif (match === '%c') {\n\t\t\t// We only are interested in the *last* %c\n\t\t\t// (the user may have provided their own)\n\t\t\tlastC = index;\n\t\t}\n\t});\n\n\targs.splice(lastC, 0, c);\n}\n\n/**\n * Invokes `console.debug()` when available.\n * No-op when `console.debug` is not a \"function\".\n * If `console.debug` is not available, falls back\n * to `console.log`.\n *\n * @api public\n */\nexports.log = console.debug || console.log || (() => {});\n\n/**\n * Save `namespaces`.\n *\n * @param {String} namespaces\n * @api private\n */\nfunction save(namespaces) {\n\ttry {\n\t\tif (namespaces) {\n\t\t\texports.storage.setItem('debug', namespaces);\n\t\t} else {\n\t\t\texports.storage.removeItem('debug');\n\t\t}\n\t} catch (error) {\n\t\t// Swallow\n\t\t// XXX (@Qix-) should we be logging these?\n\t}\n}\n\n/**\n * Load `namespaces`.\n *\n * @return {String} returns the previously persisted debug modes\n * @api private\n */\nfunction load() {\n\tlet r;\n\ttry {\n\t\tr = exports.storage.getItem('debug');\n\t} catch (error) {\n\t\t// Swallow\n\t\t// XXX (@Qix-) should we be logging these?\n\t}\n\n\t// If debug isn't set in LS, and we're in Electron, try to load $DEBUG\n\tif (!r && typeof process !== 'undefined' && 'env' in process) {\n\t\tr = process.env.DEBUG;\n\t}\n\n\treturn r;\n}\n\n/**\n * Localstorage attempts to return the localstorage.\n *\n * This is necessary because safari throws\n * when a user disables cookies/localstorage\n * and you attempt to access it.\n *\n * @return {LocalStorage}\n * @api private\n */\n\nfunction localstorage() {\n\ttry {\n\t\t// TVMLKit (Apple TV JS Runtime) does not have a window object, just localStorage in the global context\n\t\t// The Browser also has localStorage in the global context.\n\t\treturn localStorage;\n\t} catch (error) {\n\t\t// Swallow\n\t\t// XXX (@Qix-) should we be logging these?\n\t}\n}\n\nmodule.exports = require('./common')(exports);\n\nconst {formatters} = module.exports;\n\n/**\n * Map %j to `JSON.stringify()`, since no Web Inspectors do that by default.\n */\n\nformatters.j = function (v) {\n\ttry {\n\t\treturn JSON.stringify(v);\n\t} catch (error) {\n\t\treturn '[UnexpectedJSONParseError]: ' + error.message;\n\t}\n};\n","\n/**\n * This is the common logic for both the Node.js and web browser\n * implementations of `debug()`.\n */\n\nfunction setup(env) {\n\tcreateDebug.debug = createDebug;\n\tcreateDebug.default = createDebug;\n\tcreateDebug.coerce = coerce;\n\tcreateDebug.disable = disable;\n\tcreateDebug.enable = enable;\n\tcreateDebug.enabled = enabled;\n\tcreateDebug.humanize = require('ms');\n\tcreateDebug.destroy = destroy;\n\n\tObject.keys(env).forEach(key => {\n\t\tcreateDebug[key] = env[key];\n\t});\n\n\t/**\n\t* The currently active debug mode names, and names to skip.\n\t*/\n\n\tcreateDebug.names = [];\n\tcreateDebug.skips = [];\n\n\t/**\n\t* Map of special \"%n\" handling functions, for the debug \"format\" argument.\n\t*\n\t* Valid key names are a single, lower or upper-case letter, i.e. \"n\" and \"N\".\n\t*/\n\tcreateDebug.formatters = {};\n\n\t/**\n\t* Selects a color for a debug namespace\n\t* @param {String} namespace The namespace string for the debug instance to be colored\n\t* @return {Number|String} An ANSI color code for the given namespace\n\t* @api private\n\t*/\n\tfunction selectColor(namespace) {\n\t\tlet hash = 0;\n\n\t\tfor (let i = 0; i < namespace.length; i++) {\n\t\t\thash = ((hash << 5) - hash) + namespace.charCodeAt(i);\n\t\t\thash |= 0; // Convert to 32bit integer\n\t\t}\n\n\t\treturn createDebug.colors[Math.abs(hash) % createDebug.colors.length];\n\t}\n\tcreateDebug.selectColor = selectColor;\n\n\t/**\n\t* Create a debugger with the given `namespace`.\n\t*\n\t* @param {String} namespace\n\t* @return {Function}\n\t* @api public\n\t*/\n\tfunction createDebug(namespace) {\n\t\tlet prevTime;\n\t\tlet enableOverride = null;\n\t\tlet namespacesCache;\n\t\tlet enabledCache;\n\n\t\tfunction debug(...args) {\n\t\t\t// Disabled?\n\t\t\tif (!debug.enabled) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tconst self = debug;\n\n\t\t\t// Set `diff` timestamp\n\t\t\tconst curr = Number(new Date());\n\t\t\tconst ms = curr - (prevTime || curr);\n\t\t\tself.diff = ms;\n\t\t\tself.prev = prevTime;\n\t\t\tself.curr = curr;\n\t\t\tprevTime = curr;\n\n\t\t\targs[0] = createDebug.coerce(args[0]);\n\n\t\t\tif (typeof args[0] !== 'string') {\n\t\t\t\t// Anything else let's inspect with %O\n\t\t\t\targs.unshift('%O');\n\t\t\t}\n\n\t\t\t// Apply any `formatters` transformations\n\t\t\tlet index = 0;\n\t\t\targs[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format) => {\n\t\t\t\t// If we encounter an escaped % then don't increase the array index\n\t\t\t\tif (match === '%%') {\n\t\t\t\t\treturn '%';\n\t\t\t\t}\n\t\t\t\tindex++;\n\t\t\t\tconst formatter = createDebug.formatters[format];\n\t\t\t\tif (typeof formatter === 'function') {\n\t\t\t\t\tconst val = args[index];\n\t\t\t\t\tmatch = formatter.call(self, val);\n\n\t\t\t\t\t// Now we need to remove `args[index]` since it's inlined in the `format`\n\t\t\t\t\targs.splice(index, 1);\n\t\t\t\t\tindex--;\n\t\t\t\t}\n\t\t\t\treturn match;\n\t\t\t});\n\n\t\t\t// Apply env-specific formatting (colors, etc.)\n\t\t\tcreateDebug.formatArgs.call(self, args);\n\n\t\t\tconst logFn = self.log || createDebug.log;\n\t\t\tlogFn.apply(self, args);\n\t\t}\n\n\t\tdebug.namespace = namespace;\n\t\tdebug.useColors = createDebug.useColors();\n\t\tdebug.color = createDebug.selectColor(namespace);\n\t\tdebug.extend = extend;\n\t\tdebug.destroy = createDebug.destroy; // XXX Temporary. Will be removed in the next major release.\n\n\t\tObject.defineProperty(debug, 'enabled', {\n\t\t\tenumerable: true,\n\t\t\tconfigurable: false,\n\t\t\tget: () => {\n\t\t\t\tif (enableOverride !== null) {\n\t\t\t\t\treturn enableOverride;\n\t\t\t\t}\n\t\t\t\tif (namespacesCache !== createDebug.namespaces) {\n\t\t\t\t\tnamespacesCache = createDebug.namespaces;\n\t\t\t\t\tenabledCache = createDebug.enabled(namespace);\n\t\t\t\t}\n\n\t\t\t\treturn enabledCache;\n\t\t\t},\n\t\t\tset: v => {\n\t\t\t\tenableOverride = v;\n\t\t\t}\n\t\t});\n\n\t\t// Env-specific initialization logic for debug instances\n\t\tif (typeof createDebug.init === 'function') {\n\t\t\tcreateDebug.init(debug);\n\t\t}\n\n\t\treturn debug;\n\t}\n\n\tfunction extend(namespace, delimiter) {\n\t\tconst newDebug = createDebug(this.namespace + (typeof delimiter === 'undefined' ? ':' : delimiter) + namespace);\n\t\tnewDebug.log = this.log;\n\t\treturn newDebug;\n\t}\n\n\t/**\n\t* Enables a debug mode by namespaces. This can include modes\n\t* separated by a colon and wildcards.\n\t*\n\t* @param {String} namespaces\n\t* @api public\n\t*/\n\tfunction enable(namespaces) {\n\t\tcreateDebug.save(namespaces);\n\t\tcreateDebug.namespaces = namespaces;\n\n\t\tcreateDebug.names = [];\n\t\tcreateDebug.skips = [];\n\n\t\tlet i;\n\t\tconst split = (typeof namespaces === 'string' ? namespaces : '').split(/[\\s,]+/);\n\t\tconst len = split.length;\n\n\t\tfor (i = 0; i < len; i++) {\n\t\t\tif (!split[i]) {\n\t\t\t\t// ignore empty strings\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\tnamespaces = split[i].replace(/\\*/g, '.*?');\n\n\t\t\tif (namespaces[0] === '-') {\n\t\t\t\tcreateDebug.skips.push(new RegExp('^' + namespaces.slice(1) + '$'));\n\t\t\t} else {\n\t\t\t\tcreateDebug.names.push(new RegExp('^' + namespaces + '$'));\n\t\t\t}\n\t\t}\n\t}\n\n\t/**\n\t* Disable debug output.\n\t*\n\t* @return {String} namespaces\n\t* @api public\n\t*/\n\tfunction disable() {\n\t\tconst namespaces = [\n\t\t\t...createDebug.names.map(toNamespace),\n\t\t\t...createDebug.skips.map(toNamespace).map(namespace => '-' + namespace)\n\t\t].join(',');\n\t\tcreateDebug.enable('');\n\t\treturn namespaces;\n\t}\n\n\t/**\n\t* Returns true if the given mode name is enabled, false otherwise.\n\t*\n\t* @param {String} name\n\t* @return {Boolean}\n\t* @api public\n\t*/\n\tfunction enabled(name) {\n\t\tif (name[name.length - 1] === '*') {\n\t\t\treturn true;\n\t\t}\n\n\t\tlet i;\n\t\tlet len;\n\n\t\tfor (i = 0, len = createDebug.skips.length; i < len; i++) {\n\t\t\tif (createDebug.skips[i].test(name)) {\n\t\t\t\treturn false;\n\t\t\t}\n\t\t}\n\n\t\tfor (i = 0, len = createDebug.names.length; i < len; i++) {\n\t\t\tif (createDebug.names[i].test(name)) {\n\t\t\t\treturn true;\n\t\t\t}\n\t\t}\n\n\t\treturn false;\n\t}\n\n\t/**\n\t* Convert regexp to namespace\n\t*\n\t* @param {RegExp} regxep\n\t* @return {String} namespace\n\t* @api private\n\t*/\n\tfunction toNamespace(regexp) {\n\t\treturn regexp.toString()\n\t\t\t.substring(2, regexp.toString().length - 2)\n\t\t\t.replace(/\\.\\*\\?$/, '*');\n\t}\n\n\t/**\n\t* Coerce `val`.\n\t*\n\t* @param {Mixed} val\n\t* @return {Mixed}\n\t* @api private\n\t*/\n\tfunction coerce(val) {\n\t\tif (val instanceof Error) {\n\t\t\treturn val.stack || val.message;\n\t\t}\n\t\treturn val;\n\t}\n\n\t/**\n\t* XXX DO NOT USE. This is a temporary stub function.\n\t* XXX It WILL be removed in the next major release.\n\t*/\n\tfunction destroy() {\n\t\tconsole.warn('Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.');\n\t}\n\n\tcreateDebug.enable(createDebug.load());\n\n\treturn createDebug;\n}\n\nmodule.exports = setup;\n","'use strict';\n\nvar isMergeableObject = function isMergeableObject(value) {\n\treturn isNonNullObject(value)\n\t\t&& !isSpecial(value)\n};\n\nfunction isNonNullObject(value) {\n\treturn !!value && typeof value === 'object'\n}\n\nfunction isSpecial(value) {\n\tvar stringValue = Object.prototype.toString.call(value);\n\n\treturn stringValue === '[object RegExp]'\n\t\t|| stringValue === '[object Date]'\n\t\t|| isReactElement(value)\n}\n\n// see https://github.com/facebook/react/blob/b5ac963fb791d1298e7f396236383bc955f916c1/src/isomorphic/classic/element/ReactElement.js#L21-L25\nvar canUseSymbol = typeof Symbol === 'function' && Symbol.for;\nvar REACT_ELEMENT_TYPE = canUseSymbol ? Symbol.for('react.element') : 0xeac7;\n\nfunction isReactElement(value) {\n\treturn value.$$typeof === REACT_ELEMENT_TYPE\n}\n\nfunction emptyTarget(val) {\n\treturn Array.isArray(val) ? [] : {}\n}\n\nfunction cloneUnlessOtherwiseSpecified(value, options) {\n\treturn (options.clone !== false && options.isMergeableObject(value))\n\t\t? deepmerge(emptyTarget(value), value, options)\n\t\t: value\n}\n\nfunction defaultArrayMerge(target, source, options) {\n\treturn target.concat(source).map(function(element) {\n\t\treturn cloneUnlessOtherwiseSpecified(element, options)\n\t})\n}\n\nfunction getMergeFunction(key, options) {\n\tif (!options.customMerge) {\n\t\treturn deepmerge\n\t}\n\tvar customMerge = options.customMerge(key);\n\treturn typeof customMerge === 'function' ? customMerge : deepmerge\n}\n\nfunction getEnumerableOwnPropertySymbols(target) {\n\treturn Object.getOwnPropertySymbols\n\t\t? Object.getOwnPropertySymbols(target).filter(function(symbol) {\n\t\t\treturn target.propertyIsEnumerable(symbol)\n\t\t})\n\t\t: []\n}\n\nfunction getKeys(target) {\n\treturn Object.keys(target).concat(getEnumerableOwnPropertySymbols(target))\n}\n\nfunction propertyIsOnObject(object, property) {\n\ttry {\n\t\treturn property in object\n\t} catch(_) {\n\t\treturn false\n\t}\n}\n\n// Protects from prototype poisoning and unexpected merging up the prototype chain.\nfunction propertyIsUnsafe(target, key) {\n\treturn propertyIsOnObject(target, key) // Properties are safe to merge if they don't exist in the target yet,\n\t\t&& !(Object.hasOwnProperty.call(target, key) // unsafe if they exist up the prototype chain,\n\t\t\t&& Object.propertyIsEnumerable.call(target, key)) // and also unsafe if they're nonenumerable.\n}\n\nfunction mergeObject(target, source, options) {\n\tvar destination = {};\n\tif (options.isMergeableObject(target)) {\n\t\tgetKeys(target).forEach(function(key) {\n\t\t\tdestination[key] = cloneUnlessOtherwiseSpecified(target[key], options);\n\t\t});\n\t}\n\tgetKeys(source).forEach(function(key) {\n\t\tif (propertyIsUnsafe(target, key)) {\n\t\t\treturn\n\t\t}\n\n\t\tif (propertyIsOnObject(target, key) && options.isMergeableObject(source[key])) {\n\t\t\tdestination[key] = getMergeFunction(key, options)(target[key], source[key], options);\n\t\t} else {\n\t\t\tdestination[key] = cloneUnlessOtherwiseSpecified(source[key], options);\n\t\t}\n\t});\n\treturn destination\n}\n\nfunction deepmerge(target, source, options) {\n\toptions = options || {};\n\toptions.arrayMerge = options.arrayMerge || defaultArrayMerge;\n\toptions.isMergeableObject = options.isMergeableObject || isMergeableObject;\n\t// cloneUnlessOtherwiseSpecified is added to `options` so that custom arrayMerge()\n\t// implementations can use it. The caller may not replace it.\n\toptions.cloneUnlessOtherwiseSpecified = cloneUnlessOtherwiseSpecified;\n\n\tvar sourceIsArray = Array.isArray(source);\n\tvar targetIsArray = Array.isArray(target);\n\tvar sourceAndTargetTypesMatch = sourceIsArray === targetIsArray;\n\n\tif (!sourceAndTargetTypesMatch) {\n\t\treturn cloneUnlessOtherwiseSpecified(source, options)\n\t} else if (sourceIsArray) {\n\t\treturn options.arrayMerge(target, source, options)\n\t} else {\n\t\treturn mergeObject(target, source, options)\n\t}\n}\n\ndeepmerge.all = function deepmergeAll(array, options) {\n\tif (!Array.isArray(array)) {\n\t\tthrow new Error('first argument should be an array')\n\t}\n\n\treturn array.reduce(function(prev, next) {\n\t\treturn deepmerge(prev, next, options)\n\t}, {})\n};\n\nvar deepmerge_1 = deepmerge;\n\nmodule.exports = deepmerge_1;\n","/**\n * Helpers.\n */\n\nvar s = 1000;\nvar m = s * 60;\nvar h = m * 60;\nvar d = h * 24;\nvar w = d * 7;\nvar y = d * 365.25;\n\n/**\n * Parse or format the given `val`.\n *\n * Options:\n *\n *  - `long` verbose formatting [false]\n *\n * @param {String|Number} val\n * @param {Object} [options]\n * @throws {Error} throw an error if val is not a non-empty string or a number\n * @return {String|Number}\n * @api public\n */\n\nmodule.exports = function(val, options) {\n  options = options || {};\n  var type = typeof val;\n  if (type === 'string' && val.length > 0) {\n    return parse(val);\n  } else if (type === 'number' && isFinite(val)) {\n    return options.long ? fmtLong(val) : fmtShort(val);\n  }\n  throw new Error(\n    'val is not a non-empty string or a valid number. val=' +\n      JSON.stringify(val)\n  );\n};\n\n/**\n * Parse the given `str` and return milliseconds.\n *\n * @param {String} str\n * @return {Number}\n * @api private\n */\n\nfunction parse(str) {\n  str = String(str);\n  if (str.length > 100) {\n    return;\n  }\n  var match = /^(-?(?:\\d+)?\\.?\\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(\n    str\n  );\n  if (!match) {\n    return;\n  }\n  var n = parseFloat(match[1]);\n  var type = (match[2] || 'ms').toLowerCase();\n  switch (type) {\n    case 'years':\n    case 'year':\n    case 'yrs':\n    case 'yr':\n    case 'y':\n      return n * y;\n    case 'weeks':\n    case 'week':\n    case 'w':\n      return n * w;\n    case 'days':\n    case 'day':\n    case 'd':\n      return n * d;\n    case 'hours':\n    case 'hour':\n    case 'hrs':\n    case 'hr':\n    case 'h':\n      return n * h;\n    case 'minutes':\n    case 'minute':\n    case 'mins':\n    case 'min':\n    case 'm':\n      return n * m;\n    case 'seconds':\n    case 'second':\n    case 'secs':\n    case 'sec':\n    case 's':\n      return n * s;\n    case 'milliseconds':\n    case 'millisecond':\n    case 'msecs':\n    case 'msec':\n    case 'ms':\n      return n;\n    default:\n      return undefined;\n  }\n}\n\n/**\n * Short format for `ms`.\n *\n * @param {Number} ms\n * @return {String}\n * @api private\n */\n\nfunction fmtShort(ms) {\n  var msAbs = Math.abs(ms);\n  if (msAbs >= d) {\n    return Math.round(ms / d) + 'd';\n  }\n  if (msAbs >= h) {\n    return Math.round(ms / h) + 'h';\n  }\n  if (msAbs >= m) {\n    return Math.round(ms / m) + 'm';\n  }\n  if (msAbs >= s) {\n    return Math.round(ms / s) + 's';\n  }\n  return ms + 'ms';\n}\n\n/**\n * Long format for `ms`.\n *\n * @param {Number} ms\n * @return {String}\n * @api private\n */\n\nfunction fmtLong(ms) {\n  var msAbs = Math.abs(ms);\n  if (msAbs >= d) {\n    return plural(ms, msAbs, d, 'day');\n  }\n  if (msAbs >= h) {\n    return plural(ms, msAbs, h, 'hour');\n  }\n  if (msAbs >= m) {\n    return plural(ms, msAbs, m, 'minute');\n  }\n  if (msAbs >= s) {\n    return plural(ms, msAbs, s, 'second');\n  }\n  return ms + ' ms';\n}\n\n/**\n * Pluralization helper.\n */\n\nfunction plural(ms, msAbs, n, name) {\n  var isPlural = msAbs >= n * 1.5;\n  return Math.round(ms / n) + ' ' + name + (isPlural ? 's' : '');\n}\n",";(function (globalScope) {\r\n  'use strict';\r\n\r\n\r\n  /*\r\n   *  decimal.js v10.3.1\r\n   *  An arbitrary-precision Decimal type for JavaScript.\r\n   *  https://github.com/MikeMcl/decimal.js\r\n   *  Copyright (c) 2021 Michael Mclaughlin <M8ch88l@gmail.com>\r\n   *  MIT Licence\r\n   */\r\n\r\n\r\n  // -----------------------------------  EDITABLE DEFAULTS  ------------------------------------ //\r\n\r\n\r\n    // The maximum exponent magnitude.\r\n    // The limit on the value of `toExpNeg`, `toExpPos`, `minE` and `maxE`.\r\n  var EXP_LIMIT = 9e15,                      // 0 to 9e15\r\n\r\n    // The limit on the value of `precision`, and on the value of the first argument to\r\n    // `toDecimalPlaces`, `toExponential`, `toFixed`, `toPrecision` and `toSignificantDigits`.\r\n    MAX_DIGITS = 1e9,                        // 0 to 1e9\r\n\r\n    // Base conversion alphabet.\r\n    NUMERALS = '0123456789abcdef',\r\n\r\n    // The natural logarithm of 10 (1025 digits).\r\n    LN10 = '2.3025850929940456840179914546843642076011014886287729760333279009675726096773524802359972050895982983419677840422862486334095254650828067566662873690987816894829072083255546808437998948262331985283935053089653777326288461633662222876982198867465436674744042432743651550489343149393914796194044002221051017141748003688084012647080685567743216228355220114804663715659121373450747856947683463616792101806445070648000277502684916746550586856935673420670581136429224554405758925724208241314695689016758940256776311356919292033376587141660230105703089634572075440370847469940168269282808481184289314848524948644871927809676271275775397027668605952496716674183485704422507197965004714951050492214776567636938662976979522110718264549734772662425709429322582798502585509785265383207606726317164309505995087807523710333101197857547331541421808427543863591778117054309827482385045648019095610299291824318237525357709750539565187697510374970888692180205189339507238539205144634197265287286965110862571492198849978748873771345686209167058',\r\n\r\n    // Pi (1025 digits).\r\n    PI = '3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679821480865132823066470938446095505822317253594081284811174502841027019385211055596446229489549303819644288109756659334461284756482337867831652712019091456485669234603486104543266482133936072602491412737245870066063155881748815209209628292540917153643678925903600113305305488204665213841469519415116094330572703657595919530921861173819326117931051185480744623799627495673518857527248912279381830119491298336733624406566430860213949463952247371907021798609437027705392171762931767523846748184676694051320005681271452635608277857713427577896091736371787214684409012249534301465495853710507922796892589235420199561121290219608640344181598136297747713099605187072113499999983729780499510597317328160963185950244594553469083026425223082533446850352619311881710100031378387528865875332083814206171776691473035982534904287554687311595628638823537875937519577818577805321712268066130019278766111959092164201989380952572010654858632789',\r\n\r\n\r\n    // The initial configuration properties of the Decimal constructor.\r\n    DEFAULTS = {\r\n\r\n      // These values must be integers within the stated ranges (inclusive).\r\n      // Most of these values can be changed at run-time using the `Decimal.config` method.\r\n\r\n      // The maximum number of significant digits of the result of a calculation or base conversion.\r\n      // E.g. `Decimal.config({ precision: 20 });`\r\n      precision: 20,                         // 1 to MAX_DIGITS\r\n\r\n      // The rounding mode used when rounding to `precision`.\r\n      //\r\n      // ROUND_UP         0 Away from zero.\r\n      // ROUND_DOWN       1 Towards zero.\r\n      // ROUND_CEIL       2 Towards +Infinity.\r\n      // ROUND_FLOOR      3 Towards -Infinity.\r\n      // ROUND_HALF_UP    4 Towards nearest neighbour. If equidistant, up.\r\n      // ROUND_HALF_DOWN  5 Towards nearest neighbour. If equidistant, down.\r\n      // ROUND_HALF_EVEN  6 Towards nearest neighbour. If equidistant, towards even neighbour.\r\n      // ROUND_HALF_CEIL  7 Towards nearest neighbour. If equidistant, towards +Infinity.\r\n      // ROUND_HALF_FLOOR 8 Towards nearest neighbour. If equidistant, towards -Infinity.\r\n      //\r\n      // E.g.\r\n      // `Decimal.rounding = 4;`\r\n      // `Decimal.rounding = Decimal.ROUND_HALF_UP;`\r\n      rounding: 4,                           // 0 to 8\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 (JavaScript %).\r\n      // FLOOR      3 The remainder has the same sign as the divisor (Python %).\r\n      // HALF_EVEN  6 The IEEE 754 remainder function.\r\n      // EUCLID     9 Euclidian division. q = sign(n) * floor(a / abs(n)). Always positive.\r\n      //\r\n      // Truncated division (1), floored division (3), the IEEE 754 remainder (6), and Euclidian\r\n      // division (9) are commonly used for the modulus operation. The other rounding modes can also\r\n      // be used, but they may not give useful results.\r\n      modulo: 1,                             // 0 to 9\r\n\r\n      // The exponent value at and beneath which `toString` returns exponential notation.\r\n      // JavaScript numbers: -7\r\n      toExpNeg: -7,                          // 0 to -EXP_LIMIT\r\n\r\n      // The exponent value at and above which `toString` returns exponential notation.\r\n      // JavaScript numbers: 21\r\n      toExpPos:  21,                         // 0 to EXP_LIMIT\r\n\r\n      // The minimum exponent value, beneath which underflow to zero occurs.\r\n      // JavaScript numbers: -324  (5e-324)\r\n      minE: -EXP_LIMIT,                      // -1 to -EXP_LIMIT\r\n\r\n      // The maximum exponent value, above which overflow to Infinity occurs.\r\n      // JavaScript numbers: 308  (1.7976931348623157e+308)\r\n      maxE: EXP_LIMIT,                       // 1 to EXP_LIMIT\r\n\r\n      // Whether to use cryptographically-secure random number generation, if available.\r\n      crypto: false                          // true/false\r\n    },\r\n\r\n\r\n  // ----------------------------------- END OF EDITABLE DEFAULTS ------------------------------- //\r\n\r\n\r\n    Decimal, inexact, noConflict, quadrant,\r\n    external = true,\r\n\r\n    decimalError = '[DecimalError] ',\r\n    invalidArgument = decimalError + 'Invalid argument: ',\r\n    precisionLimitExceeded = decimalError + 'Precision limit exceeded',\r\n    cryptoUnavailable = decimalError + 'crypto unavailable',\r\n    tag = '[object Decimal]',\r\n\r\n    mathfloor = Math.floor,\r\n    mathpow = Math.pow,\r\n\r\n    isBinary = /^0b([01]+(\\.[01]*)?|\\.[01]+)(p[+-]?\\d+)?$/i,\r\n    isHex = /^0x([0-9a-f]+(\\.[0-9a-f]*)?|\\.[0-9a-f]+)(p[+-]?\\d+)?$/i,\r\n    isOctal = /^0o([0-7]+(\\.[0-7]*)?|\\.[0-7]+)(p[+-]?\\d+)?$/i,\r\n    isDecimal = /^(\\d+(\\.\\d*)?|\\.\\d+)(e[+-]?\\d+)?$/i,\r\n\r\n    BASE = 1e7,\r\n    LOG_BASE = 7,\r\n    MAX_SAFE_INTEGER = 9007199254740991,\r\n\r\n    LN10_PRECISION = LN10.length - 1,\r\n    PI_PRECISION = PI.length - 1,\r\n\r\n    // Decimal.prototype object\r\n    P = { toStringTag: tag };\r\n\r\n\r\n  // Decimal prototype methods\r\n\r\n\r\n  /*\r\n   *  absoluteValue             abs\r\n   *  ceil\r\n   *  clampedTo                 clamp\r\n   *  comparedTo                cmp\r\n   *  cosine                    cos\r\n   *  cubeRoot                  cbrt\r\n   *  decimalPlaces             dp\r\n   *  dividedBy                 div\r\n   *  dividedToIntegerBy        divToInt\r\n   *  equals                    eq\r\n   *  floor\r\n   *  greaterThan               gt\r\n   *  greaterThanOrEqualTo      gte\r\n   *  hyperbolicCosine          cosh\r\n   *  hyperbolicSine            sinh\r\n   *  hyperbolicTangent         tanh\r\n   *  inverseCosine             acos\r\n   *  inverseHyperbolicCosine   acosh\r\n   *  inverseHyperbolicSine     asinh\r\n   *  inverseHyperbolicTangent  atanh\r\n   *  inverseSine               asin\r\n   *  inverseTangent            atan\r\n   *  isFinite\r\n   *  isInteger                 isInt\r\n   *  isNaN\r\n   *  isNegative                isNeg\r\n   *  isPositive                isPos\r\n   *  isZero\r\n   *  lessThan                  lt\r\n   *  lessThanOrEqualTo         lte\r\n   *  logarithm                 log\r\n   *  [maximum]                 [max]\r\n   *  [minimum]                 [min]\r\n   *  minus                     sub\r\n   *  modulo                    mod\r\n   *  naturalExponential        exp\r\n   *  naturalLogarithm          ln\r\n   *  negated                   neg\r\n   *  plus                      add\r\n   *  precision                 sd\r\n   *  round\r\n   *  sine                      sin\r\n   *  squareRoot                sqrt\r\n   *  tangent                   tan\r\n   *  times                     mul\r\n   *  toBinary\r\n   *  toDecimalPlaces           toDP\r\n   *  toExponential\r\n   *  toFixed\r\n   *  toFraction\r\n   *  toHexadecimal             toHex\r\n   *  toNearest\r\n   *  toNumber\r\n   *  toOctal\r\n   *  toPower                   pow\r\n   *  toPrecision\r\n   *  toSignificantDigits       toSD\r\n   *  toString\r\n   *  truncated                 trunc\r\n   *  valueOf                   toJSON\r\n   */\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the absolute value of this Decimal.\r\n   *\r\n   */\r\n  P.absoluteValue = P.abs = function () {\r\n    var x = new this.constructor(this);\r\n    if (x.s < 0) x.s = 1;\r\n    return finalise(x);\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the value of this Decimal rounded to a whole number in the\r\n   * direction of positive Infinity.\r\n   *\r\n   */\r\n  P.ceil = function () {\r\n    return finalise(new this.constructor(this), this.e + 1, 2);\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the value of this Decimal clamped to the range\r\n   * delineated by `min` and `max`.\r\n   *\r\n   * min {number|string|Decimal}\r\n   * max {number|string|Decimal}\r\n   *\r\n   */\r\n  P.clampedTo = P.clamp = function (min, max) {\r\n    var k,\r\n      x = this,\r\n      Ctor = x.constructor;\r\n    min = new Ctor(min);\r\n    max = new Ctor(max);\r\n    if (!min.s || !max.s) return new Ctor(NaN);\r\n    if (min.gt(max)) throw Error(invalidArgument + max);\r\n    k = x.cmp(min);\r\n    return k < 0 ? min : x.cmp(max) > 0 ? max : new Ctor(x);\r\n  };\r\n\r\n\r\n  /*\r\n   * Return\r\n   *   1    if the value of this Decimal is greater than the value of `y`,\r\n   *  -1    if the value of this Decimal is less than the value of `y`,\r\n   *   0    if they have the same value,\r\n   *   NaN  if the value of either Decimal is NaN.\r\n   *\r\n   */\r\n  P.comparedTo = P.cmp = function (y) {\r\n    var i, j, xdL, ydL,\r\n      x = this,\r\n      xd = x.d,\r\n      yd = (y = new x.constructor(y)).d,\r\n      xs = x.s,\r\n      ys = y.s;\r\n\r\n    // Either NaN or ±Infinity?\r\n    if (!xd || !yd) {\r\n      return !xs || !ys ? NaN : xs !== ys ? xs : xd === yd ? 0 : !xd ^ xs < 0 ? 1 : -1;\r\n    }\r\n\r\n    // Either zero?\r\n    if (!xd[0] || !yd[0]) return xd[0] ? xs : yd[0] ? -ys : 0;\r\n\r\n    // Signs differ?\r\n    if (xs !== ys) return xs;\r\n\r\n    // Compare exponents.\r\n    if (x.e !== y.e) return x.e > y.e ^ xs < 0 ? 1 : -1;\r\n\r\n    xdL = xd.length;\r\n    ydL = yd.length;\r\n\r\n    // Compare digit by digit.\r\n    for (i = 0, j = xdL < ydL ? xdL : ydL; i < j; ++i) {\r\n      if (xd[i] !== yd[i]) return xd[i] > yd[i] ^ xs < 0 ? 1 : -1;\r\n    }\r\n\r\n    // Compare lengths.\r\n    return xdL === ydL ? 0 : xdL > ydL ^ xs < 0 ? 1 : -1;\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the cosine of the value in radians of this Decimal.\r\n   *\r\n   * Domain: [-Infinity, Infinity]\r\n   * Range: [-1, 1]\r\n   *\r\n   * cos(0)         = 1\r\n   * cos(-0)        = 1\r\n   * cos(Infinity)  = NaN\r\n   * cos(-Infinity) = NaN\r\n   * cos(NaN)       = NaN\r\n   *\r\n   */\r\n  P.cosine = P.cos = function () {\r\n    var pr, rm,\r\n      x = this,\r\n      Ctor = x.constructor;\r\n\r\n    if (!x.d) return new Ctor(NaN);\r\n\r\n    // cos(0) = cos(-0) = 1\r\n    if (!x.d[0]) return new Ctor(1);\r\n\r\n    pr = Ctor.precision;\r\n    rm = Ctor.rounding;\r\n    Ctor.precision = pr + Math.max(x.e, x.sd()) + LOG_BASE;\r\n    Ctor.rounding = 1;\r\n\r\n    x = cosine(Ctor, toLessThanHalfPi(Ctor, x));\r\n\r\n    Ctor.precision = pr;\r\n    Ctor.rounding = rm;\r\n\r\n    return finalise(quadrant == 2 || quadrant == 3 ? x.neg() : x, pr, rm, true);\r\n  };\r\n\r\n\r\n  /*\r\n   *\r\n   * Return a new Decimal whose value is the cube root of the value of this Decimal, rounded to\r\n   * `precision` significant digits using rounding mode `rounding`.\r\n   *\r\n   *  cbrt(0)  =  0\r\n   *  cbrt(-0) = -0\r\n   *  cbrt(1)  =  1\r\n   *  cbrt(-1) = -1\r\n   *  cbrt(N)  =  N\r\n   *  cbrt(-I) = -I\r\n   *  cbrt(I)  =  I\r\n   *\r\n   * Math.cbrt(x) = (x < 0 ? -Math.pow(-x, 1/3) : Math.pow(x, 1/3))\r\n   *\r\n   */\r\n  P.cubeRoot = P.cbrt = function () {\r\n    var e, m, n, r, rep, s, sd, t, t3, t3plusx,\r\n      x = this,\r\n      Ctor = x.constructor;\r\n\r\n    if (!x.isFinite() || x.isZero()) return new Ctor(x);\r\n    external = false;\r\n\r\n    // Initial estimate.\r\n    s = x.s * mathpow(x.s * x, 1 / 3);\r\n\r\n     // Math.cbrt underflow/overflow?\r\n     // Pass x to Math.pow as integer, then adjust the exponent of the result.\r\n    if (!s || Math.abs(s) == 1 / 0) {\r\n      n = digitsToString(x.d);\r\n      e = x.e;\r\n\r\n      // Adjust n exponent so it is a multiple of 3 away from x exponent.\r\n      if (s = (e - n.length + 1) % 3) n += (s == 1 || s == -2 ? '0' : '00');\r\n      s = mathpow(n, 1 / 3);\r\n\r\n      // Rarely, e may be one less than the result exponent value.\r\n      e = mathfloor((e + 1) / 3) - (e % 3 == (e < 0 ? -1 : 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 Ctor(n);\r\n      r.s = x.s;\r\n    } else {\r\n      r = new Ctor(s.toString());\r\n    }\r\n\r\n    sd = (e = Ctor.precision) + 3;\r\n\r\n    // Halley's method.\r\n    // TODO? Compare Newton's method.\r\n    for (;;) {\r\n      t = r;\r\n      t3 = t.times(t).times(t);\r\n      t3plusx = t3.plus(x);\r\n      r = divide(t3plusx.plus(x).times(t), t3plusx.plus(t3), sd + 2, 1);\r\n\r\n      // TODO? Replace with for-loop and checkRoundingDigits.\r\n      if (digitsToString(t.d).slice(0, sd) === (n = digitsToString(r.d)).slice(0, sd)) {\r\n        n = n.slice(sd - 3, sd + 1);\r\n\r\n        // The 4th rounding digit may be in error by -1 so if the 4 rounding digits are 9999 or 4999\r\n        // , i.e. approaching a rounding boundary, continue the 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 exact result as the\r\n          // nines may infinitely repeat.\r\n          if (!rep) {\r\n            finalise(t, e + 1, 0);\r\n\r\n            if (t.times(t).times(t).eq(x)) {\r\n              r = t;\r\n              break;\r\n            }\r\n          }\r\n\r\n          sd += 4;\r\n          rep = 1;\r\n        } else {\r\n\r\n          // If the rounding digits are null, 0{0,4} or 50{0,3}, check for an exact result.\r\n          // 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            finalise(r, e + 1, 1);\r\n            m = !r.times(r).times(r).eq(x);\r\n          }\r\n\r\n          break;\r\n        }\r\n      }\r\n    }\r\n\r\n    external = true;\r\n\r\n    return finalise(r, e, Ctor.rounding, m);\r\n  };\r\n\r\n\r\n  /*\r\n   * Return the number of decimal places of the value of this Decimal.\r\n   *\r\n   */\r\n  P.decimalPlaces = P.dp = function () {\r\n    var w,\r\n      d = this.d,\r\n      n = NaN;\r\n\r\n    if (d) {\r\n      w = d.length - 1;\r\n      n = (w - mathfloor(this.e / LOG_BASE)) * LOG_BASE;\r\n\r\n      // Subtract the number of trailing zeros of the last word.\r\n      w = d[w];\r\n      if (w) for (; w % 10 == 0; w /= 10) n--;\r\n      if (n < 0) n = 0;\r\n    }\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 Decimal whose value is the value of this Decimal divided by `y`, rounded to\r\n   * `precision` significant digits using rounding mode `rounding`.\r\n   *\r\n   */\r\n  P.dividedBy = P.div = function (y) {\r\n    return divide(this, new this.constructor(y));\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the integer part of dividing the value of this Decimal\r\n   * by the value of `y`, rounded to `precision` significant digits using rounding mode `rounding`.\r\n   *\r\n   */\r\n  P.dividedToIntegerBy = P.divToInt = function (y) {\r\n    var x = this,\r\n      Ctor = x.constructor;\r\n    return finalise(divide(x, new Ctor(y), 0, 1, 1), Ctor.precision, Ctor.rounding);\r\n  };\r\n\r\n\r\n  /*\r\n   * Return true if the value of this Decimal is equal to the value of `y`, otherwise return false.\r\n   *\r\n   */\r\n  P.equals = P.eq = function (y) {\r\n    return this.cmp(y) === 0;\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the value of this Decimal rounded to a whole number in the\r\n   * direction of negative Infinity.\r\n   *\r\n   */\r\n  P.floor = function () {\r\n    return finalise(new this.constructor(this), this.e + 1, 3);\r\n  };\r\n\r\n\r\n  /*\r\n   * Return true if the value of this Decimal is greater than the value of `y`, otherwise return\r\n   * false.\r\n   *\r\n   */\r\n  P.greaterThan = P.gt = function (y) {\r\n    return this.cmp(y) > 0;\r\n  };\r\n\r\n\r\n  /*\r\n   * Return true if the value of this Decimal is greater than or equal to the value of `y`,\r\n   * otherwise return false.\r\n   *\r\n   */\r\n  P.greaterThanOrEqualTo = P.gte = function (y) {\r\n    var k = this.cmp(y);\r\n    return k == 1 || k === 0;\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the hyperbolic cosine of the value in radians of this\r\n   * Decimal.\r\n   *\r\n   * Domain: [-Infinity, Infinity]\r\n   * Range: [1, Infinity]\r\n   *\r\n   * cosh(x) = 1 + x^2/2! + x^4/4! + x^6/6! + ...\r\n   *\r\n   * cosh(0)         = 1\r\n   * cosh(-0)        = 1\r\n   * cosh(Infinity)  = Infinity\r\n   * cosh(-Infinity) = Infinity\r\n   * cosh(NaN)       = NaN\r\n   *\r\n   *  x        time taken (ms)   result\r\n   * 1000      9                 9.8503555700852349694e+433\r\n   * 10000     25                4.4034091128314607936e+4342\r\n   * 100000    171               1.4033316802130615897e+43429\r\n   * 1000000   3817              1.5166076984010437725e+434294\r\n   * 10000000  abandoned after 2 minute wait\r\n   *\r\n   * TODO? Compare performance of cosh(x) = 0.5 * (exp(x) + exp(-x))\r\n   *\r\n   */\r\n  P.hyperbolicCosine = P.cosh = function () {\r\n    var k, n, pr, rm, len,\r\n      x = this,\r\n      Ctor = x.constructor,\r\n      one = new Ctor(1);\r\n\r\n    if (!x.isFinite()) return new Ctor(x.s ? 1 / 0 : NaN);\r\n    if (x.isZero()) return one;\r\n\r\n    pr = Ctor.precision;\r\n    rm = Ctor.rounding;\r\n    Ctor.precision = pr + Math.max(x.e, x.sd()) + 4;\r\n    Ctor.rounding = 1;\r\n    len = x.d.length;\r\n\r\n    // Argument reduction: cos(4x) = 1 - 8cos^2(x) + 8cos^4(x) + 1\r\n    // i.e. cos(x) = 1 - cos^2(x/4)(8 - 8cos^2(x/4))\r\n\r\n    // Estimate the optimum number of times to use the argument reduction.\r\n    // TODO? Estimation reused from cosine() and may not be optimal here.\r\n    if (len < 32) {\r\n      k = Math.ceil(len / 3);\r\n      n = (1 / tinyPow(4, k)).toString();\r\n    } else {\r\n      k = 16;\r\n      n = '2.3283064365386962890625e-10';\r\n    }\r\n\r\n    x = taylorSeries(Ctor, 1, x.times(n), new Ctor(1), true);\r\n\r\n    // Reverse argument reduction\r\n    var cosh2_x,\r\n      i = k,\r\n      d8 = new Ctor(8);\r\n    for (; i--;) {\r\n      cosh2_x = x.times(x);\r\n      x = one.minus(cosh2_x.times(d8.minus(cosh2_x.times(d8))));\r\n    }\r\n\r\n    return finalise(x, Ctor.precision = pr, Ctor.rounding = rm, true);\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the hyperbolic sine of the value in radians of this\r\n   * Decimal.\r\n   *\r\n   * Domain: [-Infinity, Infinity]\r\n   * Range: [-Infinity, Infinity]\r\n   *\r\n   * sinh(x) = x + x^3/3! + x^5/5! + x^7/7! + ...\r\n   *\r\n   * sinh(0)         = 0\r\n   * sinh(-0)        = -0\r\n   * sinh(Infinity)  = Infinity\r\n   * sinh(-Infinity) = -Infinity\r\n   * sinh(NaN)       = NaN\r\n   *\r\n   * x        time taken (ms)\r\n   * 10       2 ms\r\n   * 100      5 ms\r\n   * 1000     14 ms\r\n   * 10000    82 ms\r\n   * 100000   886 ms            1.4033316802130615897e+43429\r\n   * 200000   2613 ms\r\n   * 300000   5407 ms\r\n   * 400000   8824 ms\r\n   * 500000   13026 ms          8.7080643612718084129e+217146\r\n   * 1000000  48543 ms\r\n   *\r\n   * TODO? Compare performance of sinh(x) = 0.5 * (exp(x) - exp(-x))\r\n   *\r\n   */\r\n  P.hyperbolicSine = P.sinh = function () {\r\n    var k, pr, rm, len,\r\n      x = this,\r\n      Ctor = x.constructor;\r\n\r\n    if (!x.isFinite() || x.isZero()) return new Ctor(x);\r\n\r\n    pr = Ctor.precision;\r\n    rm = Ctor.rounding;\r\n    Ctor.precision = pr + Math.max(x.e, x.sd()) + 4;\r\n    Ctor.rounding = 1;\r\n    len = x.d.length;\r\n\r\n    if (len < 3) {\r\n      x = taylorSeries(Ctor, 2, x, x, true);\r\n    } else {\r\n\r\n      // Alternative argument reduction: sinh(3x) = sinh(x)(3 + 4sinh^2(x))\r\n      // i.e. sinh(x) = sinh(x/3)(3 + 4sinh^2(x/3))\r\n      // 3 multiplications and 1 addition\r\n\r\n      // Argument reduction: sinh(5x) = sinh(x)(5 + sinh^2(x)(20 + 16sinh^2(x)))\r\n      // i.e. sinh(x) = sinh(x/5)(5 + sinh^2(x/5)(20 + 16sinh^2(x/5)))\r\n      // 4 multiplications and 2 additions\r\n\r\n      // Estimate the optimum number of times to use the argument reduction.\r\n      k = 1.4 * Math.sqrt(len);\r\n      k = k > 16 ? 16 : k | 0;\r\n\r\n      x = x.times(1 / tinyPow(5, k));\r\n      x = taylorSeries(Ctor, 2, x, x, true);\r\n\r\n      // Reverse argument reduction\r\n      var sinh2_x,\r\n        d5 = new Ctor(5),\r\n        d16 = new Ctor(16),\r\n        d20 = new Ctor(20);\r\n      for (; k--;) {\r\n        sinh2_x = x.times(x);\r\n        x = x.times(d5.plus(sinh2_x.times(d16.times(sinh2_x).plus(d20))));\r\n      }\r\n    }\r\n\r\n    Ctor.precision = pr;\r\n    Ctor.rounding = rm;\r\n\r\n    return finalise(x, pr, rm, true);\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the hyperbolic tangent of the value in radians of this\r\n   * Decimal.\r\n   *\r\n   * Domain: [-Infinity, Infinity]\r\n   * Range: [-1, 1]\r\n   *\r\n   * tanh(x) = sinh(x) / cosh(x)\r\n   *\r\n   * tanh(0)         = 0\r\n   * tanh(-0)        = -0\r\n   * tanh(Infinity)  = 1\r\n   * tanh(-Infinity) = -1\r\n   * tanh(NaN)       = NaN\r\n   *\r\n   */\r\n  P.hyperbolicTangent = P.tanh = function () {\r\n    var pr, rm,\r\n      x = this,\r\n      Ctor = x.constructor;\r\n\r\n    if (!x.isFinite()) return new Ctor(x.s);\r\n    if (x.isZero()) return new Ctor(x);\r\n\r\n    pr = Ctor.precision;\r\n    rm = Ctor.rounding;\r\n    Ctor.precision = pr + 7;\r\n    Ctor.rounding = 1;\r\n\r\n    return divide(x.sinh(), x.cosh(), Ctor.precision = pr, Ctor.rounding = rm);\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the arccosine (inverse cosine) in radians of the value of\r\n   * this Decimal.\r\n   *\r\n   * Domain: [-1, 1]\r\n   * Range: [0, pi]\r\n   *\r\n   * acos(x) = pi/2 - asin(x)\r\n   *\r\n   * acos(0)       = pi/2\r\n   * acos(-0)      = pi/2\r\n   * acos(1)       = 0\r\n   * acos(-1)      = pi\r\n   * acos(1/2)     = pi/3\r\n   * acos(-1/2)    = 2*pi/3\r\n   * acos(|x| > 1) = NaN\r\n   * acos(NaN)     = NaN\r\n   *\r\n   */\r\n  P.inverseCosine = P.acos = function () {\r\n    var halfPi,\r\n      x = this,\r\n      Ctor = x.constructor,\r\n      k = x.abs().cmp(1),\r\n      pr = Ctor.precision,\r\n      rm = Ctor.rounding;\r\n\r\n    if (k !== -1) {\r\n      return k === 0\r\n        // |x| is 1\r\n        ? x.isNeg() ? getPi(Ctor, pr, rm) : new Ctor(0)\r\n        // |x| > 1 or x is NaN\r\n        : new Ctor(NaN);\r\n    }\r\n\r\n    if (x.isZero()) return getPi(Ctor, pr + 4, rm).times(0.5);\r\n\r\n    // TODO? Special case acos(0.5) = pi/3 and acos(-0.5) = 2*pi/3\r\n\r\n    Ctor.precision = pr + 6;\r\n    Ctor.rounding = 1;\r\n\r\n    x = x.asin();\r\n    halfPi = getPi(Ctor, pr + 4, rm).times(0.5);\r\n\r\n    Ctor.precision = pr;\r\n    Ctor.rounding = rm;\r\n\r\n    return halfPi.minus(x);\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the inverse of the hyperbolic cosine in radians of the\r\n   * value of this Decimal.\r\n   *\r\n   * Domain: [1, Infinity]\r\n   * Range: [0, Infinity]\r\n   *\r\n   * acosh(x) = ln(x + sqrt(x^2 - 1))\r\n   *\r\n   * acosh(x < 1)     = NaN\r\n   * acosh(NaN)       = NaN\r\n   * acosh(Infinity)  = Infinity\r\n   * acosh(-Infinity) = NaN\r\n   * acosh(0)         = NaN\r\n   * acosh(-0)        = NaN\r\n   * acosh(1)         = 0\r\n   * acosh(-1)        = NaN\r\n   *\r\n   */\r\n  P.inverseHyperbolicCosine = P.acosh = function () {\r\n    var pr, rm,\r\n      x = this,\r\n      Ctor = x.constructor;\r\n\r\n    if (x.lte(1)) return new Ctor(x.eq(1) ? 0 : NaN);\r\n    if (!x.isFinite()) return new Ctor(x);\r\n\r\n    pr = Ctor.precision;\r\n    rm = Ctor.rounding;\r\n    Ctor.precision = pr + Math.max(Math.abs(x.e), x.sd()) + 4;\r\n    Ctor.rounding = 1;\r\n    external = false;\r\n\r\n    x = x.times(x).minus(1).sqrt().plus(x);\r\n\r\n    external = true;\r\n    Ctor.precision = pr;\r\n    Ctor.rounding = rm;\r\n\r\n    return x.ln();\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the inverse of the hyperbolic sine in radians of the value\r\n   * of this Decimal.\r\n   *\r\n   * Domain: [-Infinity, Infinity]\r\n   * Range: [-Infinity, Infinity]\r\n   *\r\n   * asinh(x) = ln(x + sqrt(x^2 + 1))\r\n   *\r\n   * asinh(NaN)       = NaN\r\n   * asinh(Infinity)  = Infinity\r\n   * asinh(-Infinity) = -Infinity\r\n   * asinh(0)         = 0\r\n   * asinh(-0)        = -0\r\n   *\r\n   */\r\n  P.inverseHyperbolicSine = P.asinh = function () {\r\n    var pr, rm,\r\n      x = this,\r\n      Ctor = x.constructor;\r\n\r\n    if (!x.isFinite() || x.isZero()) return new Ctor(x);\r\n\r\n    pr = Ctor.precision;\r\n    rm = Ctor.rounding;\r\n    Ctor.precision = pr + 2 * Math.max(Math.abs(x.e), x.sd()) + 6;\r\n    Ctor.rounding = 1;\r\n    external = false;\r\n\r\n    x = x.times(x).plus(1).sqrt().plus(x);\r\n\r\n    external = true;\r\n    Ctor.precision = pr;\r\n    Ctor.rounding = rm;\r\n\r\n    return x.ln();\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the inverse of the hyperbolic tangent in radians of the\r\n   * value of this Decimal.\r\n   *\r\n   * Domain: [-1, 1]\r\n   * Range: [-Infinity, Infinity]\r\n   *\r\n   * atanh(x) = 0.5 * ln((1 + x) / (1 - x))\r\n   *\r\n   * atanh(|x| > 1)   = NaN\r\n   * atanh(NaN)       = NaN\r\n   * atanh(Infinity)  = NaN\r\n   * atanh(-Infinity) = NaN\r\n   * atanh(0)         = 0\r\n   * atanh(-0)        = -0\r\n   * atanh(1)         = Infinity\r\n   * atanh(-1)        = -Infinity\r\n   *\r\n   */\r\n  P.inverseHyperbolicTangent = P.atanh = function () {\r\n    var pr, rm, wpr, xsd,\r\n      x = this,\r\n      Ctor = x.constructor;\r\n\r\n    if (!x.isFinite()) return new Ctor(NaN);\r\n    if (x.e >= 0) return new Ctor(x.abs().eq(1) ? x.s / 0 : x.isZero() ? x : NaN);\r\n\r\n    pr = Ctor.precision;\r\n    rm = Ctor.rounding;\r\n    xsd = x.sd();\r\n\r\n    if (Math.max(xsd, pr) < 2 * -x.e - 1) return finalise(new Ctor(x), pr, rm, true);\r\n\r\n    Ctor.precision = wpr = xsd - x.e;\r\n\r\n    x = divide(x.plus(1), new Ctor(1).minus(x), wpr + pr, 1);\r\n\r\n    Ctor.precision = pr + 4;\r\n    Ctor.rounding = 1;\r\n\r\n    x = x.ln();\r\n\r\n    Ctor.precision = pr;\r\n    Ctor.rounding = rm;\r\n\r\n    return x.times(0.5);\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the arcsine (inverse sine) in radians of the value of this\r\n   * Decimal.\r\n   *\r\n   * Domain: [-Infinity, Infinity]\r\n   * Range: [-pi/2, pi/2]\r\n   *\r\n   * asin(x) = 2*atan(x/(1 + sqrt(1 - x^2)))\r\n   *\r\n   * asin(0)       = 0\r\n   * asin(-0)      = -0\r\n   * asin(1/2)     = pi/6\r\n   * asin(-1/2)    = -pi/6\r\n   * asin(1)       = pi/2\r\n   * asin(-1)      = -pi/2\r\n   * asin(|x| > 1) = NaN\r\n   * asin(NaN)     = NaN\r\n   *\r\n   * TODO? Compare performance of Taylor series.\r\n   *\r\n   */\r\n  P.inverseSine = P.asin = function () {\r\n    var halfPi, k,\r\n      pr, rm,\r\n      x = this,\r\n      Ctor = x.constructor;\r\n\r\n    if (x.isZero()) return new Ctor(x);\r\n\r\n    k = x.abs().cmp(1);\r\n    pr = Ctor.precision;\r\n    rm = Ctor.rounding;\r\n\r\n    if (k !== -1) {\r\n\r\n      // |x| is 1\r\n      if (k === 0) {\r\n        halfPi = getPi(Ctor, pr + 4, rm).times(0.5);\r\n        halfPi.s = x.s;\r\n        return halfPi;\r\n      }\r\n\r\n      // |x| > 1 or x is NaN\r\n      return new Ctor(NaN);\r\n    }\r\n\r\n    // TODO? Special case asin(1/2) = pi/6 and asin(-1/2) = -pi/6\r\n\r\n    Ctor.precision = pr + 6;\r\n    Ctor.rounding = 1;\r\n\r\n    x = x.div(new Ctor(1).minus(x.times(x)).sqrt().plus(1)).atan();\r\n\r\n    Ctor.precision = pr;\r\n    Ctor.rounding = rm;\r\n\r\n    return x.times(2);\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the arctangent (inverse tangent) in radians of the value\r\n   * of this Decimal.\r\n   *\r\n   * Domain: [-Infinity, Infinity]\r\n   * Range: [-pi/2, pi/2]\r\n   *\r\n   * atan(x) = x - x^3/3 + x^5/5 - x^7/7 + ...\r\n   *\r\n   * atan(0)         = 0\r\n   * atan(-0)        = -0\r\n   * atan(1)         = pi/4\r\n   * atan(-1)        = -pi/4\r\n   * atan(Infinity)  = pi/2\r\n   * atan(-Infinity) = -pi/2\r\n   * atan(NaN)       = NaN\r\n   *\r\n   */\r\n  P.inverseTangent = P.atan = function () {\r\n    var i, j, k, n, px, t, r, wpr, x2,\r\n      x = this,\r\n      Ctor = x.constructor,\r\n      pr = Ctor.precision,\r\n      rm = Ctor.rounding;\r\n\r\n    if (!x.isFinite()) {\r\n      if (!x.s) return new Ctor(NaN);\r\n      if (pr + 4 <= PI_PRECISION) {\r\n        r = getPi(Ctor, pr + 4, rm).times(0.5);\r\n        r.s = x.s;\r\n        return r;\r\n      }\r\n    } else if (x.isZero()) {\r\n      return new Ctor(x);\r\n    } else if (x.abs().eq(1) && pr + 4 <= PI_PRECISION) {\r\n      r = getPi(Ctor, pr + 4, rm).times(0.25);\r\n      r.s = x.s;\r\n      return r;\r\n    }\r\n\r\n    Ctor.precision = wpr = pr + 10;\r\n    Ctor.rounding = 1;\r\n\r\n    // TODO? if (x >= 1 && pr <= PI_PRECISION) atan(x) = halfPi * x.s - atan(1 / x);\r\n\r\n    // Argument reduction\r\n    // Ensure |x| < 0.42\r\n    // atan(x) = 2 * atan(x / (1 + sqrt(1 + x^2)))\r\n\r\n    k = Math.min(28, wpr / LOG_BASE + 2 | 0);\r\n\r\n    for (i = k; i; --i) x = x.div(x.times(x).plus(1).sqrt().plus(1));\r\n\r\n    external = false;\r\n\r\n    j = Math.ceil(wpr / LOG_BASE);\r\n    n = 1;\r\n    x2 = x.times(x);\r\n    r = new Ctor(x);\r\n    px = x;\r\n\r\n    // atan(x) = x - x^3/3 + x^5/5 - x^7/7 + ...\r\n    for (; i !== -1;) {\r\n      px = px.times(x2);\r\n      t = r.minus(px.div(n += 2));\r\n\r\n      px = px.times(x2);\r\n      r = t.plus(px.div(n += 2));\r\n\r\n      if (r.d[j] !== void 0) for (i = j; r.d[i] === t.d[i] && i--;);\r\n    }\r\n\r\n    if (k) r = r.times(2 << (k - 1));\r\n\r\n    external = true;\r\n\r\n    return finalise(r, Ctor.precision = pr, Ctor.rounding = rm, true);\r\n  };\r\n\r\n\r\n  /*\r\n   * Return true if the value of this Decimal is a finite number, otherwise return false.\r\n   *\r\n   */\r\n  P.isFinite = function () {\r\n    return !!this.d;\r\n  };\r\n\r\n\r\n  /*\r\n   * Return true if the value of this Decimal is an integer, otherwise return false.\r\n   *\r\n   */\r\n  P.isInteger = P.isInt = function () {\r\n    return !!this.d && mathfloor(this.e / LOG_BASE) > this.d.length - 2;\r\n  };\r\n\r\n\r\n  /*\r\n   * Return true if the value of this Decimal is NaN, otherwise return false.\r\n   *\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 Decimal is negative, otherwise return false.\r\n   *\r\n   */\r\n  P.isNegative = P.isNeg = function () {\r\n    return this.s < 0;\r\n  };\r\n\r\n\r\n  /*\r\n   * Return true if the value of this Decimal is positive, otherwise return false.\r\n   *\r\n   */\r\n  P.isPositive = P.isPos = function () {\r\n    return this.s > 0;\r\n  };\r\n\r\n\r\n  /*\r\n   * Return true if the value of this Decimal is 0 or -0, otherwise return false.\r\n   *\r\n   */\r\n  P.isZero = function () {\r\n    return !!this.d && this.d[0] === 0;\r\n  };\r\n\r\n\r\n  /*\r\n   * Return true if the value of this Decimal is less than `y`, otherwise return false.\r\n   *\r\n   */\r\n  P.lessThan = P.lt = function (y) {\r\n    return this.cmp(y) < 0;\r\n  };\r\n\r\n\r\n  /*\r\n   * Return true if the value of this Decimal is less than or equal to `y`, otherwise return false.\r\n   *\r\n   */\r\n  P.lessThanOrEqualTo = P.lte = function (y) {\r\n    return this.cmp(y) < 1;\r\n  };\r\n\r\n\r\n  /*\r\n   * Return the logarithm of the value of this Decimal to the specified base, rounded to `precision`\r\n   * significant digits using rounding mode `rounding`.\r\n   *\r\n   * If no base is specified, return log[10](arg).\r\n   *\r\n   * log[base](arg) = ln(arg) / ln(base)\r\n   *\r\n   * The result will always be correctly rounded if the base of the log is 10, and 'almost always'\r\n   * otherwise:\r\n   *\r\n   * Depending on the rounding mode, the result may be incorrectly rounded if the first fifteen\r\n   * rounding digits are [49]99999999999999 or [50]00000000000000. In that case, the maximum error\r\n   * between the result and the correctly rounded result will be one ulp (unit in the last place).\r\n   *\r\n   * log[-b](a)       = NaN\r\n   * log[0](a)        = NaN\r\n   * log[1](a)        = NaN\r\n   * log[NaN](a)      = NaN\r\n   * log[Infinity](a) = NaN\r\n   * log[b](0)        = -Infinity\r\n   * log[b](-0)       = -Infinity\r\n   * log[b](-a)       = NaN\r\n   * log[b](1)        = 0\r\n   * log[b](Infinity) = Infinity\r\n   * log[b](NaN)      = NaN\r\n   *\r\n   * [base] {number|string|Decimal} The base of the logarithm.\r\n   *\r\n   */\r\n  P.logarithm = P.log = function (base) {\r\n    var isBase10, d, denominator, k, inf, num, sd, r,\r\n      arg = this,\r\n      Ctor = arg.constructor,\r\n      pr = Ctor.precision,\r\n      rm = Ctor.rounding,\r\n      guard = 5;\r\n\r\n    // Default base is 10.\r\n    if (base == null) {\r\n      base = new Ctor(10);\r\n      isBase10 = true;\r\n    } else {\r\n      base = new Ctor(base);\r\n      d = base.d;\r\n\r\n      // Return NaN if base is negative, or non-finite, or is 0 or 1.\r\n      if (base.s < 0 || !d || !d[0] || base.eq(1)) return new Ctor(NaN);\r\n\r\n      isBase10 = base.eq(10);\r\n    }\r\n\r\n    d = arg.d;\r\n\r\n    // Is arg negative, non-finite, 0 or 1?\r\n    if (arg.s < 0 || !d || !d[0] || arg.eq(1)) {\r\n      return new Ctor(d && !d[0] ? -1 / 0 : arg.s != 1 ? NaN : d ? 0 : 1 / 0);\r\n    }\r\n\r\n    // The result will have a non-terminating decimal expansion if base is 10 and arg is not an\r\n    // integer power of 10.\r\n    if (isBase10) {\r\n      if (d.length > 1) {\r\n        inf = true;\r\n      } else {\r\n        for (k = d[0]; k % 10 === 0;) k /= 10;\r\n        inf = k !== 1;\r\n      }\r\n    }\r\n\r\n    external = false;\r\n    sd = pr + guard;\r\n    num = naturalLogarithm(arg, sd);\r\n    denominator = isBase10 ? getLn10(Ctor, sd + 10) : naturalLogarithm(base, sd);\r\n\r\n    // The result will have 5 rounding digits.\r\n    r = divide(num, denominator, sd, 1);\r\n\r\n    // If at a rounding boundary, i.e. the result's rounding digits are [49]9999 or [50]0000,\r\n    // calculate 10 further digits.\r\n    //\r\n    // If the result is known to have an infinite decimal expansion, repeat this until it is clear\r\n    // that the result is above or below the boundary. Otherwise, if after calculating the 10\r\n    // further digits, the last 14 are nines, round up and assume the result is exact.\r\n    // Also assume the result is exact if the last 14 are zero.\r\n    //\r\n    // Example of a result that will be incorrectly rounded:\r\n    // log[1048576](4503599627370502) = 2.60000000000000009610279511444746...\r\n    // The above result correctly rounded using ROUND_CEIL to 1 decimal place should be 2.7, but it\r\n    // will be given as 2.6 as there are 15 zeros immediately after the requested decimal place, so\r\n    // the exact result would be assumed to be 2.6, which rounded using ROUND_CEIL to 1 decimal\r\n    // place is still 2.6.\r\n    if (checkRoundingDigits(r.d, k = pr, rm)) {\r\n\r\n      do {\r\n        sd += 10;\r\n        num = naturalLogarithm(arg, sd);\r\n        denominator = isBase10 ? getLn10(Ctor, sd + 10) : naturalLogarithm(base, sd);\r\n        r = divide(num, denominator, sd, 1);\r\n\r\n        if (!inf) {\r\n\r\n          // Check for 14 nines from the 2nd rounding digit, as the first may be 4.\r\n          if (+digitsToString(r.d).slice(k + 1, k + 15) + 1 == 1e14) {\r\n            r = finalise(r, pr + 1, 0);\r\n          }\r\n\r\n          break;\r\n        }\r\n      } while (checkRoundingDigits(r.d, k += 10, rm));\r\n    }\r\n\r\n    external = true;\r\n\r\n    return finalise(r, pr, rm);\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the maximum of the arguments and the value of this Decimal.\r\n   *\r\n   * arguments {number|string|Decimal}\r\n   *\r\n  P.max = function () {\r\n    Array.prototype.push.call(arguments, this);\r\n    return maxOrMin(this.constructor, arguments, 'lt');\r\n  };\r\n   */\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the minimum of the arguments and the value of this Decimal.\r\n   *\r\n   * arguments {number|string|Decimal}\r\n   *\r\n  P.min = function () {\r\n    Array.prototype.push.call(arguments, this);\r\n    return maxOrMin(this.constructor, arguments, 'gt');\r\n  };\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 Decimal whose value is the value of this Decimal minus `y`, rounded to `precision`\r\n   * significant digits using rounding mode `rounding`.\r\n   *\r\n   */\r\n  P.minus = P.sub = function (y) {\r\n    var d, e, i, j, k, len, pr, rm, xd, xe, xLTy, yd,\r\n      x = this,\r\n      Ctor = x.constructor;\r\n\r\n    y = new Ctor(y);\r\n\r\n    // If either is not finite...\r\n    if (!x.d || !y.d) {\r\n\r\n      // Return NaN if either is NaN.\r\n      if (!x.s || !y.s) y = new Ctor(NaN);\r\n\r\n      // Return y negated if x is finite and y is ±Infinity.\r\n      else if (x.d) y.s = -y.s;\r\n\r\n      // Return x if y is finite and x is ±Infinity.\r\n      // Return x if both are ±Infinity with different signs.\r\n      // Return NaN if both are ±Infinity with the same sign.\r\n      else y = new Ctor(y.d || x.s !== y.s ? x : NaN);\r\n\r\n      return y;\r\n    }\r\n\r\n    // If signs differ...\r\n    if (x.s != y.s) {\r\n      y.s = -y.s;\r\n      return x.plus(y);\r\n    }\r\n\r\n    xd = x.d;\r\n    yd = y.d;\r\n    pr = Ctor.precision;\r\n    rm = Ctor.rounding;\r\n\r\n    // If either is zero...\r\n    if (!xd[0] || !yd[0]) {\r\n\r\n      // Return y negated if x is zero and y is non-zero.\r\n      if (yd[0]) y.s = -y.s;\r\n\r\n      // Return x if y is zero and x is non-zero.\r\n      else if (xd[0]) y = new Ctor(x);\r\n\r\n      // Return zero if both are zero.\r\n      // From IEEE 754 (2008) 6.3: 0 - 0 = -0 - -0 = -0 when rounding to -Infinity.\r\n      else return new Ctor(rm === 3 ? -0 : 0);\r\n\r\n      return external ? finalise(y, pr, rm) : y;\r\n    }\r\n\r\n    // x and y are finite, non-zero numbers with the same sign.\r\n\r\n    // Calculate base 1e7 exponents.\r\n    e = mathfloor(y.e / LOG_BASE);\r\n    xe = mathfloor(x.e / LOG_BASE);\r\n\r\n    xd = xd.slice();\r\n    k = xe - e;\r\n\r\n    // If base 1e7 exponents differ...\r\n    if (k) {\r\n      xLTy = k < 0;\r\n\r\n      if (xLTy) {\r\n        d = xd;\r\n        k = -k;\r\n        len = yd.length;\r\n      } else {\r\n        d = yd;\r\n        e = xe;\r\n        len = xd.length;\r\n      }\r\n\r\n      // Numbers with massively different exponents would result in a very high number of\r\n      // zeros needing to be prepended, but this can be avoided while still ensuring correct\r\n      // rounding by limiting the number of zeros to `Math.ceil(pr / LOG_BASE) + 2`.\r\n      i = Math.max(Math.ceil(pr / LOG_BASE), len) + 2;\r\n\r\n      if (k > i) {\r\n        k = i;\r\n        d.length = 1;\r\n      }\r\n\r\n      // Prepend zeros to equalise exponents.\r\n      d.reverse();\r\n      for (i = k; i--;) d.push(0);\r\n      d.reverse();\r\n\r\n    // Base 1e7 exponents equal.\r\n    } else {\r\n\r\n      // Check digits to determine which is the bigger number.\r\n\r\n      i = xd.length;\r\n      len = yd.length;\r\n      xLTy = i < len;\r\n      if (xLTy) len = i;\r\n\r\n      for (i = 0; i < len; i++) {\r\n        if (xd[i] != yd[i]) {\r\n          xLTy = xd[i] < yd[i];\r\n          break;\r\n        }\r\n      }\r\n\r\n      k = 0;\r\n    }\r\n\r\n    if (xLTy) {\r\n      d = xd;\r\n      xd = yd;\r\n      yd = d;\r\n      y.s = -y.s;\r\n    }\r\n\r\n    len = xd.length;\r\n\r\n    // Append zeros to `xd` if shorter.\r\n    // Don't add zeros to `yd` if shorter as subtraction only needs to start at `yd` length.\r\n    for (i = yd.length - len; i > 0; --i) xd[len++] = 0;\r\n\r\n    // Subtract yd from xd.\r\n    for (i = yd.length; i > k;) {\r\n\r\n      if (xd[--i] < yd[i]) {\r\n        for (j = i; j && xd[--j] === 0;) xd[j] = BASE - 1;\r\n        --xd[j];\r\n        xd[i] += BASE;\r\n      }\r\n\r\n      xd[i] -= yd[i];\r\n    }\r\n\r\n    // Remove trailing zeros.\r\n    for (; xd[--len] === 0;) xd.pop();\r\n\r\n    // Remove leading zeros and adjust exponent accordingly.\r\n    for (; xd[0] === 0; xd.shift()) --e;\r\n\r\n    // Zero?\r\n    if (!xd[0]) return new Ctor(rm === 3 ? -0 : 0);\r\n\r\n    y.d = xd;\r\n    y.e = getBase10Exponent(xd, e);\r\n\r\n    return external ? finalise(y, pr, rm) : y;\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 Decimal whose value is the value of this Decimal modulo `y`, rounded to\r\n   * `precision` significant digits using rounding mode `rounding`.\r\n   *\r\n   * The result depends on the modulo mode.\r\n   *\r\n   */\r\n  P.modulo = P.mod = function (y) {\r\n    var q,\r\n      x = this,\r\n      Ctor = x.constructor;\r\n\r\n    y = new Ctor(y);\r\n\r\n    // Return NaN if x is ±Infinity or NaN, or y is NaN or ±0.\r\n    if (!x.d || !y.s || y.d && !y.d[0]) return new Ctor(NaN);\r\n\r\n    // Return x if y is ±Infinity or x is ±0.\r\n    if (!y.d || x.d && !x.d[0]) {\r\n      return finalise(new Ctor(x), Ctor.precision, Ctor.rounding);\r\n    }\r\n\r\n    // Prevent rounding of intermediate calculations.\r\n    external = false;\r\n\r\n    if (Ctor.modulo == 9) {\r\n\r\n      // Euclidian division: q = sign(y) * floor(x / abs(y))\r\n      // result = x - q * y    where  0 <= result < abs(y)\r\n      q = divide(x, y.abs(), 0, 3, 1);\r\n      q.s *= y.s;\r\n    } else {\r\n      q = divide(x, y, 0, Ctor.modulo, 1);\r\n    }\r\n\r\n    q = q.times(y);\r\n\r\n    external = true;\r\n\r\n    return x.minus(q);\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the natural exponential of the value of this Decimal,\r\n   * i.e. the base e raised to the power the value of this Decimal, rounded to `precision`\r\n   * significant digits using rounding mode `rounding`.\r\n   *\r\n   */\r\n  P.naturalExponential = P.exp = function () {\r\n    return naturalExponential(this);\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the natural logarithm of the value of this Decimal,\r\n   * rounded to `precision` significant digits using rounding mode `rounding`.\r\n   *\r\n   */\r\n  P.naturalLogarithm = P.ln = function () {\r\n    return naturalLogarithm(this);\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the value of this Decimal negated, i.e. as if multiplied by\r\n   * -1.\r\n   *\r\n   */\r\n  P.negated = P.neg = function () {\r\n    var x = new this.constructor(this);\r\n    x.s = -x.s;\r\n    return finalise(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 Decimal whose value is the value of this Decimal plus `y`, rounded to `precision`\r\n   * significant digits using rounding mode `rounding`.\r\n   *\r\n   */\r\n  P.plus = P.add = function (y) {\r\n    var carry, d, e, i, k, len, pr, rm, xd, yd,\r\n      x = this,\r\n      Ctor = x.constructor;\r\n\r\n    y = new Ctor(y);\r\n\r\n    // If either is not finite...\r\n    if (!x.d || !y.d) {\r\n\r\n      // Return NaN if either is NaN.\r\n      if (!x.s || !y.s) y = new Ctor(NaN);\r\n\r\n      // Return x if y is finite and x is ±Infinity.\r\n      // Return x if both are ±Infinity with the same sign.\r\n      // Return NaN if both are ±Infinity with different signs.\r\n      // Return y if x is finite and y is ±Infinity.\r\n      else if (!x.d) y = new Ctor(y.d || x.s === y.s ? x : NaN);\r\n\r\n      return y;\r\n    }\r\n\r\n     // If signs differ...\r\n    if (x.s != y.s) {\r\n      y.s = -y.s;\r\n      return x.minus(y);\r\n    }\r\n\r\n    xd = x.d;\r\n    yd = y.d;\r\n    pr = Ctor.precision;\r\n    rm = Ctor.rounding;\r\n\r\n    // If either is zero...\r\n    if (!xd[0] || !yd[0]) {\r\n\r\n      // Return x if y is zero.\r\n      // Return y if y is non-zero.\r\n      if (!yd[0]) y = new Ctor(x);\r\n\r\n      return external ? finalise(y, pr, rm) : y;\r\n    }\r\n\r\n    // x and y are finite, non-zero numbers with the same sign.\r\n\r\n    // Calculate base 1e7 exponents.\r\n    k = mathfloor(x.e / LOG_BASE);\r\n    e = mathfloor(y.e / LOG_BASE);\r\n\r\n    xd = xd.slice();\r\n    i = k - e;\r\n\r\n    // If base 1e7 exponents differ...\r\n    if (i) {\r\n\r\n      if (i < 0) {\r\n        d = xd;\r\n        i = -i;\r\n        len = yd.length;\r\n      } else {\r\n        d = yd;\r\n        e = k;\r\n        len = xd.length;\r\n      }\r\n\r\n      // Limit number of zeros prepended to max(ceil(pr / LOG_BASE), len) + 1.\r\n      k = Math.ceil(pr / LOG_BASE);\r\n      len = k > len ? k + 1 : len + 1;\r\n\r\n      if (i > len) {\r\n        i = len;\r\n        d.length = 1;\r\n      }\r\n\r\n      // Prepend zeros to equalise exponents. Note: Faster to use reverse then do unshifts.\r\n      d.reverse();\r\n      for (; i--;) d.push(0);\r\n      d.reverse();\r\n    }\r\n\r\n    len = xd.length;\r\n    i = yd.length;\r\n\r\n    // If yd is longer than xd, swap xd and yd so xd points to the longer array.\r\n    if (len - i < 0) {\r\n      i = len;\r\n      d = yd;\r\n      yd = xd;\r\n      xd = d;\r\n    }\r\n\r\n    // Only start adding at yd.length - 1 as the further digits of xd can be left as they are.\r\n    for (carry = 0; i;) {\r\n      carry = (xd[--i] = xd[i] + yd[i] + carry) / BASE | 0;\r\n      xd[i] %= BASE;\r\n    }\r\n\r\n    if (carry) {\r\n      xd.unshift(carry);\r\n      ++e;\r\n    }\r\n\r\n    // Remove trailing zeros.\r\n    // No need to check for zero, as +x + +y != 0 && -x + -y != 0\r\n    for (len = xd.length; xd[--len] == 0;) xd.pop();\r\n\r\n    y.d = xd;\r\n    y.e = getBase10Exponent(xd, e);\r\n\r\n    return external ? finalise(y, pr, rm) : y;\r\n  };\r\n\r\n\r\n  /*\r\n   * Return the number of significant digits of the value of this Decimal.\r\n   *\r\n   * [z] {boolean|number} Whether to count integer-part trailing zeros: true, false, 1 or 0.\r\n   *\r\n   */\r\n  P.precision = P.sd = function (z) {\r\n    var k,\r\n      x = this;\r\n\r\n    if (z !== void 0 && z !== !!z && z !== 1 && z !== 0) throw Error(invalidArgument + z);\r\n\r\n    if (x.d) {\r\n      k = getPrecision(x.d);\r\n      if (z && x.e + 1 > k) k = x.e + 1;\r\n    } else {\r\n      k = NaN;\r\n    }\r\n\r\n    return k;\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the value of this Decimal rounded to a whole number using\r\n   * rounding mode `rounding`.\r\n   *\r\n   */\r\n  P.round = function () {\r\n    var x = this,\r\n      Ctor = x.constructor;\r\n\r\n    return finalise(new Ctor(x), x.e + 1, Ctor.rounding);\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the sine of the value in radians of this Decimal.\r\n   *\r\n   * Domain: [-Infinity, Infinity]\r\n   * Range: [-1, 1]\r\n   *\r\n   * sin(x) = x - x^3/3! + x^5/5! - ...\r\n   *\r\n   * sin(0)         = 0\r\n   * sin(-0)        = -0\r\n   * sin(Infinity)  = NaN\r\n   * sin(-Infinity) = NaN\r\n   * sin(NaN)       = NaN\r\n   *\r\n   */\r\n  P.sine = P.sin = function () {\r\n    var pr, rm,\r\n      x = this,\r\n      Ctor = x.constructor;\r\n\r\n    if (!x.isFinite()) return new Ctor(NaN);\r\n    if (x.isZero()) return new Ctor(x);\r\n\r\n    pr = Ctor.precision;\r\n    rm = Ctor.rounding;\r\n    Ctor.precision = pr + Math.max(x.e, x.sd()) + LOG_BASE;\r\n    Ctor.rounding = 1;\r\n\r\n    x = sine(Ctor, toLessThanHalfPi(Ctor, x));\r\n\r\n    Ctor.precision = pr;\r\n    Ctor.rounding = rm;\r\n\r\n    return finalise(quadrant > 2 ? x.neg() : x, pr, rm, true);\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the square root of this Decimal, rounded to `precision`\r\n   * significant digits using rounding mode `rounding`.\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   */\r\n  P.squareRoot = P.sqrt = function () {\r\n    var m, n, sd, r, rep, t,\r\n      x = this,\r\n      d = x.d,\r\n      e = x.e,\r\n      s = x.s,\r\n      Ctor = x.constructor;\r\n\r\n    // Negative/NaN/Infinity/zero?\r\n    if (s !== 1 || !d || !d[0]) {\r\n      return new Ctor(!s || s < 0 && (!d || d[0]) ? NaN : d ? x : 1 / 0);\r\n    }\r\n\r\n    external = false;\r\n\r\n    // Initial estimate.\r\n    s = Math.sqrt(+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 = digitsToString(d);\r\n\r\n      if ((n.length + e) % 2 == 0) n += '0';\r\n      s = Math.sqrt(n);\r\n      e = mathfloor((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 Ctor(n);\r\n    } else {\r\n      r = new Ctor(s.toString());\r\n    }\r\n\r\n    sd = (e = Ctor.precision) + 3;\r\n\r\n    // Newton-Raphson iteration.\r\n    for (;;) {\r\n      t = r;\r\n      r = t.plus(divide(x, t, sd + 2, 1)).times(0.5);\r\n\r\n      // TODO? Replace with for-loop and checkRoundingDigits.\r\n      if (digitsToString(t.d).slice(0, sd) === (n = digitsToString(r.d)).slice(0, sd)) {\r\n        n = n.slice(sd - 3, sd + 1);\r\n\r\n        // The 4th rounding digit may be in error by -1 so if the 4 rounding digits are 9999 or\r\n        // 4999, i.e. approaching a rounding boundary, continue the 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 exact result as the\r\n          // nines may infinitely repeat.\r\n          if (!rep) {\r\n            finalise(t, e + 1, 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          sd += 4;\r\n          rep = 1;\r\n        } else {\r\n\r\n          // If the rounding digits are null, 0{0,4} or 50{0,3}, check for an exact result.\r\n          // 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            finalise(r, e + 1, 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    external = true;\r\n\r\n    return finalise(r, e, Ctor.rounding, m);\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the tangent of the value in radians of this Decimal.\r\n   *\r\n   * Domain: [-Infinity, Infinity]\r\n   * Range: [-Infinity, Infinity]\r\n   *\r\n   * tan(0)         = 0\r\n   * tan(-0)        = -0\r\n   * tan(Infinity)  = NaN\r\n   * tan(-Infinity) = NaN\r\n   * tan(NaN)       = NaN\r\n   *\r\n   */\r\n  P.tangent = P.tan = function () {\r\n    var pr, rm,\r\n      x = this,\r\n      Ctor = x.constructor;\r\n\r\n    if (!x.isFinite()) return new Ctor(NaN);\r\n    if (x.isZero()) return new Ctor(x);\r\n\r\n    pr = Ctor.precision;\r\n    rm = Ctor.rounding;\r\n    Ctor.precision = pr + 10;\r\n    Ctor.rounding = 1;\r\n\r\n    x = x.sin();\r\n    x.s = 1;\r\n    x = divide(x, new Ctor(1).minus(x.times(x)).sqrt(), pr + 10, 0);\r\n\r\n    Ctor.precision = pr;\r\n    Ctor.rounding = rm;\r\n\r\n    return finalise(quadrant == 2 || quadrant == 4 ? x.neg() : x, pr, rm, true);\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 Decimal whose value is this Decimal times `y`, rounded to `precision` significant\r\n   * digits using rounding mode `rounding`.\r\n   *\r\n   */\r\n  P.times = P.mul = function (y) {\r\n    var carry, e, i, k, r, rL, t, xdL, ydL,\r\n      x = this,\r\n      Ctor = x.constructor,\r\n      xd = x.d,\r\n      yd = (y = new Ctor(y)).d;\r\n\r\n    y.s *= x.s;\r\n\r\n     // If either is NaN, ±Infinity or ±0...\r\n    if (!xd || !xd[0] || !yd || !yd[0]) {\r\n\r\n      return new Ctor(!y.s || xd && !xd[0] && !yd || yd && !yd[0] && !xd\r\n\r\n        // Return NaN if either is NaN.\r\n        // Return NaN if x is ±0 and y is ±Infinity, or y is ±0 and x is ±Infinity.\r\n        ? NaN\r\n\r\n        // Return ±Infinity if either is ±Infinity.\r\n        // Return ±0 if either is ±0.\r\n        : !xd || !yd ? y.s / 0 : y.s * 0);\r\n    }\r\n\r\n    e = mathfloor(x.e / LOG_BASE) + mathfloor(y.e / LOG_BASE);\r\n    xdL = xd.length;\r\n    ydL = yd.length;\r\n\r\n    // Ensure xd points to the longer array.\r\n    if (xdL < ydL) {\r\n      r = xd;\r\n      xd = yd;\r\n      yd = r;\r\n      rL = xdL;\r\n      xdL = ydL;\r\n      ydL = rL;\r\n    }\r\n\r\n    // Initialise the result array with zeros.\r\n    r = [];\r\n    rL = xdL + ydL;\r\n    for (i = rL; i--;) r.push(0);\r\n\r\n    // Multiply!\r\n    for (i = ydL; --i >= 0;) {\r\n      carry = 0;\r\n      for (k = xdL + i; k > i;) {\r\n        t = r[k] + yd[i] * xd[k - i - 1] + carry;\r\n        r[k--] = t % BASE | 0;\r\n        carry = t / BASE | 0;\r\n      }\r\n\r\n      r[k] = (r[k] + carry) % BASE | 0;\r\n    }\r\n\r\n    // Remove trailing zeros.\r\n    for (; !r[--rL];) r.pop();\r\n\r\n    if (carry) ++e;\r\n    else r.shift();\r\n\r\n    y.d = r;\r\n    y.e = getBase10Exponent(r, e);\r\n\r\n    return external ? finalise(y, Ctor.precision, Ctor.rounding) : y;\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a string representing the value of this Decimal in base 2, round to `sd` significant\r\n   * digits using rounding mode `rm`.\r\n   *\r\n   * If the optional `sd` argument is present then return binary exponential notation.\r\n   *\r\n   * [sd] {number} Significant digits. Integer, 1 to MAX_DIGITS inclusive.\r\n   * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n   *\r\n   */\r\n  P.toBinary = function (sd, rm) {\r\n    return toStringBinary(this, 2, sd, rm);\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the value of this Decimal rounded to a maximum of `dp`\r\n   * decimal places using rounding mode `rm` or `rounding` if `rm` is omitted.\r\n   *\r\n   * If `dp` is omitted, return a new Decimal whose value is the value of this Decimal.\r\n   *\r\n   * [dp] {number} Decimal places. Integer, 0 to MAX_DIGITS inclusive.\r\n   * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n   *\r\n   */\r\n  P.toDecimalPlaces = P.toDP = function (dp, rm) {\r\n    var x = this,\r\n      Ctor = x.constructor;\r\n\r\n    x = new Ctor(x);\r\n    if (dp === void 0) return x;\r\n\r\n    checkInt32(dp, 0, MAX_DIGITS);\r\n\r\n    if (rm === void 0) rm = Ctor.rounding;\r\n    else checkInt32(rm, 0, 8);\r\n\r\n    return finalise(x, dp + x.e + 1, rm);\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a string representing the value of this Decimal in exponential notation rounded to\r\n   * `dp` fixed decimal places using rounding mode `rounding`.\r\n   *\r\n   * [dp] {number} Decimal places. Integer, 0 to MAX_DIGITS inclusive.\r\n   * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n   *\r\n   */\r\n  P.toExponential = function (dp, rm) {\r\n    var str,\r\n      x = this,\r\n      Ctor = x.constructor;\r\n\r\n    if (dp === void 0) {\r\n      str = finiteToString(x, true);\r\n    } else {\r\n      checkInt32(dp, 0, MAX_DIGITS);\r\n\r\n      if (rm === void 0) rm = Ctor.rounding;\r\n      else checkInt32(rm, 0, 8);\r\n\r\n      x = finalise(new Ctor(x), dp + 1, rm);\r\n      str = finiteToString(x, true, dp + 1);\r\n    }\r\n\r\n    return x.isNeg() && !x.isZero() ? '-' + str : str;\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a string representing the value of this Decimal in normal (fixed-point) notation to\r\n   * `dp` fixed decimal places and rounded using rounding mode `rm` or `rounding` if `rm` is\r\n   * omitted.\r\n   *\r\n   * As with JavaScript numbers, (-0).toFixed(0) is '0', but e.g. (-0.00001).toFixed(0) is '-0'.\r\n   *\r\n   * [dp] {number} Decimal places. Integer, 0 to MAX_DIGITS inclusive.\r\n   * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n   *\r\n   * (-0).toFixed(0) is '0', but (-0.1).toFixed(0) is '-0'.\r\n   * (-0).toFixed(1) is '0.0', but (-0.01).toFixed(1) is '-0.0'.\r\n   * (-0).toFixed(3) is '0.000'.\r\n   * (-0.5).toFixed(0) is '-0'.\r\n   *\r\n   */\r\n  P.toFixed = function (dp, rm) {\r\n    var str, y,\r\n      x = this,\r\n      Ctor = x.constructor;\r\n\r\n    if (dp === void 0) {\r\n      str = finiteToString(x);\r\n    } else {\r\n      checkInt32(dp, 0, MAX_DIGITS);\r\n\r\n      if (rm === void 0) rm = Ctor.rounding;\r\n      else checkInt32(rm, 0, 8);\r\n\r\n      y = finalise(new Ctor(x), dp + x.e + 1, rm);\r\n      str = finiteToString(y, false, dp + y.e + 1);\r\n    }\r\n\r\n    // To determine whether to add the minus sign look at the value before it was rounded,\r\n    // i.e. look at `x` rather than `y`.\r\n    return x.isNeg() && !x.isZero() ? '-' + str : str;\r\n  };\r\n\r\n\r\n  /*\r\n   * Return an array representing the value of this Decimal as a simple fraction with an integer\r\n   * numerator and an integer denominator.\r\n   *\r\n   * The denominator will be a positive non-zero value less than or equal to the specified maximum\r\n   * denominator. If a maximum denominator is not specified, the denominator will be the lowest\r\n   * value necessary to represent the number exactly.\r\n   *\r\n   * [maxD] {number|string|Decimal} Maximum denominator. Integer >= 1 and < Infinity.\r\n   *\r\n   */\r\n  P.toFraction = function (maxD) {\r\n    var d, d0, d1, d2, e, k, n, n0, n1, pr, q, r,\r\n      x = this,\r\n      xd = x.d,\r\n      Ctor = x.constructor;\r\n\r\n    if (!xd) return new Ctor(x);\r\n\r\n    n1 = d0 = new Ctor(1);\r\n    d1 = n0 = new Ctor(0);\r\n\r\n    d = new Ctor(d1);\r\n    e = d.e = getPrecision(xd) - x.e - 1;\r\n    k = e % LOG_BASE;\r\n    d.d[0] = mathpow(10, k < 0 ? LOG_BASE + k : k);\r\n\r\n    if (maxD == null) {\r\n\r\n      // d is 10**e, the minimum max-denominator needed.\r\n      maxD = e > 0 ? d : n1;\r\n    } else {\r\n      n = new Ctor(maxD);\r\n      if (!n.isInt() || n.lt(n1)) throw Error(invalidArgument + n);\r\n      maxD = n.gt(d) ? (e > 0 ? d : n1) : n;\r\n    }\r\n\r\n    external = false;\r\n    n = new Ctor(digitsToString(xd));\r\n    pr = Ctor.precision;\r\n    Ctor.precision = e = xd.length * LOG_BASE * 2;\r\n\r\n    for (;;)  {\r\n      q = divide(n, d, 0, 1, 1);\r\n      d2 = d0.plus(q.times(d1));\r\n      if (d2.cmp(maxD) == 1) break;\r\n      d0 = d1;\r\n      d1 = d2;\r\n      d2 = n1;\r\n      n1 = n0.plus(q.times(d2));\r\n      n0 = d2;\r\n      d2 = d;\r\n      d = n.minus(q.times(d2));\r\n      n = d2;\r\n    }\r\n\r\n    d2 = divide(maxD.minus(d0), d1, 0, 1, 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\r\n    // Determine which fraction is closer to x, n0/d0 or n1/d1?\r\n    r = divide(n1, d1, e, 1).minus(x).abs().cmp(divide(n0, d0, e, 1).minus(x).abs()) < 1\r\n        ? [n1, d1] : [n0, d0];\r\n\r\n    Ctor.precision = pr;\r\n    external = true;\r\n\r\n    return r;\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a string representing the value of this Decimal in base 16, round to `sd` significant\r\n   * digits using rounding mode `rm`.\r\n   *\r\n   * If the optional `sd` argument is present then return binary exponential notation.\r\n   *\r\n   * [sd] {number} Significant digits. Integer, 1 to MAX_DIGITS inclusive.\r\n   * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n   *\r\n   */\r\n  P.toHexadecimal = P.toHex = function (sd, rm) {\r\n    return toStringBinary(this, 16, sd, rm);\r\n  };\r\n\r\n\r\n  /*\r\n   * Returns a new Decimal whose value is the nearest multiple of `y` in the direction of rounding\r\n   * mode `rm`, or `Decimal.rounding` if `rm` is omitted, to the value of this Decimal.\r\n   *\r\n   * The return value will always have the same sign as this Decimal, unless either this Decimal\r\n   * or `y` is NaN, in which case the return value will be also be NaN.\r\n   *\r\n   * The return value is not affected by the value of `precision`.\r\n   *\r\n   * y {number|string|Decimal} The magnitude to round to a multiple of.\r\n   * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n   *\r\n   * 'toNearest() rounding mode not an integer: {rm}'\r\n   * 'toNearest() rounding mode out of range: {rm}'\r\n   *\r\n   */\r\n  P.toNearest = function (y, rm) {\r\n    var x = this,\r\n      Ctor = x.constructor;\r\n\r\n    x = new Ctor(x);\r\n\r\n    if (y == null) {\r\n\r\n      // If x is not finite, return x.\r\n      if (!x.d) return x;\r\n\r\n      y = new Ctor(1);\r\n      rm = Ctor.rounding;\r\n    } else {\r\n      y = new Ctor(y);\r\n      if (rm === void 0) {\r\n        rm = Ctor.rounding;\r\n      } else {\r\n        checkInt32(rm, 0, 8);\r\n      }\r\n\r\n      // If x is not finite, return x if y is not NaN, else NaN.\r\n      if (!x.d) return y.s ? x : y;\r\n\r\n      // If y is not finite, return Infinity with the sign of x if y is Infinity, else NaN.\r\n      if (!y.d) {\r\n        if (y.s) y.s = x.s;\r\n        return y;\r\n      }\r\n    }\r\n\r\n    // If y is not zero, calculate the nearest multiple of y to x.\r\n    if (y.d[0]) {\r\n      external = false;\r\n      x = divide(x, y, 0, rm, 1).times(y);\r\n      external = true;\r\n      finalise(x);\r\n\r\n    // If y is zero, return zero with the sign of x.\r\n    } else {\r\n      y.s = x.s;\r\n      x = y;\r\n    }\r\n\r\n    return x;\r\n  };\r\n\r\n\r\n  /*\r\n   * Return the value of this Decimal converted to a number primitive.\r\n   * Zero keeps its sign.\r\n   *\r\n   */\r\n  P.toNumber = function () {\r\n    return +this;\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a string representing the value of this Decimal in base 8, round to `sd` significant\r\n   * digits using rounding mode `rm`.\r\n   *\r\n   * If the optional `sd` argument is present then return binary exponential notation.\r\n   *\r\n   * [sd] {number} Significant digits. Integer, 1 to MAX_DIGITS inclusive.\r\n   * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n   *\r\n   */\r\n  P.toOctal = function (sd, rm) {\r\n    return toStringBinary(this, 8, sd, rm);\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the value of this Decimal raised to the power `y`, rounded\r\n   * to `precision` significant digits using rounding mode `rounding`.\r\n   *\r\n   * ECMAScript compliant.\r\n   *\r\n   *   pow(x, NaN)                           = NaN\r\n   *   pow(x, ±0)                            = 1\r\n\r\n   *   pow(NaN, non-zero)                    = NaN\r\n   *   pow(abs(x) > 1, +Infinity)            = +Infinity\r\n   *   pow(abs(x) > 1, -Infinity)            = +0\r\n   *   pow(abs(x) == 1, ±Infinity)           = NaN\r\n   *   pow(abs(x) < 1, +Infinity)            = +0\r\n   *   pow(abs(x) < 1, -Infinity)            = +Infinity\r\n   *   pow(+Infinity, y > 0)                 = +Infinity\r\n   *   pow(+Infinity, y < 0)                 = +0\r\n   *   pow(-Infinity, odd integer > 0)       = -Infinity\r\n   *   pow(-Infinity, even integer > 0)      = +Infinity\r\n   *   pow(-Infinity, odd integer < 0)       = -0\r\n   *   pow(-Infinity, even integer < 0)      = +0\r\n   *   pow(+0, y > 0)                        = +0\r\n   *   pow(+0, y < 0)                        = +Infinity\r\n   *   pow(-0, odd integer > 0)              = -0\r\n   *   pow(-0, even integer > 0)             = +0\r\n   *   pow(-0, odd integer < 0)              = -Infinity\r\n   *   pow(-0, even integer < 0)             = +Infinity\r\n   *   pow(finite x < 0, finite non-integer) = NaN\r\n   *\r\n   * For non-integer or very large exponents pow(x, y) is calculated using\r\n   *\r\n   *   x^y = exp(y*ln(x))\r\n   *\r\n   * Assuming the first 15 rounding digits are each equally likely to be any digit 0-9, the\r\n   * probability of an incorrectly rounded result\r\n   * P([49]9{14} | [50]0{14}) = 2 * 0.2 * 10^-14 = 4e-15 = 1/2.5e+14\r\n   * i.e. 1 in 250,000,000,000,000\r\n   *\r\n   * If a result is incorrectly rounded the maximum error will be 1 ulp (unit in last place).\r\n   *\r\n   * y {number|string|Decimal} The power to which to raise this Decimal.\r\n   *\r\n   */\r\n  P.toPower = P.pow = function (y) {\r\n    var e, k, pr, r, rm, s,\r\n      x = this,\r\n      Ctor = x.constructor,\r\n      yn = +(y = new Ctor(y));\r\n\r\n    // Either ±Infinity, NaN or ±0?\r\n    if (!x.d || !y.d || !x.d[0] || !y.d[0]) return new Ctor(mathpow(+x, yn));\r\n\r\n    x = new Ctor(x);\r\n\r\n    if (x.eq(1)) return x;\r\n\r\n    pr = Ctor.precision;\r\n    rm = Ctor.rounding;\r\n\r\n    if (y.eq(1)) return finalise(x, pr, rm);\r\n\r\n    // y exponent\r\n    e = mathfloor(y.e / LOG_BASE);\r\n\r\n    // If y is a small integer use the 'exponentiation by squaring' algorithm.\r\n    if (e >= y.d.length - 1 && (k = yn < 0 ? -yn : yn) <= MAX_SAFE_INTEGER) {\r\n      r = intPow(Ctor, x, k, pr);\r\n      return y.s < 0 ? new Ctor(1).div(r) : finalise(r, pr, rm);\r\n    }\r\n\r\n    s = x.s;\r\n\r\n    // if x is negative\r\n    if (s < 0) {\r\n\r\n      // if y is not an integer\r\n      if (e < y.d.length - 1) return new Ctor(NaN);\r\n\r\n      // Result is positive if x is negative and the last digit of integer y is even.\r\n      if ((y.d[e] & 1) == 0) s = 1;\r\n\r\n      // if x.eq(-1)\r\n      if (x.e == 0 && x.d[0] == 1 && x.d.length == 1) {\r\n        x.s = s;\r\n        return x;\r\n      }\r\n    }\r\n\r\n    // Estimate result exponent.\r\n    // x^y = 10^e,  where e = y * log10(x)\r\n    // log10(x) = log10(x_significand) + x_exponent\r\n    // log10(x_significand) = ln(x_significand) / ln(10)\r\n    k = mathpow(+x, yn);\r\n    e = k == 0 || !isFinite(k)\r\n      ? mathfloor(yn * (Math.log('0.' + digitsToString(x.d)) / Math.LN10 + x.e + 1))\r\n      : new Ctor(k + '').e;\r\n\r\n    // Exponent estimate may be incorrect e.g. x: 0.999999999999999999, y: 2.29, e: 0, r.e: -1.\r\n\r\n    // Overflow/underflow?\r\n    if (e > Ctor.maxE + 1 || e < Ctor.minE - 1) return new Ctor(e > 0 ? s / 0 : 0);\r\n\r\n    external = false;\r\n    Ctor.rounding = x.s = 1;\r\n\r\n    // Estimate the extra guard digits needed to ensure five correct rounding digits from\r\n    // naturalLogarithm(x). Example of failure without these extra digits (precision: 10):\r\n    // new Decimal(2.32456).pow('2087987436534566.46411')\r\n    // should be 1.162377823e+764914905173815, but is 1.162355823e+764914905173815\r\n    k = Math.min(12, (e + '').length);\r\n\r\n    // r = x^y = exp(y*ln(x))\r\n    r = naturalExponential(y.times(naturalLogarithm(x, pr + k)), pr);\r\n\r\n    // r may be Infinity, e.g. (0.9999999999999999).pow(-1e+40)\r\n    if (r.d) {\r\n\r\n      // Truncate to the required precision plus five rounding digits.\r\n      r = finalise(r, pr + 5, 1);\r\n\r\n      // If the rounding digits are [49]9999 or [50]0000 increase the precision by 10 and recalculate\r\n      // the result.\r\n      if (checkRoundingDigits(r.d, pr, rm)) {\r\n        e = pr + 10;\r\n\r\n        // Truncate to the increased precision plus five rounding digits.\r\n        r = finalise(naturalExponential(y.times(naturalLogarithm(x, e + k)), e), e + 5, 1);\r\n\r\n        // Check for 14 nines from the 2nd rounding digit (the first rounding digit may be 4 or 9).\r\n        if (+digitsToString(r.d).slice(pr + 1, pr + 15) + 1 == 1e14) {\r\n          r = finalise(r, pr + 1, 0);\r\n        }\r\n      }\r\n    }\r\n\r\n    r.s = s;\r\n    external = true;\r\n    Ctor.rounding = rm;\r\n\r\n    return finalise(r, pr, rm);\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a string representing the value of this Decimal rounded to `sd` significant digits\r\n   * using rounding mode `rounding`.\r\n   *\r\n   * Return exponential notation if `sd` is less than the number of digits necessary to represent\r\n   * the integer part of the value in normal notation.\r\n   *\r\n   * [sd] {number} Significant digits. Integer, 1 to MAX_DIGITS inclusive.\r\n   * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n   *\r\n   */\r\n  P.toPrecision = function (sd, rm) {\r\n    var str,\r\n      x = this,\r\n      Ctor = x.constructor;\r\n\r\n    if (sd === void 0) {\r\n      str = finiteToString(x, x.e <= Ctor.toExpNeg || x.e >= Ctor.toExpPos);\r\n    } else {\r\n      checkInt32(sd, 1, MAX_DIGITS);\r\n\r\n      if (rm === void 0) rm = Ctor.rounding;\r\n      else checkInt32(rm, 0, 8);\r\n\r\n      x = finalise(new Ctor(x), sd, rm);\r\n      str = finiteToString(x, sd <= x.e || x.e <= Ctor.toExpNeg, sd);\r\n    }\r\n\r\n    return x.isNeg() && !x.isZero() ? '-' + str : str;\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the value of this Decimal rounded to a maximum of `sd`\r\n   * significant digits using rounding mode `rm`, or to `precision` and `rounding` respectively if\r\n   * omitted.\r\n   *\r\n   * [sd] {number} Significant digits. Integer, 1 to MAX_DIGITS inclusive.\r\n   * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n   *\r\n   * 'toSD() digits out of range: {sd}'\r\n   * 'toSD() digits not an integer: {sd}'\r\n   * 'toSD() rounding mode not an integer: {rm}'\r\n   * 'toSD() rounding mode out of range: {rm}'\r\n   *\r\n   */\r\n  P.toSignificantDigits = P.toSD = function (sd, rm) {\r\n    var x = this,\r\n      Ctor = x.constructor;\r\n\r\n    if (sd === void 0) {\r\n      sd = Ctor.precision;\r\n      rm = Ctor.rounding;\r\n    } else {\r\n      checkInt32(sd, 1, MAX_DIGITS);\r\n\r\n      if (rm === void 0) rm = Ctor.rounding;\r\n      else checkInt32(rm, 0, 8);\r\n    }\r\n\r\n    return finalise(new Ctor(x), sd, rm);\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a string representing the value of this Decimal.\r\n   *\r\n   * Return exponential notation if this Decimal has a positive exponent equal to or greater than\r\n   * `toExpPos`, or a negative exponent equal to or less than `toExpNeg`.\r\n   *\r\n   */\r\n  P.toString = function () {\r\n    var x = this,\r\n      Ctor = x.constructor,\r\n      str = finiteToString(x, x.e <= Ctor.toExpNeg || x.e >= Ctor.toExpPos);\r\n\r\n    return x.isNeg() && !x.isZero() ? '-' + str : str;\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the value of this Decimal truncated to a whole number.\r\n   *\r\n   */\r\n  P.truncated = P.trunc = function () {\r\n    return finalise(new this.constructor(this), this.e + 1, 1);\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a string representing the value of this Decimal.\r\n   * Unlike `toString`, negative zero will include the minus sign.\r\n   *\r\n   */\r\n  P.valueOf = P.toJSON = function () {\r\n    var x = this,\r\n      Ctor = x.constructor,\r\n      str = finiteToString(x, x.e <= Ctor.toExpNeg || x.e >= Ctor.toExpPos);\r\n\r\n    return x.isNeg() ? '-' + str : str;\r\n  };\r\n\r\n\r\n  // Helper functions for Decimal.prototype (P) and/or Decimal methods, and their callers.\r\n\r\n\r\n  /*\r\n   *  digitsToString           P.cubeRoot, P.logarithm, P.squareRoot, P.toFraction, P.toPower,\r\n   *                           finiteToString, naturalExponential, naturalLogarithm\r\n   *  checkInt32               P.toDecimalPlaces, P.toExponential, P.toFixed, P.toNearest,\r\n   *                           P.toPrecision, P.toSignificantDigits, toStringBinary, random\r\n   *  checkRoundingDigits      P.logarithm, P.toPower, naturalExponential, naturalLogarithm\r\n   *  convertBase              toStringBinary, parseOther\r\n   *  cos                      P.cos\r\n   *  divide                   P.atanh, P.cubeRoot, P.dividedBy, P.dividedToIntegerBy,\r\n   *                           P.logarithm, P.modulo, P.squareRoot, P.tan, P.tanh, P.toFraction,\r\n   *                           P.toNearest, toStringBinary, naturalExponential, naturalLogarithm,\r\n   *                           taylorSeries, atan2, parseOther\r\n   *  finalise                 P.absoluteValue, P.atan, P.atanh, P.ceil, P.cos, P.cosh,\r\n   *                           P.cubeRoot, P.dividedToIntegerBy, P.floor, P.logarithm, P.minus,\r\n   *                           P.modulo, P.negated, P.plus, P.round, P.sin, P.sinh, P.squareRoot,\r\n   *                           P.tan, P.times, P.toDecimalPlaces, P.toExponential, P.toFixed,\r\n   *                           P.toNearest, P.toPower, P.toPrecision, P.toSignificantDigits,\r\n   *                           P.truncated, divide, getLn10, getPi, naturalExponential,\r\n   *                           naturalLogarithm, ceil, floor, round, trunc\r\n   *  finiteToString           P.toExponential, P.toFixed, P.toPrecision, P.toString, P.valueOf,\r\n   *                           toStringBinary\r\n   *  getBase10Exponent        P.minus, P.plus, P.times, parseOther\r\n   *  getLn10                  P.logarithm, naturalLogarithm\r\n   *  getPi                    P.acos, P.asin, P.atan, toLessThanHalfPi, atan2\r\n   *  getPrecision             P.precision, P.toFraction\r\n   *  getZeroString            digitsToString, finiteToString\r\n   *  intPow                   P.toPower, parseOther\r\n   *  isOdd                    toLessThanHalfPi\r\n   *  maxOrMin                 max, min\r\n   *  naturalExponential       P.naturalExponential, P.toPower\r\n   *  naturalLogarithm         P.acosh, P.asinh, P.atanh, P.logarithm, P.naturalLogarithm,\r\n   *                           P.toPower, naturalExponential\r\n   *  nonFiniteToString        finiteToString, toStringBinary\r\n   *  parseDecimal             Decimal\r\n   *  parseOther               Decimal\r\n   *  sin                      P.sin\r\n   *  taylorSeries             P.cosh, P.sinh, cos, sin\r\n   *  toLessThanHalfPi         P.cos, P.sin\r\n   *  toStringBinary           P.toBinary, P.toHexadecimal, P.toOctal\r\n   *  truncate                 intPow\r\n   *\r\n   *  Throws:                  P.logarithm, P.precision, P.toFraction, checkInt32, getLn10, getPi,\r\n   *                           naturalLogarithm, config, parseOther, random, Decimal\r\n   */\r\n\r\n\r\n  function digitsToString(d) {\r\n    var i, k, ws,\r\n      indexOfLastWord = d.length - 1,\r\n      str = '',\r\n      w = d[0];\r\n\r\n    if (indexOfLastWord > 0) {\r\n      str += w;\r\n      for (i = 1; i < indexOfLastWord; i++) {\r\n        ws = d[i] + '';\r\n        k = LOG_BASE - ws.length;\r\n        if (k) str += getZeroString(k);\r\n        str += ws;\r\n      }\r\n\r\n      w = d[i];\r\n      ws = w + '';\r\n      k = LOG_BASE - ws.length;\r\n      if (k) str += getZeroString(k);\r\n    } else if (w === 0) {\r\n      return '0';\r\n    }\r\n\r\n    // Remove trailing zeros of last w.\r\n    for (; w % 10 === 0;) w /= 10;\r\n\r\n    return str + w;\r\n  }\r\n\r\n\r\n  function checkInt32(i, min, max) {\r\n    if (i !== ~~i || i < min || i > max) {\r\n      throw Error(invalidArgument + i);\r\n    }\r\n  }\r\n\r\n\r\n  /*\r\n   * Check 5 rounding digits if `repeating` is null, 4 otherwise.\r\n   * `repeating == null` if caller is `log` or `pow`,\r\n   * `repeating != null` if caller is `naturalLogarithm` or `naturalExponential`.\r\n   */\r\n  function checkRoundingDigits(d, i, rm, repeating) {\r\n    var di, k, r, rd;\r\n\r\n    // Get the length of the first word of the array d.\r\n    for (k = d[0]; k >= 10; k /= 10) --i;\r\n\r\n    // Is the rounding digit in the first word of d?\r\n    if (--i < 0) {\r\n      i += LOG_BASE;\r\n      di = 0;\r\n    } else {\r\n      di = Math.ceil((i + 1) / LOG_BASE);\r\n      i %= LOG_BASE;\r\n    }\r\n\r\n    // i is the index (0 - 6) of the rounding digit.\r\n    // E.g. if within the word 3487563 the first rounding digit is 5,\r\n    // then i = 4, k = 1000, rd = 3487563 % 1000 = 563\r\n    k = mathpow(10, LOG_BASE - i);\r\n    rd = d[di] % k | 0;\r\n\r\n    if (repeating == null) {\r\n      if (i < 3) {\r\n        if (i == 0) rd = rd / 100 | 0;\r\n        else if (i == 1) rd = rd / 10 | 0;\r\n        r = rm < 4 && rd == 99999 || rm > 3 && rd == 49999 || rd == 50000 || rd == 0;\r\n      } else {\r\n        r = (rm < 4 && rd + 1 == k || rm > 3 && rd + 1 == k / 2) &&\r\n          (d[di + 1] / k / 100 | 0) == mathpow(10, i - 2) - 1 ||\r\n            (rd == k / 2 || rd == 0) && (d[di + 1] / k / 100 | 0) == 0;\r\n      }\r\n    } else {\r\n      if (i < 4) {\r\n        if (i == 0) rd = rd / 1000 | 0;\r\n        else if (i == 1) rd = rd / 100 | 0;\r\n        else if (i == 2) rd = rd / 10 | 0;\r\n        r = (repeating || rm < 4) && rd == 9999 || !repeating && rm > 3 && rd == 4999;\r\n      } else {\r\n        r = ((repeating || rm < 4) && rd + 1 == k ||\r\n        (!repeating && rm > 3) && rd + 1 == k / 2) &&\r\n          (d[di + 1] / k / 1000 | 0) == mathpow(10, i - 3) - 1;\r\n      }\r\n    }\r\n\r\n    return r;\r\n  }\r\n\r\n\r\n  // Convert string of `baseIn` to an array of numbers of `baseOut`.\r\n  // Eg. convertBase('255', 10, 16) returns [15, 15].\r\n  // Eg. convertBase('ff', 16, 10) returns [2, 5, 5].\r\n  function convertBase(str, baseIn, baseOut) {\r\n    var j,\r\n      arr = [0],\r\n      arrL,\r\n      i = 0,\r\n      strL = str.length;\r\n\r\n    for (; i < strL;) {\r\n      for (arrL = arr.length; arrL--;) arr[arrL] *= baseIn;\r\n      arr[0] += NUMERALS.indexOf(str.charAt(i++));\r\n      for (j = 0; j < arr.length; j++) {\r\n        if (arr[j] > baseOut - 1) {\r\n          if (arr[j + 1] === void 0) 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\r\n  /*\r\n   * cos(x) = 1 - x^2/2! + x^4/4! - ...\r\n   * |x| < pi/2\r\n   *\r\n   */\r\n  function cosine(Ctor, x) {\r\n    var k, len, y;\r\n\r\n    if (x.isZero()) return x;\r\n\r\n    // Argument reduction: cos(4x) = 8*(cos^4(x) - cos^2(x)) + 1\r\n    // i.e. cos(x) = 8*(cos^4(x/4) - cos^2(x/4)) + 1\r\n\r\n    // Estimate the optimum number of times to use the argument reduction.\r\n    len = x.d.length;\r\n    if (len < 32) {\r\n      k = Math.ceil(len / 3);\r\n      y = (1 / tinyPow(4, k)).toString();\r\n    } else {\r\n      k = 16;\r\n      y = '2.3283064365386962890625e-10';\r\n    }\r\n\r\n    Ctor.precision += k;\r\n\r\n    x = taylorSeries(Ctor, 1, x.times(y), new Ctor(1));\r\n\r\n    // Reverse argument reduction\r\n    for (var i = k; i--;) {\r\n      var cos2x = x.times(x);\r\n      x = cos2x.times(cos2x).minus(cos2x).times(8).plus(1);\r\n    }\r\n\r\n    Ctor.precision -= k;\r\n\r\n    return x;\r\n  }\r\n\r\n\r\n  /*\r\n   * Perform division in the specified base.\r\n   */\r\n  var divide = (function () {\r\n\r\n    // Assumes non-zero x and k, and hence non-zero result.\r\n    function multiplyInteger(x, k, base) {\r\n      var temp,\r\n        carry = 0,\r\n        i = x.length;\r\n\r\n      for (x = x.slice(); i--;) {\r\n        temp = x[i] * k + carry;\r\n        x[i] = temp % base | 0;\r\n        carry = temp / base | 0;\r\n      }\r\n\r\n      if (carry) x.unshift(carry);\r\n\r\n      return x;\r\n    }\r\n\r\n    function compare(a, b, aL, bL) {\r\n      var i, r;\r\n\r\n      if (aL != bL) {\r\n        r = aL > bL ? 1 : -1;\r\n      } else {\r\n        for (i = r = 0; i < aL; i++) {\r\n          if (a[i] != b[i]) {\r\n            r = a[i] > b[i] ? 1 : -1;\r\n            break;\r\n          }\r\n        }\r\n      }\r\n\r\n      return r;\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.shift();\r\n    }\r\n\r\n    return function (x, y, pr, rm, dp, base) {\r\n      var cmp, e, i, k, logBase, more, prod, prodL, q, qd, rem, remL, rem0, sd, t, xi, xL, yd0,\r\n        yL, yz,\r\n        Ctor = x.constructor,\r\n        sign = x.s == y.s ? 1 : -1,\r\n        xd = x.d,\r\n        yd = y.d;\r\n\r\n      // Either NaN, Infinity or 0?\r\n      if (!xd || !xd[0] || !yd || !yd[0]) {\r\n\r\n        return new Ctor(// Return NaN if either NaN, or both Infinity or 0.\r\n          !x.s || !y.s || (xd ? yd && xd[0] == yd[0] : !yd) ? NaN :\r\n\r\n          // Return ±0 if x is 0 or y is ±Infinity, or return ±Infinity as y is 0.\r\n          xd && xd[0] == 0 || !yd ? sign * 0 : sign / 0);\r\n      }\r\n\r\n      if (base) {\r\n        logBase = 1;\r\n        e = x.e - y.e;\r\n      } else {\r\n        base = BASE;\r\n        logBase = LOG_BASE;\r\n        e = mathfloor(x.e / logBase) - mathfloor(y.e / logBase);\r\n      }\r\n\r\n      yL = yd.length;\r\n      xL = xd.length;\r\n      q = new Ctor(sign);\r\n      qd = q.d = [];\r\n\r\n      // Result exponent may be one less than e.\r\n      // The digit array of a Decimal from toStringBinary may have trailing zeros.\r\n      for (i = 0; yd[i] == (xd[i] || 0); i++);\r\n\r\n      if (yd[i] > (xd[i] || 0)) e--;\r\n\r\n      if (pr == null) {\r\n        sd = pr = Ctor.precision;\r\n        rm = Ctor.rounding;\r\n      } else if (dp) {\r\n        sd = pr + (x.e - y.e) + 1;\r\n      } else {\r\n        sd = pr;\r\n      }\r\n\r\n      if (sd < 0) {\r\n        qd.push(1);\r\n        more = true;\r\n      } else {\r\n\r\n        // Convert precision in number of base 10 digits to base 1e7 digits.\r\n        sd = sd / logBase + 2 | 0;\r\n        i = 0;\r\n\r\n        // divisor < 1e7\r\n        if (yL == 1) {\r\n          k = 0;\r\n          yd = yd[0];\r\n          sd++;\r\n\r\n          // k is the carry.\r\n          for (; (i < xL || k) && sd--; i++) {\r\n            t = k * base + (xd[i] || 0);\r\n            qd[i] = t / yd | 0;\r\n            k = t % yd | 0;\r\n          }\r\n\r\n          more = k || i < xL;\r\n\r\n        // divisor >= 1e7\r\n        } else {\r\n\r\n          // Normalise xd and yd so highest order digit of yd is >= base/2\r\n          k = base / (yd[0] + 1) | 0;\r\n\r\n          if (k > 1) {\r\n            yd = multiplyInteger(yd, k, base);\r\n            xd = multiplyInteger(xd, k, base);\r\n            yL = yd.length;\r\n            xL = xd.length;\r\n          }\r\n\r\n          xi = yL;\r\n          rem = xd.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\r\n          yz = yd.slice();\r\n          yz.unshift(0);\r\n          yd0 = yd[0];\r\n\r\n          if (yd[1] >= base / 2) ++yd0;\r\n\r\n          do {\r\n            k = 0;\r\n\r\n            // Compare divisor and remainder.\r\n            cmp = compare(yd, rem, yL, remL);\r\n\r\n            // If divisor < remainder.\r\n            if (cmp < 0) {\r\n\r\n              // Calculate trial digit, k.\r\n              rem0 = rem[0];\r\n              if (yL != remL) rem0 = rem0 * base + (rem[1] || 0);\r\n\r\n              // k will be how many times the divisor goes into the current remainder.\r\n              k = rem0 / yd0 | 0;\r\n\r\n              //  Algorithm:\r\n              //  1. product = divisor * trial digit (k)\r\n              //  2. if product > remainder: product -= divisor, k--\r\n              //  3. remainder -= product\r\n              //  4. if product was < remainder at 2:\r\n              //    5. compare new remainder and divisor\r\n              //    6. If remainder > divisor: remainder -= divisor, k++\r\n\r\n              if (k > 1) {\r\n                if (k >= base) k = base - 1;\r\n\r\n                // product = divisor * trial digit.\r\n                prod = multiplyInteger(yd, k, base);\r\n                prodL = prod.length;\r\n                remL = rem.length;\r\n\r\n                // Compare product and remainder.\r\n                cmp = compare(prod, rem, prodL, remL);\r\n\r\n                // product > remainder.\r\n                if (cmp == 1) {\r\n                  k--;\r\n\r\n                  // Subtract divisor from product.\r\n                  subtract(prod, yL < prodL ? yz : yd, prodL, base);\r\n                }\r\n              } else {\r\n\r\n                // cmp is -1.\r\n                // If k is 0, there is no need to compare yd and rem again below, so change cmp to 1\r\n                // to avoid it. If k is 1 there is a need to compare yd and rem again below.\r\n                if (k == 0) cmp = k = 1;\r\n                prod = yd.slice();\r\n              }\r\n\r\n              prodL = prod.length;\r\n              if (prodL < remL) prod.unshift(0);\r\n\r\n              // Subtract product from remainder.\r\n              subtract(rem, prod, remL, base);\r\n\r\n              // If product was < previous remainder.\r\n              if (cmp == -1) {\r\n                remL = rem.length;\r\n\r\n                // Compare divisor and new remainder.\r\n                cmp = compare(yd, rem, yL, remL);\r\n\r\n                // If divisor < new remainder, subtract divisor from remainder.\r\n                if (cmp < 1) {\r\n                  k++;\r\n\r\n                  // Subtract divisor from remainder.\r\n                  subtract(rem, yL < remL ? yz : yd, remL, base);\r\n                }\r\n              }\r\n\r\n              remL = rem.length;\r\n            } else if (cmp === 0) {\r\n              k++;\r\n              rem = [0];\r\n            }    // if cmp === 1, k will be 0\r\n\r\n            // Add the next digit, k, to the result array.\r\n            qd[i++] = k;\r\n\r\n            // Update the remainder.\r\n            if (cmp && rem[0]) {\r\n              rem[remL++] = xd[xi] || 0;\r\n            } else {\r\n              rem = [xd[xi]];\r\n              remL = 1;\r\n            }\r\n\r\n          } while ((xi++ < xL || rem[0] !== void 0) && sd--);\r\n\r\n          more = rem[0] !== void 0;\r\n        }\r\n\r\n        // Leading zero?\r\n        if (!qd[0]) qd.shift();\r\n      }\r\n\r\n      // logBase is 1 when divide is being used for base conversion.\r\n      if (logBase == 1) {\r\n        q.e = e;\r\n        inexact = more;\r\n      } else {\r\n\r\n        // To calculate q.e, first get the number of digits of qd[0].\r\n        for (i = 1, k = qd[0]; k >= 10; k /= 10) i++;\r\n        q.e = i + e * logBase - 1;\r\n\r\n        finalise(q, dp ? pr + q.e + 1 : pr, rm, more);\r\n      }\r\n\r\n      return q;\r\n    };\r\n  })();\r\n\r\n\r\n  /*\r\n   * Round `x` to `sd` significant digits using rounding mode `rm`.\r\n   * Check for over/under-flow.\r\n   */\r\n   function finalise(x, sd, rm, isTruncated) {\r\n    var digits, i, j, k, rd, roundUp, w, xd, xdi,\r\n      Ctor = x.constructor;\r\n\r\n    // Don't round if sd is null or undefined.\r\n    out: if (sd != null) {\r\n      xd = x.d;\r\n\r\n      // Infinity/NaN.\r\n      if (!xd) return x;\r\n\r\n      // rd: the rounding digit, i.e. the digit after the digit that may be rounded up.\r\n      // w: the word of xd containing rd, a base 1e7 number.\r\n      // xdi: the index of w within xd.\r\n      // digits: the number of digits of w.\r\n      // i: what would be the index of rd within w if all the numbers were 7 digits long (i.e. if\r\n      // they had leading zeros)\r\n      // j: if > 0, the actual index of rd within w (if < 0, rd is a leading zero).\r\n\r\n      // Get the length of the first word of the digits array xd.\r\n      for (digits = 1, k = xd[0]; k >= 10; k /= 10) digits++;\r\n      i = sd - digits;\r\n\r\n      // Is the rounding digit in the first word of xd?\r\n      if (i < 0) {\r\n        i += LOG_BASE;\r\n        j = sd;\r\n        w = xd[xdi = 0];\r\n\r\n        // Get the rounding digit at index j of w.\r\n        rd = w / mathpow(10, digits - j - 1) % 10 | 0;\r\n      } else {\r\n        xdi = Math.ceil((i + 1) / LOG_BASE);\r\n        k = xd.length;\r\n        if (xdi >= k) {\r\n          if (isTruncated) {\r\n\r\n            // Needed by `naturalExponential`, `naturalLogarithm` and `squareRoot`.\r\n            for (; k++ <= xdi;) xd.push(0);\r\n            w = rd = 0;\r\n            digits = 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          w = k = xd[xdi];\r\n\r\n          // Get the number of digits of w.\r\n          for (digits = 1; k >= 10; k /= 10) digits++;\r\n\r\n          // Get the index of rd within w.\r\n          i %= LOG_BASE;\r\n\r\n          // Get the index of rd within w, adjusted for leading zeros.\r\n          // The number of leading zeros of w is given by LOG_BASE - digits.\r\n          j = i - LOG_BASE + digits;\r\n\r\n          // Get the rounding digit at index j of w.\r\n          rd = j < 0 ? 0 : w / mathpow(10, digits - j - 1) % 10 | 0;\r\n        }\r\n      }\r\n\r\n      // Are there any non-zero digits after the rounding digit?\r\n      isTruncated = isTruncated || sd < 0 ||\r\n        xd[xdi + 1] !== void 0 || (j < 0 ? w : w % mathpow(10, digits - j - 1));\r\n\r\n      // The expression `w % mathpow(10, digits - j - 1)` returns all the digits of w to the right\r\n      // of the digit at (left-to-right) index j, e.g. if w is 908714 and j is 2, the expression\r\n      // will give 714.\r\n\r\n      roundUp = rm < 4\r\n        ? (rd || isTruncated) && (rm == 0 || rm == (x.s < 0 ? 3 : 2))\r\n        : rd > 5 || rd == 5 && (rm == 4 || isTruncated || 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 ? w / mathpow(10, digits - j) : 0 : xd[xdi - 1]) % 10) & 1 ||\r\n            rm == (x.s < 0 ? 8 : 7));\r\n\r\n      if (sd < 1 || !xd[0]) {\r\n        xd.length = 0;\r\n        if (roundUp) {\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          xd[0] = mathpow(10, (LOG_BASE - sd % LOG_BASE) % LOG_BASE);\r\n          x.e = -sd || 0;\r\n        } else {\r\n\r\n          // Zero.\r\n          xd[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        xd.length = xdi;\r\n        k = 1;\r\n        xdi--;\r\n      } else {\r\n        xd.length = xdi + 1;\r\n        k = mathpow(10, 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 w.\r\n        xd[xdi] = j > 0 ? (w / mathpow(10, digits - j) % mathpow(10, j) | 0) * k : 0;\r\n      }\r\n\r\n      if (roundUp) {\r\n        for (;;) {\r\n\r\n          // Is the digit to be rounded up in the first word of xd?\r\n          if (xdi == 0) {\r\n\r\n            // i will be the length of xd[0] before k is added.\r\n            for (i = 1, j = xd[0]; j >= 10; j /= 10) i++;\r\n            j = xd[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 (xd[0] == BASE) xd[0] = 1;\r\n            }\r\n\r\n            break;\r\n          } else {\r\n            xd[xdi] += k;\r\n            if (xd[xdi] != BASE) break;\r\n            xd[xdi--] = 0;\r\n            k = 1;\r\n          }\r\n        }\r\n      }\r\n\r\n      // Remove trailing zeros.\r\n      for (i = xd.length; xd[--i] === 0;) xd.pop();\r\n    }\r\n\r\n    if (external) {\r\n\r\n      // Overflow?\r\n      if (x.e > Ctor.maxE) {\r\n\r\n        // Infinity.\r\n        x.d = null;\r\n        x.e = NaN;\r\n\r\n      // Underflow?\r\n      } else if (x.e < Ctor.minE) {\r\n\r\n        // Zero.\r\n        x.e = 0;\r\n        x.d = [0];\r\n        // Ctor.underflow = true;\r\n      } // else Ctor.underflow = false;\r\n    }\r\n\r\n    return x;\r\n  }\r\n\r\n\r\n  function finiteToString(x, isExp, sd) {\r\n    if (!x.isFinite()) return nonFiniteToString(x);\r\n    var k,\r\n      e = x.e,\r\n      str = digitsToString(x.d),\r\n      len = str.length;\r\n\r\n    if (isExp) {\r\n      if (sd && (k = sd - len) > 0) {\r\n        str = str.charAt(0) + '.' + str.slice(1) + getZeroString(k);\r\n      } else if (len > 1) {\r\n        str = str.charAt(0) + '.' + str.slice(1);\r\n      }\r\n\r\n      str = str + (x.e < 0 ? 'e' : 'e+') + x.e;\r\n    } else if (e < 0) {\r\n      str = '0.' + getZeroString(-e - 1) + str;\r\n      if (sd && (k = sd - len) > 0) str += getZeroString(k);\r\n    } else if (e >= len) {\r\n      str += getZeroString(e + 1 - len);\r\n      if (sd && (k = sd - e - 1) > 0) str = str + '.' + getZeroString(k);\r\n    } else {\r\n      if ((k = e + 1) < len) str = str.slice(0, k) + '.' + str.slice(k);\r\n      if (sd && (k = sd - len) > 0) {\r\n        if (e + 1 === len) str += '.';\r\n        str += getZeroString(k);\r\n      }\r\n    }\r\n\r\n    return str;\r\n  }\r\n\r\n\r\n  // Calculate the base 10 exponent from the base 1e7 exponent.\r\n  function getBase10Exponent(digits, e) {\r\n    var w = digits[0];\r\n\r\n    // Add the number of digits of the first word of the digits array.\r\n    for ( e *= LOG_BASE; w >= 10; w /= 10) e++;\r\n    return e;\r\n  }\r\n\r\n\r\n  function getLn10(Ctor, sd, pr) {\r\n    if (sd > LN10_PRECISION) {\r\n\r\n      // Reset global state in case the exception is caught.\r\n      external = true;\r\n      if (pr) Ctor.precision = pr;\r\n      throw Error(precisionLimitExceeded);\r\n    }\r\n    return finalise(new Ctor(LN10), sd, 1, true);\r\n  }\r\n\r\n\r\n  function getPi(Ctor, sd, rm) {\r\n    if (sd > PI_PRECISION) throw Error(precisionLimitExceeded);\r\n    return finalise(new Ctor(PI), sd, rm, true);\r\n  }\r\n\r\n\r\n  function getPrecision(digits) {\r\n    var w = digits.length - 1,\r\n      len = w * LOG_BASE + 1;\r\n\r\n    w = digits[w];\r\n\r\n    // If non-zero...\r\n    if (w) {\r\n\r\n      // Subtract the number of trailing zeros of the last word.\r\n      for (; w % 10 == 0; w /= 10) len--;\r\n\r\n      // Add the number of digits of the first word.\r\n      for (w = digits[0]; w >= 10; w /= 10) len++;\r\n    }\r\n\r\n    return len;\r\n  }\r\n\r\n\r\n  function getZeroString(k) {\r\n    var zs = '';\r\n    for (; k--;) zs += '0';\r\n    return zs;\r\n  }\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the value of Decimal `x` to the power `n`, where `n` is an\r\n   * integer of type number.\r\n   *\r\n   * Implements 'exponentiation by squaring'. Called by `pow` and `parseOther`.\r\n   *\r\n   */\r\n  function intPow(Ctor, x, n, pr) {\r\n    var isTruncated,\r\n      r = new Ctor(1),\r\n\r\n      // Max n of 9007199254740991 takes 53 loop iterations.\r\n      // Maximum digits array length; leaves [28, 34] guard digits.\r\n      k = Math.ceil(pr / LOG_BASE + 4);\r\n\r\n    external = false;\r\n\r\n    for (;;) {\r\n      if (n % 2) {\r\n        r = r.times(x);\r\n        if (truncate(r.d, k)) isTruncated = true;\r\n      }\r\n\r\n      n = mathfloor(n / 2);\r\n      if (n === 0) {\r\n\r\n        // To ensure correct rounding when r.d is truncated, increment the last word if it is zero.\r\n        n = r.d.length - 1;\r\n        if (isTruncated && r.d[n] === 0) ++r.d[n];\r\n        break;\r\n      }\r\n\r\n      x = x.times(x);\r\n      truncate(x.d, k);\r\n    }\r\n\r\n    external = true;\r\n\r\n    return r;\r\n  }\r\n\r\n\r\n  function isOdd(n) {\r\n    return n.d[n.d.length - 1] & 1;\r\n  }\r\n\r\n\r\n  /*\r\n   * Handle `max` and `min`. `ltgt` is 'lt' or 'gt'.\r\n   */\r\n  function maxOrMin(Ctor, args, ltgt) {\r\n    var y,\r\n      x = new Ctor(args[0]),\r\n      i = 0;\r\n\r\n    for (; ++i < args.length;) {\r\n      y = new Ctor(args[i]);\r\n      if (!y.s) {\r\n        x = y;\r\n        break;\r\n      } else if (x[ltgt](y)) {\r\n        x = y;\r\n      }\r\n    }\r\n\r\n    return x;\r\n  }\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the natural exponential of `x` rounded to `sd` significant\r\n   * digits.\r\n   *\r\n   * Taylor/Maclaurin series.\r\n   *\r\n   * exp(x) = x^0/0! + x^1/1! + x^2/2! + x^3/3! + ...\r\n   *\r\n   * Argument reduction:\r\n   *   Repeat x = x / 32, k += 5, until |x| < 0.1\r\n   *   exp(x) = exp(x / 2^k)^(2^k)\r\n   *\r\n   * Previously, the argument was initially reduced by\r\n   * exp(x) = exp(r) * 10^k  where r = x - k * ln10, k = floor(x / ln10)\r\n   * to first put r in the range [0, ln10], before dividing by 32 until |x| < 0.1, but this was\r\n   * found to be slower than just dividing repeatedly by 32 as above.\r\n   *\r\n   * Max integer argument: exp('20723265836946413') = 6.3e+9000000000000000\r\n   * Min integer argument: exp('-20723265836946411') = 1.2e-9000000000000000\r\n   * (Math object integer min/max: Math.exp(709) = 8.2e+307, Math.exp(-745) = 5e-324)\r\n   *\r\n   *  exp(Infinity)  = Infinity\r\n   *  exp(-Infinity) = 0\r\n   *  exp(NaN)       = NaN\r\n   *  exp(±0)        = 1\r\n   *\r\n   *  exp(x) is non-terminating for any finite, non-zero x.\r\n   *\r\n   *  The result will always be correctly rounded.\r\n   *\r\n   */\r\n  function naturalExponential(x, sd) {\r\n    var denominator, guard, j, pow, sum, t, wpr,\r\n      rep = 0,\r\n      i = 0,\r\n      k = 0,\r\n      Ctor = x.constructor,\r\n      rm = Ctor.rounding,\r\n      pr = Ctor.precision;\r\n\r\n    // 0/NaN/Infinity?\r\n    if (!x.d || !x.d[0] || x.e > 17) {\r\n\r\n      return new Ctor(x.d\r\n        ? !x.d[0] ? 1 : x.s < 0 ? 0 : 1 / 0\r\n        : x.s ? x.s < 0 ? 0 : x : 0 / 0);\r\n    }\r\n\r\n    if (sd == null) {\r\n      external = false;\r\n      wpr = pr;\r\n    } else {\r\n      wpr = sd;\r\n    }\r\n\r\n    t = new Ctor(0.03125);\r\n\r\n    // while abs(x) >= 0.1\r\n    while (x.e > -2) {\r\n\r\n      // x = x / 2^5\r\n      x = x.times(t);\r\n      k += 5;\r\n    }\r\n\r\n    // Use 2 * log10(2^k) + 5 (empirically derived) to estimate the increase in precision\r\n    // necessary to ensure the first 4 rounding digits are correct.\r\n    guard = Math.log(mathpow(2, k)) / Math.LN10 * 2 + 5 | 0;\r\n    wpr += guard;\r\n    denominator = pow = sum = new Ctor(1);\r\n    Ctor.precision = wpr;\r\n\r\n    for (;;) {\r\n      pow = finalise(pow.times(x), wpr, 1);\r\n      denominator = denominator.times(++i);\r\n      t = sum.plus(divide(pow, denominator, wpr, 1));\r\n\r\n      if (digitsToString(t.d).slice(0, wpr) === digitsToString(sum.d).slice(0, wpr)) {\r\n        j = k;\r\n        while (j--) sum = finalise(sum.times(sum), wpr, 1);\r\n\r\n        // Check to see if the first 4 rounding digits are [49]999.\r\n        // If so, repeat the summation with a higher precision, otherwise\r\n        // e.g. with precision: 18, rounding: 1\r\n        // exp(18.404272462595034083567793919843761) = 98372560.1229999999 (should be 98372560.123)\r\n        // `wpr - guard` is the index of first rounding digit.\r\n        if (sd == null) {\r\n\r\n          if (rep < 3 && checkRoundingDigits(sum.d, wpr - guard, rm, rep)) {\r\n            Ctor.precision = wpr += 10;\r\n            denominator = pow = t = new Ctor(1);\r\n            i = 0;\r\n            rep++;\r\n          } else {\r\n            return finalise(sum, Ctor.precision = pr, rm, external = true);\r\n          }\r\n        } else {\r\n          Ctor.precision = pr;\r\n          return sum;\r\n        }\r\n      }\r\n\r\n      sum = t;\r\n    }\r\n  }\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the natural logarithm of `x` rounded to `sd` significant\r\n   * digits.\r\n   *\r\n   *  ln(-n)        = NaN\r\n   *  ln(0)         = -Infinity\r\n   *  ln(-0)        = -Infinity\r\n   *  ln(1)         = 0\r\n   *  ln(Infinity)  = Infinity\r\n   *  ln(-Infinity) = NaN\r\n   *  ln(NaN)       = NaN\r\n   *\r\n   *  ln(n) (n != 1) is non-terminating.\r\n   *\r\n   */\r\n  function naturalLogarithm(y, sd) {\r\n    var c, c0, denominator, e, numerator, rep, sum, t, wpr, x1, x2,\r\n      n = 1,\r\n      guard = 10,\r\n      x = y,\r\n      xd = x.d,\r\n      Ctor = x.constructor,\r\n      rm = Ctor.rounding,\r\n      pr = Ctor.precision;\r\n\r\n    // Is x negative or Infinity, NaN, 0 or 1?\r\n    if (x.s < 0 || !xd || !xd[0] || !x.e && xd[0] == 1 && xd.length == 1) {\r\n      return new Ctor(xd && !xd[0] ? -1 / 0 : x.s != 1 ? NaN : xd ? 0 : x);\r\n    }\r\n\r\n    if (sd == null) {\r\n      external = false;\r\n      wpr = pr;\r\n    } else {\r\n      wpr = sd;\r\n    }\r\n\r\n    Ctor.precision = wpr += guard;\r\n    c = digitsToString(xd);\r\n    c0 = c.charAt(0);\r\n\r\n    if (Math.abs(e = x.e) < 1.5e15) {\r\n\r\n      // Argument reduction.\r\n      // The series converges faster the closer the argument is to 1, so using\r\n      // ln(a^b) = b * ln(a),   ln(a) = ln(a^b) / b\r\n      // multiply the argument by itself until the leading digits of the significand are 7, 8, 9,\r\n      // 10, 11, 12 or 13, recording the number of multiplications so the sum of the series can\r\n      // later be divided by this number, then separate out the power of 10 using\r\n      // ln(a*10^b) = ln(a) + b*ln(10).\r\n\r\n      // max n is 21 (gives 0.9, 1.0 or 1.1) (9e15 / 21 = 4.2e14).\r\n      //while (c0 < 9 && c0 != 1 || c0 == 1 && c.charAt(1) > 1) {\r\n      // max n is 6 (gives 0.7 - 1.3)\r\n      while (c0 < 7 && c0 != 1 || c0 == 1 && c.charAt(1) > 3) {\r\n        x = x.times(y);\r\n        c = digitsToString(x.d);\r\n        c0 = c.charAt(0);\r\n        n++;\r\n      }\r\n\r\n      e = x.e;\r\n\r\n      if (c0 > 1) {\r\n        x = new Ctor('0.' + c);\r\n        e++;\r\n      } else {\r\n        x = new Ctor(c0 + '.' + c.slice(1));\r\n      }\r\n    } else {\r\n\r\n      // The argument reduction method above may result in overflow if the argument y is a massive\r\n      // number with exponent >= 1500000000000000 (9e15 / 6 = 1.5e15), so instead recall this\r\n      // function using ln(x*10^e) = ln(x) + e*ln(10).\r\n      t = getLn10(Ctor, wpr + 2, pr).times(e + '');\r\n      x = naturalLogarithm(new Ctor(c0 + '.' + c.slice(1)), wpr - guard).plus(t);\r\n      Ctor.precision = pr;\r\n\r\n      return sd == null ? finalise(x, pr, rm, external = true) : x;\r\n    }\r\n\r\n    // x1 is x reduced to a value near 1.\r\n    x1 = x;\r\n\r\n    // Taylor series.\r\n    // ln(y) = ln((1 + x)/(1 - x)) = 2(x + x^3/3 + x^5/5 + x^7/7 + ...)\r\n    // where x = (y - 1)/(y + 1)    (|x| < 1)\r\n    sum = numerator = x = divide(x.minus(1), x.plus(1), wpr, 1);\r\n    x2 = finalise(x.times(x), wpr, 1);\r\n    denominator = 3;\r\n\r\n    for (;;) {\r\n      numerator = finalise(numerator.times(x2), wpr, 1);\r\n      t = sum.plus(divide(numerator, new Ctor(denominator), wpr, 1));\r\n\r\n      if (digitsToString(t.d).slice(0, wpr) === digitsToString(sum.d).slice(0, wpr)) {\r\n        sum = sum.times(2);\r\n\r\n        // Reverse the argument reduction. Check that e is not 0 because, besides preventing an\r\n        // unnecessary calculation, -0 + 0 = +0 and to ensure correct rounding -0 needs to stay -0.\r\n        if (e !== 0) sum = sum.plus(getLn10(Ctor, wpr + 2, pr).times(e + ''));\r\n        sum = divide(sum, new Ctor(n), wpr, 1);\r\n\r\n        // Is rm > 3 and the first 4 rounding digits 4999, or rm < 4 (or the summation has\r\n        // been repeated previously) and the first 4 rounding digits 9999?\r\n        // If so, restart the summation with a higher precision, otherwise\r\n        // e.g. with precision: 12, rounding: 1\r\n        // ln(135520028.6126091714265381533) = 18.7246299999 when it should be 18.72463.\r\n        // `wpr - guard` is the index of first rounding digit.\r\n        if (sd == null) {\r\n          if (checkRoundingDigits(sum.d, wpr - guard, rm, rep)) {\r\n            Ctor.precision = wpr += guard;\r\n            t = numerator = x = divide(x1.minus(1), x1.plus(1), wpr, 1);\r\n            x2 = finalise(x.times(x), wpr, 1);\r\n            denominator = rep = 1;\r\n          } else {\r\n            return finalise(sum, Ctor.precision = pr, rm, external = true);\r\n          }\r\n        } else {\r\n          Ctor.precision = pr;\r\n          return sum;\r\n        }\r\n      }\r\n\r\n      sum = t;\r\n      denominator += 2;\r\n    }\r\n  }\r\n\r\n\r\n  // ±Infinity, NaN.\r\n  function nonFiniteToString(x) {\r\n    // Unsigned.\r\n    return String(x.s * x.s / 0);\r\n  }\r\n\r\n\r\n  /*\r\n   * Parse the value of a new Decimal `x` from string `str`.\r\n   */\r\n  function parseDecimal(x, str) {\r\n    var e, i, len;\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    // 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 - 1) === 48; --len);\r\n    str = str.slice(i, len);\r\n\r\n    if (str) {\r\n      len -= i;\r\n      x.e = e = e - i - 1;\r\n      x.d = [];\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 word of the digits array.\r\n      i = (e + 1) % LOG_BASE;\r\n      if (e < 0) i += LOG_BASE;\r\n\r\n      if (i < len) {\r\n        if (i) x.d.push(+str.slice(0, i));\r\n        for (len -= LOG_BASE; i < len;) x.d.push(+str.slice(i, i += LOG_BASE));\r\n        str = str.slice(i);\r\n        i = LOG_BASE - str.length;\r\n      } else {\r\n        i -= len;\r\n      }\r\n\r\n      for (; i--;) str += '0';\r\n      x.d.push(+str);\r\n\r\n      if (external) {\r\n\r\n        // Overflow?\r\n        if (x.e > x.constructor.maxE) {\r\n\r\n          // Infinity.\r\n          x.d = null;\r\n          x.e = NaN;\r\n\r\n        // Underflow?\r\n        } else if (x.e < x.constructor.minE) {\r\n\r\n          // Zero.\r\n          x.e = 0;\r\n          x.d = [0];\r\n          // x.constructor.underflow = true;\r\n        } // else x.constructor.underflow = false;\r\n      }\r\n    } else {\r\n\r\n      // Zero.\r\n      x.e = 0;\r\n      x.d = [0];\r\n    }\r\n\r\n    return x;\r\n  }\r\n\r\n\r\n  /*\r\n   * Parse the value of a new Decimal `x` from a string `str`, which is not a decimal value.\r\n   */\r\n  function parseOther(x, str) {\r\n    var base, Ctor, divisor, i, isFloat, len, p, xd, xe;\r\n\r\n    if (str.indexOf('_') > -1) {\r\n      str = str.replace(/(\\d)_(?=\\d)/g, '$1');\r\n      if (isDecimal.test(str)) return parseDecimal(x, str);\r\n    } else if (str === 'Infinity' || str === 'NaN') {\r\n      if (!+str) x.s = NaN;\r\n      x.e = NaN;\r\n      x.d = null;\r\n      return x;\r\n    }\r\n\r\n    if (isHex.test(str))  {\r\n      base = 16;\r\n      str = str.toLowerCase();\r\n    } else if (isBinary.test(str))  {\r\n      base = 2;\r\n    } else if (isOctal.test(str))  {\r\n      base = 8;\r\n    } else {\r\n      throw Error(invalidArgument + str);\r\n    }\r\n\r\n    // Is there a binary exponent part?\r\n    i = str.search(/p/i);\r\n\r\n    if (i > 0) {\r\n      p = +str.slice(i + 1);\r\n      str = str.substring(2, i);\r\n    } else {\r\n      str = str.slice(2);\r\n    }\r\n\r\n    // Convert `str` as an integer then divide the result by `base` raised to a power such that the\r\n    // fraction part will be restored.\r\n    i = str.indexOf('.');\r\n    isFloat = i >= 0;\r\n    Ctor = x.constructor;\r\n\r\n    if (isFloat) {\r\n      str = str.replace('.', '');\r\n      len = str.length;\r\n      i = len - i;\r\n\r\n      // log[10](16) = 1.2041... , log[10](88) = 1.9444....\r\n      divisor = intPow(Ctor, new Ctor(base), i, i * 2);\r\n    }\r\n\r\n    xd = convertBase(str, base, BASE);\r\n    xe = xd.length - 1;\r\n\r\n    // Remove trailing zeros.\r\n    for (i = xe; xd[i] === 0; --i) xd.pop();\r\n    if (i < 0) return new Ctor(x.s * 0);\r\n    x.e = getBase10Exponent(xd, xe);\r\n    x.d = xd;\r\n    external = false;\r\n\r\n    // At what precision to perform the division to ensure exact conversion?\r\n    // maxDecimalIntegerPartDigitCount = ceil(log[10](b) * otherBaseIntegerPartDigitCount)\r\n    // log[10](2) = 0.30103, log[10](8) = 0.90309, log[10](16) = 1.20412\r\n    // E.g. ceil(1.2 * 3) = 4, so up to 4 decimal digits are needed to represent 3 hex int digits.\r\n    // maxDecimalFractionPartDigitCount = {Hex:4|Oct:3|Bin:1} * otherBaseFractionPartDigitCount\r\n    // Therefore using 4 * the number of digits of str will always be enough.\r\n    if (isFloat) x = divide(x, divisor, len * 4);\r\n\r\n    // Multiply by the binary exponent part if present.\r\n    if (p) x = x.times(Math.abs(p) < 54 ? mathpow(2, p) : Decimal.pow(2, p));\r\n    external = true;\r\n\r\n    return x;\r\n  }\r\n\r\n\r\n  /*\r\n   * sin(x) = x - x^3/3! + x^5/5! - ...\r\n   * |x| < pi/2\r\n   *\r\n   */\r\n  function sine(Ctor, x) {\r\n    var k,\r\n      len = x.d.length;\r\n\r\n    if (len < 3) {\r\n      return x.isZero() ? x : taylorSeries(Ctor, 2, x, x);\r\n    }\r\n\r\n    // Argument reduction: sin(5x) = 16*sin^5(x) - 20*sin^3(x) + 5*sin(x)\r\n    // i.e. sin(x) = 16*sin^5(x/5) - 20*sin^3(x/5) + 5*sin(x/5)\r\n    // and  sin(x) = sin(x/5)(5 + sin^2(x/5)(16sin^2(x/5) - 20))\r\n\r\n    // Estimate the optimum number of times to use the argument reduction.\r\n    k = 1.4 * Math.sqrt(len);\r\n    k = k > 16 ? 16 : k | 0;\r\n\r\n    x = x.times(1 / tinyPow(5, k));\r\n    x = taylorSeries(Ctor, 2, x, x);\r\n\r\n    // Reverse argument reduction\r\n    var sin2_x,\r\n      d5 = new Ctor(5),\r\n      d16 = new Ctor(16),\r\n      d20 = new Ctor(20);\r\n    for (; k--;) {\r\n      sin2_x = x.times(x);\r\n      x = x.times(d5.plus(sin2_x.times(d16.times(sin2_x).minus(d20))));\r\n    }\r\n\r\n    return x;\r\n  }\r\n\r\n\r\n  // Calculate Taylor series for `cos`, `cosh`, `sin` and `sinh`.\r\n  function taylorSeries(Ctor, n, x, y, isHyperbolic) {\r\n    var j, t, u, x2,\r\n      i = 1,\r\n      pr = Ctor.precision,\r\n      k = Math.ceil(pr / LOG_BASE);\r\n\r\n    external = false;\r\n    x2 = x.times(x);\r\n    u = new Ctor(y);\r\n\r\n    for (;;) {\r\n      t = divide(u.times(x2), new Ctor(n++ * n++), pr, 1);\r\n      u = isHyperbolic ? y.plus(t) : y.minus(t);\r\n      y = divide(t.times(x2), new Ctor(n++ * n++), pr, 1);\r\n      t = u.plus(y);\r\n\r\n      if (t.d[k] !== void 0) {\r\n        for (j = k; t.d[j] === u.d[j] && j--;);\r\n        if (j == -1) break;\r\n      }\r\n\r\n      j = u;\r\n      u = y;\r\n      y = t;\r\n      t = j;\r\n      i++;\r\n    }\r\n\r\n    external = true;\r\n    t.d.length = k + 1;\r\n\r\n    return t;\r\n  }\r\n\r\n\r\n  // Exponent e must be positive and non-zero.\r\n  function tinyPow(b, e) {\r\n    var n = b;\r\n    while (--e) n *= b;\r\n    return n;\r\n  }\r\n\r\n\r\n  // Return the absolute value of `x` reduced to less than or equal to half pi.\r\n  function toLessThanHalfPi(Ctor, x) {\r\n    var t,\r\n      isNeg = x.s < 0,\r\n      pi = getPi(Ctor, Ctor.precision, 1),\r\n      halfPi = pi.times(0.5);\r\n\r\n    x = x.abs();\r\n\r\n    if (x.lte(halfPi)) {\r\n      quadrant = isNeg ? 4 : 1;\r\n      return x;\r\n    }\r\n\r\n    t = x.divToInt(pi);\r\n\r\n    if (t.isZero()) {\r\n      quadrant = isNeg ? 3 : 2;\r\n    } else {\r\n      x = x.minus(t.times(pi));\r\n\r\n      // 0 <= x < pi\r\n      if (x.lte(halfPi)) {\r\n        quadrant = isOdd(t) ? (isNeg ? 2 : 3) : (isNeg ? 4 : 1);\r\n        return x;\r\n      }\r\n\r\n      quadrant = isOdd(t) ? (isNeg ? 1 : 4) : (isNeg ? 3 : 2);\r\n    }\r\n\r\n    return x.minus(pi).abs();\r\n  }\r\n\r\n\r\n  /*\r\n   * Return the value of Decimal `x` as a string in base `baseOut`.\r\n   *\r\n   * If the optional `sd` argument is present include a binary exponent suffix.\r\n   */\r\n  function toStringBinary(x, baseOut, sd, rm) {\r\n    var base, e, i, k, len, roundUp, str, xd, y,\r\n      Ctor = x.constructor,\r\n      isExp = sd !== void 0;\r\n\r\n    if (isExp) {\r\n      checkInt32(sd, 1, MAX_DIGITS);\r\n      if (rm === void 0) rm = Ctor.rounding;\r\n      else checkInt32(rm, 0, 8);\r\n    } else {\r\n      sd = Ctor.precision;\r\n      rm = Ctor.rounding;\r\n    }\r\n\r\n    if (!x.isFinite()) {\r\n      str = nonFiniteToString(x);\r\n    } else {\r\n      str = finiteToString(x);\r\n      i = str.indexOf('.');\r\n\r\n      // Use exponential notation according to `toExpPos` and `toExpNeg`? No, but if required:\r\n      // maxBinaryExponent = floor((decimalExponent + 1) * log[2](10))\r\n      // minBinaryExponent = floor(decimalExponent * log[2](10))\r\n      // log[2](10) = 3.321928094887362347870319429489390175864\r\n\r\n      if (isExp) {\r\n        base = 2;\r\n        if (baseOut == 16) {\r\n          sd = sd * 4 - 3;\r\n        } else if (baseOut == 8) {\r\n          sd = sd * 3 - 2;\r\n        }\r\n      } else {\r\n        base = baseOut;\r\n      }\r\n\r\n      // Convert the number as an integer then divide the result by its base raised to a power such\r\n      // that the fraction part will be restored.\r\n\r\n      // Non-integer.\r\n      if (i >= 0) {\r\n        str = str.replace('.', '');\r\n        y = new Ctor(1);\r\n        y.e = str.length - i;\r\n        y.d = convertBase(finiteToString(y), 10, base);\r\n        y.e = y.d.length;\r\n      }\r\n\r\n      xd = convertBase(str, 10, base);\r\n      e = len = xd.length;\r\n\r\n      // Remove trailing zeros.\r\n      for (; xd[--len] == 0;) xd.pop();\r\n\r\n      if (!xd[0]) {\r\n        str = isExp ? '0p+0' : '0';\r\n      } else {\r\n        if (i < 0) {\r\n          e--;\r\n        } else {\r\n          x = new Ctor(x);\r\n          x.d = xd;\r\n          x.e = e;\r\n          x = divide(x, y, sd, rm, 0, base);\r\n          xd = x.d;\r\n          e = x.e;\r\n          roundUp = inexact;\r\n        }\r\n\r\n        // The rounding digit, i.e. the digit after the digit that may be rounded up.\r\n        i = xd[sd];\r\n        k = base / 2;\r\n        roundUp = roundUp || xd[sd + 1] !== void 0;\r\n\r\n        roundUp = rm < 4\r\n          ? (i !== void 0 || roundUp) && (rm === 0 || rm === (x.s < 0 ? 3 : 2))\r\n          : i > k || i === k && (rm === 4 || roundUp || rm === 6 && xd[sd - 1] & 1 ||\r\n            rm === (x.s < 0 ? 8 : 7));\r\n\r\n        xd.length = sd;\r\n\r\n        if (roundUp) {\r\n\r\n          // Rounding up may mean the previous digit has to be rounded up and so on.\r\n          for (; ++xd[--sd] > base - 1;) {\r\n            xd[sd] = 0;\r\n            if (!sd) {\r\n              ++e;\r\n              xd.unshift(1);\r\n            }\r\n          }\r\n        }\r\n\r\n        // Determine trailing zeros.\r\n        for (len = xd.length; !xd[len - 1]; --len);\r\n\r\n        // E.g. [4, 11, 15] becomes 4bf.\r\n        for (i = 0, str = ''; i < len; i++) str += NUMERALS.charAt(xd[i]);\r\n\r\n        // Add binary exponent suffix?\r\n        if (isExp) {\r\n          if (len > 1) {\r\n            if (baseOut == 16 || baseOut == 8) {\r\n              i = baseOut == 16 ? 4 : 3;\r\n              for (--len; len % i; len++) str += '0';\r\n              xd = convertBase(str, base, baseOut);\r\n              for (len = xd.length; !xd[len - 1]; --len);\r\n\r\n              // xd[0] will always be be 1\r\n              for (i = 1, str = '1.'; i < len; i++) str += NUMERALS.charAt(xd[i]);\r\n            } else {\r\n              str = str.charAt(0) + '.' + str.slice(1);\r\n            }\r\n          }\r\n\r\n          str =  str + (e < 0 ? 'p' : 'p+') + e;\r\n        } else if (e < 0) {\r\n          for (; ++e;) str = '0' + str;\r\n          str = '0.' + str;\r\n        } else {\r\n          if (++e > len) for (e -= len; e-- ;) str += '0';\r\n          else if (e < len) str = str.slice(0, e) + '.' + str.slice(e);\r\n        }\r\n      }\r\n\r\n      str = (baseOut == 16 ? '0x' : baseOut == 2 ? '0b' : baseOut == 8 ? '0o' : '') + str;\r\n    }\r\n\r\n    return x.s < 0 ? '-' + str : str;\r\n  }\r\n\r\n\r\n  // Does not strip trailing zeros.\r\n  function truncate(arr, len) {\r\n    if (arr.length > len) {\r\n      arr.length = len;\r\n      return true;\r\n    }\r\n  }\r\n\r\n\r\n  // Decimal methods\r\n\r\n\r\n  /*\r\n   *  abs\r\n   *  acos\r\n   *  acosh\r\n   *  add\r\n   *  asin\r\n   *  asinh\r\n   *  atan\r\n   *  atanh\r\n   *  atan2\r\n   *  cbrt\r\n   *  ceil\r\n   *  clamp\r\n   *  clone\r\n   *  config\r\n   *  cos\r\n   *  cosh\r\n   *  div\r\n   *  exp\r\n   *  floor\r\n   *  hypot\r\n   *  ln\r\n   *  log\r\n   *  log2\r\n   *  log10\r\n   *  max\r\n   *  min\r\n   *  mod\r\n   *  mul\r\n   *  pow\r\n   *  random\r\n   *  round\r\n   *  set\r\n   *  sign\r\n   *  sin\r\n   *  sinh\r\n   *  sqrt\r\n   *  sub\r\n   *  sum\r\n   *  tan\r\n   *  tanh\r\n   *  trunc\r\n   */\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the absolute value of `x`.\r\n   *\r\n   * x {number|string|Decimal}\r\n   *\r\n   */\r\n  function abs(x) {\r\n    return new this(x).abs();\r\n  }\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the arccosine in radians of `x`.\r\n   *\r\n   * x {number|string|Decimal}\r\n   *\r\n   */\r\n  function acos(x) {\r\n    return new this(x).acos();\r\n  }\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the inverse of the hyperbolic cosine of `x`, rounded to\r\n   * `precision` significant digits using rounding mode `rounding`.\r\n   *\r\n   * x {number|string|Decimal} A value in radians.\r\n   *\r\n   */\r\n  function acosh(x) {\r\n    return new this(x).acosh();\r\n  }\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the sum of `x` and `y`, rounded to `precision` significant\r\n   * digits using rounding mode `rounding`.\r\n   *\r\n   * x {number|string|Decimal}\r\n   * y {number|string|Decimal}\r\n   *\r\n   */\r\n  function add(x, y) {\r\n    return new this(x).plus(y);\r\n  }\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the arcsine in radians of `x`, rounded to `precision`\r\n   * significant digits using rounding mode `rounding`.\r\n   *\r\n   * x {number|string|Decimal}\r\n   *\r\n   */\r\n  function asin(x) {\r\n    return new this(x).asin();\r\n  }\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the inverse of the hyperbolic sine of `x`, rounded to\r\n   * `precision` significant digits using rounding mode `rounding`.\r\n   *\r\n   * x {number|string|Decimal} A value in radians.\r\n   *\r\n   */\r\n  function asinh(x) {\r\n    return new this(x).asinh();\r\n  }\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the arctangent in radians of `x`, rounded to `precision`\r\n   * significant digits using rounding mode `rounding`.\r\n   *\r\n   * x {number|string|Decimal}\r\n   *\r\n   */\r\n  function atan(x) {\r\n    return new this(x).atan();\r\n  }\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the inverse of the hyperbolic tangent of `x`, rounded to\r\n   * `precision` significant digits using rounding mode `rounding`.\r\n   *\r\n   * x {number|string|Decimal} A value in radians.\r\n   *\r\n   */\r\n  function atanh(x) {\r\n    return new this(x).atanh();\r\n  }\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the arctangent in radians of `y/x` in the range -pi to pi\r\n   * (inclusive), rounded to `precision` significant digits using rounding mode `rounding`.\r\n   *\r\n   * Domain: [-Infinity, Infinity]\r\n   * Range: [-pi, pi]\r\n   *\r\n   * y {number|string|Decimal} The y-coordinate.\r\n   * x {number|string|Decimal} The x-coordinate.\r\n   *\r\n   * atan2(±0, -0)               = ±pi\r\n   * atan2(±0, +0)               = ±0\r\n   * atan2(±0, -x)               = ±pi for x > 0\r\n   * atan2(±0, x)                = ±0 for x > 0\r\n   * atan2(-y, ±0)               = -pi/2 for y > 0\r\n   * atan2(y, ±0)                = pi/2 for y > 0\r\n   * atan2(±y, -Infinity)        = ±pi for finite y > 0\r\n   * atan2(±y, +Infinity)        = ±0 for finite y > 0\r\n   * atan2(±Infinity, x)         = ±pi/2 for finite x\r\n   * atan2(±Infinity, -Infinity) = ±3*pi/4\r\n   * atan2(±Infinity, +Infinity) = ±pi/4\r\n   * atan2(NaN, x) = NaN\r\n   * atan2(y, NaN) = NaN\r\n   *\r\n   */\r\n  function atan2(y, x) {\r\n    y = new this(y);\r\n    x = new this(x);\r\n    var r,\r\n      pr = this.precision,\r\n      rm = this.rounding,\r\n      wpr = pr + 4;\r\n\r\n    // Either NaN\r\n    if (!y.s || !x.s) {\r\n      r = new this(NaN);\r\n\r\n    // Both ±Infinity\r\n    } else if (!y.d && !x.d) {\r\n      r = getPi(this, wpr, 1).times(x.s > 0 ? 0.25 : 0.75);\r\n      r.s = y.s;\r\n\r\n    // x is ±Infinity or y is ±0\r\n    } else if (!x.d || y.isZero()) {\r\n      r = x.s < 0 ? getPi(this, pr, rm) : new this(0);\r\n      r.s = y.s;\r\n\r\n    // y is ±Infinity or x is ±0\r\n    } else if (!y.d || x.isZero()) {\r\n      r = getPi(this, wpr, 1).times(0.5);\r\n      r.s = y.s;\r\n\r\n    // Both non-zero and finite\r\n    } else if (x.s < 0) {\r\n      this.precision = wpr;\r\n      this.rounding = 1;\r\n      r = this.atan(divide(y, x, wpr, 1));\r\n      x = getPi(this, wpr, 1);\r\n      this.precision = pr;\r\n      this.rounding = rm;\r\n      r = y.s < 0 ? r.minus(x) : r.plus(x);\r\n    } else {\r\n      r = this.atan(divide(y, x, wpr, 1));\r\n    }\r\n\r\n    return r;\r\n  }\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the cube root of `x`, rounded to `precision` significant\r\n   * digits using rounding mode `rounding`.\r\n   *\r\n   * x {number|string|Decimal}\r\n   *\r\n   */\r\n  function cbrt(x) {\r\n    return new this(x).cbrt();\r\n  }\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is `x` rounded to an integer using `ROUND_CEIL`.\r\n   *\r\n   * x {number|string|Decimal}\r\n   *\r\n   */\r\n  function ceil(x) {\r\n    return finalise(x = new this(x), x.e + 1, 2);\r\n  }\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is `x` clamped to the range delineated by `min` and `max`.\r\n   *\r\n   * x {number|string|Decimal}\r\n   * min {number|string|Decimal}\r\n   * max {number|string|Decimal}\r\n   *\r\n   */\r\n  function clamp(x, min, max) {\r\n    return new this(x).clamp(min, max);\r\n  }\r\n\r\n\r\n  /*\r\n   * Configure global settings for a Decimal constructor.\r\n   *\r\n   * `obj` is an object with one or more of the following properties,\r\n   *\r\n   *   precision  {number}\r\n   *   rounding   {number}\r\n   *   toExpNeg   {number}\r\n   *   toExpPos   {number}\r\n   *   maxE       {number}\r\n   *   minE       {number}\r\n   *   modulo     {number}\r\n   *   crypto     {boolean|number}\r\n   *   defaults   {true}\r\n   *\r\n   * E.g. Decimal.config({ precision: 20, rounding: 4 })\r\n   *\r\n   */\r\n  function config(obj) {\r\n    if (!obj || typeof obj !== 'object') throw Error(decimalError + 'Object expected');\r\n    var i, p, v,\r\n      useDefaults = obj.defaults === true,\r\n      ps = [\r\n        'precision', 1, MAX_DIGITS,\r\n        'rounding', 0, 8,\r\n        'toExpNeg', -EXP_LIMIT, 0,\r\n        'toExpPos', 0, EXP_LIMIT,\r\n        'maxE', 0, EXP_LIMIT,\r\n        'minE', -EXP_LIMIT, 0,\r\n        'modulo', 0, 9\r\n      ];\r\n\r\n    for (i = 0; i < ps.length; i += 3) {\r\n      if (p = ps[i], useDefaults) this[p] = DEFAULTS[p];\r\n      if ((v = obj[p]) !== void 0) {\r\n        if (mathfloor(v) === v && v >= ps[i + 1] && v <= ps[i + 2]) this[p] = v;\r\n        else throw Error(invalidArgument + p + ': ' + v);\r\n      }\r\n    }\r\n\r\n    if (p = 'crypto', useDefaults) this[p] = DEFAULTS[p];\r\n    if ((v = obj[p]) !== void 0) {\r\n      if (v === true || v === false || v === 0 || v === 1) {\r\n        if (v) {\r\n          if (typeof crypto != 'undefined' && crypto &&\r\n            (crypto.getRandomValues || crypto.randomBytes)) {\r\n            this[p] = true;\r\n          } else {\r\n            throw Error(cryptoUnavailable);\r\n          }\r\n        } else {\r\n          this[p] = false;\r\n        }\r\n      } else {\r\n        throw Error(invalidArgument + p + ': ' + v);\r\n      }\r\n    }\r\n\r\n    return this;\r\n  }\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the cosine of `x`, rounded to `precision` significant\r\n   * digits using rounding mode `rounding`.\r\n   *\r\n   * x {number|string|Decimal} A value in radians.\r\n   *\r\n   */\r\n  function cos(x) {\r\n    return new this(x).cos();\r\n  }\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the hyperbolic cosine of `x`, rounded to precision\r\n   * significant digits using rounding mode `rounding`.\r\n   *\r\n   * x {number|string|Decimal} A value in radians.\r\n   *\r\n   */\r\n  function cosh(x) {\r\n    return new this(x).cosh();\r\n  }\r\n\r\n\r\n  /*\r\n   * Create and return a Decimal constructor with the same configuration properties as this Decimal\r\n   * constructor.\r\n   *\r\n   */\r\n  function clone(obj) {\r\n    var i, p, ps;\r\n\r\n    /*\r\n     * The Decimal constructor and exported function.\r\n     * Return a new Decimal instance.\r\n     *\r\n     * v {number|string|Decimal} A numeric value.\r\n     *\r\n     */\r\n    function Decimal(v) {\r\n      var e, i, t,\r\n        x = this;\r\n\r\n      // Decimal called without new.\r\n      if (!(x instanceof Decimal)) return new Decimal(v);\r\n\r\n      // Retain a reference to this Decimal constructor, and shadow Decimal.prototype.constructor\r\n      // which points to Object.\r\n      x.constructor = Decimal;\r\n\r\n      // Duplicate.\r\n      if (isDecimalInstance(v)) {\r\n        x.s = v.s;\r\n\r\n        if (external) {\r\n          if (!v.d || v.e > Decimal.maxE) {\r\n\r\n            // Infinity.\r\n            x.e = NaN;\r\n            x.d = null;\r\n          } else if (v.e < Decimal.minE) {\r\n\r\n            // Zero.\r\n            x.e = 0;\r\n            x.d = [0];\r\n          } else {\r\n            x.e = v.e;\r\n            x.d = v.d.slice();\r\n          }\r\n        } else {\r\n          x.e = v.e;\r\n          x.d = v.d ? v.d.slice() : v.d;\r\n        }\r\n\r\n        return;\r\n      }\r\n\r\n      t = typeof v;\r\n\r\n      if (t === 'number') {\r\n        if (v === 0) {\r\n          x.s = 1 / v < 0 ? -1 : 1;\r\n          x.e = 0;\r\n          x.d = [0];\r\n          return;\r\n        }\r\n\r\n        if (v < 0) {\r\n          v = -v;\r\n          x.s = -1;\r\n        } else {\r\n          x.s = 1;\r\n        }\r\n\r\n        // Fast path for small integers.\r\n        if (v === ~~v && v < 1e7) {\r\n          for (e = 0, i = v; i >= 10; i /= 10) e++;\r\n\r\n          if (external) {\r\n            if (e > Decimal.maxE) {\r\n              x.e = NaN;\r\n              x.d = null;\r\n            } else if (e < Decimal.minE) {\r\n              x.e = 0;\r\n              x.d = [0];\r\n            } else {\r\n              x.e = e;\r\n              x.d = [v];\r\n            }\r\n          } else {\r\n            x.e = e;\r\n            x.d = [v];\r\n          }\r\n\r\n          return;\r\n\r\n        // Infinity, NaN.\r\n        } else if (v * 0 !== 0) {\r\n          if (!v) x.s = NaN;\r\n          x.e = NaN;\r\n          x.d = null;\r\n          return;\r\n        }\r\n\r\n        return parseDecimal(x, v.toString());\r\n\r\n      } else if (t !== 'string') {\r\n        throw Error(invalidArgument + v);\r\n      }\r\n\r\n      // Minus sign?\r\n      if ((i = v.charCodeAt(0)) === 45) {\r\n        v = v.slice(1);\r\n        x.s = -1;\r\n      } else {\r\n        // Plus sign?\r\n        if (i === 43) v = v.slice(1);\r\n        x.s = 1;\r\n      }\r\n\r\n      return isDecimal.test(v) ? parseDecimal(x, v) : parseOther(x, v);\r\n    }\r\n\r\n    Decimal.prototype = P;\r\n\r\n    Decimal.ROUND_UP = 0;\r\n    Decimal.ROUND_DOWN = 1;\r\n    Decimal.ROUND_CEIL = 2;\r\n    Decimal.ROUND_FLOOR = 3;\r\n    Decimal.ROUND_HALF_UP = 4;\r\n    Decimal.ROUND_HALF_DOWN = 5;\r\n    Decimal.ROUND_HALF_EVEN = 6;\r\n    Decimal.ROUND_HALF_CEIL = 7;\r\n    Decimal.ROUND_HALF_FLOOR = 8;\r\n    Decimal.EUCLID = 9;\r\n\r\n    Decimal.config = Decimal.set = config;\r\n    Decimal.clone = clone;\r\n    Decimal.isDecimal = isDecimalInstance;\r\n\r\n    Decimal.abs = abs;\r\n    Decimal.acos = acos;\r\n    Decimal.acosh = acosh;        // ES6\r\n    Decimal.add = add;\r\n    Decimal.asin = asin;\r\n    Decimal.asinh = asinh;        // ES6\r\n    Decimal.atan = atan;\r\n    Decimal.atanh = atanh;        // ES6\r\n    Decimal.atan2 = atan2;\r\n    Decimal.cbrt = cbrt;          // ES6\r\n    Decimal.ceil = ceil;\r\n    Decimal.clamp = clamp;\r\n    Decimal.cos = cos;\r\n    Decimal.cosh = cosh;          // ES6\r\n    Decimal.div = div;\r\n    Decimal.exp = exp;\r\n    Decimal.floor = floor;\r\n    Decimal.hypot = hypot;        // ES6\r\n    Decimal.ln = ln;\r\n    Decimal.log = log;\r\n    Decimal.log10 = log10;        // ES6\r\n    Decimal.log2 = log2;          // ES6\r\n    Decimal.max = max;\r\n    Decimal.min = min;\r\n    Decimal.mod = mod;\r\n    Decimal.mul = mul;\r\n    Decimal.pow = pow;\r\n    Decimal.random = random;\r\n    Decimal.round = round;\r\n    Decimal.sign = sign;          // ES6\r\n    Decimal.sin = sin;\r\n    Decimal.sinh = sinh;          // ES6\r\n    Decimal.sqrt = sqrt;\r\n    Decimal.sub = sub;\r\n    Decimal.sum = sum;\r\n    Decimal.tan = tan;\r\n    Decimal.tanh = tanh;          // ES6\r\n    Decimal.trunc = trunc;        // ES6\r\n\r\n    if (obj === void 0) obj = {};\r\n    if (obj) {\r\n      if (obj.defaults !== true) {\r\n        ps = ['precision', 'rounding', 'toExpNeg', 'toExpPos', 'maxE', 'minE', 'modulo', 'crypto'];\r\n        for (i = 0; i < ps.length;) if (!obj.hasOwnProperty(p = ps[i++])) obj[p] = this[p];\r\n      }\r\n    }\r\n\r\n    Decimal.config(obj);\r\n\r\n    return Decimal;\r\n  }\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is `x` divided by `y`, rounded to `precision` significant\r\n   * digits using rounding mode `rounding`.\r\n   *\r\n   * x {number|string|Decimal}\r\n   * y {number|string|Decimal}\r\n   *\r\n   */\r\n  function div(x, y) {\r\n    return new this(x).div(y);\r\n  }\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the natural exponential of `x`, rounded to `precision`\r\n   * significant digits using rounding mode `rounding`.\r\n   *\r\n   * x {number|string|Decimal} The power to which to raise the base of the natural log.\r\n   *\r\n   */\r\n  function exp(x) {\r\n    return new this(x).exp();\r\n  }\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is `x` round to an integer using `ROUND_FLOOR`.\r\n   *\r\n   * x {number|string|Decimal}\r\n   *\r\n   */\r\n  function floor(x) {\r\n    return finalise(x = new this(x), x.e + 1, 3);\r\n  }\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the square root of the sum of the squares of the arguments,\r\n   * rounded to `precision` significant digits using rounding mode `rounding`.\r\n   *\r\n   * hypot(a, b, ...) = sqrt(a^2 + b^2 + ...)\r\n   *\r\n   * arguments {number|string|Decimal}\r\n   *\r\n   */\r\n  function hypot() {\r\n    var i, n,\r\n      t = new this(0);\r\n\r\n    external = false;\r\n\r\n    for (i = 0; i < arguments.length;) {\r\n      n = new this(arguments[i++]);\r\n      if (!n.d) {\r\n        if (n.s) {\r\n          external = true;\r\n          return new this(1 / 0);\r\n        }\r\n        t = n;\r\n      } else if (t.d) {\r\n        t = t.plus(n.times(n));\r\n      }\r\n    }\r\n\r\n    external = true;\r\n\r\n    return t.sqrt();\r\n  }\r\n\r\n\r\n  /*\r\n   * Return true if object is a Decimal instance (where Decimal is any Decimal constructor),\r\n   * otherwise return false.\r\n   *\r\n   */\r\n  function isDecimalInstance(obj) {\r\n    return obj instanceof Decimal || obj && obj.toStringTag === tag || false;\r\n  }\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the natural logarithm of `x`, rounded to `precision`\r\n   * significant digits using rounding mode `rounding`.\r\n   *\r\n   * x {number|string|Decimal}\r\n   *\r\n   */\r\n  function ln(x) {\r\n    return new this(x).ln();\r\n  }\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the log of `x` to the base `y`, or to base 10 if no base\r\n   * is specified, rounded to `precision` significant digits using rounding mode `rounding`.\r\n   *\r\n   * log[y](x)\r\n   *\r\n   * x {number|string|Decimal} The argument of the logarithm.\r\n   * y {number|string|Decimal} The base of the logarithm.\r\n   *\r\n   */\r\n  function log(x, y) {\r\n    return new this(x).log(y);\r\n  }\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the base 2 logarithm of `x`, rounded to `precision`\r\n   * significant digits using rounding mode `rounding`.\r\n   *\r\n   * x {number|string|Decimal}\r\n   *\r\n   */\r\n  function log2(x) {\r\n    return new this(x).log(2);\r\n  }\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the base 10 logarithm of `x`, rounded to `precision`\r\n   * significant digits using rounding mode `rounding`.\r\n   *\r\n   * x {number|string|Decimal}\r\n   *\r\n   */\r\n  function log10(x) {\r\n    return new this(x).log(10);\r\n  }\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the maximum of the arguments.\r\n   *\r\n   * arguments {number|string|Decimal}\r\n   *\r\n   */\r\n  function max() {\r\n    return maxOrMin(this, arguments, 'lt');\r\n  }\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the minimum of the arguments.\r\n   *\r\n   * arguments {number|string|Decimal}\r\n   *\r\n   */\r\n  function min() {\r\n    return maxOrMin(this, arguments, 'gt');\r\n  }\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is `x` modulo `y`, rounded to `precision` significant digits\r\n   * using rounding mode `rounding`.\r\n   *\r\n   * x {number|string|Decimal}\r\n   * y {number|string|Decimal}\r\n   *\r\n   */\r\n  function mod(x, y) {\r\n    return new this(x).mod(y);\r\n  }\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is `x` multiplied by `y`, rounded to `precision` significant\r\n   * digits using rounding mode `rounding`.\r\n   *\r\n   * x {number|string|Decimal}\r\n   * y {number|string|Decimal}\r\n   *\r\n   */\r\n  function mul(x, y) {\r\n    return new this(x).mul(y);\r\n  }\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is `x` raised to the power `y`, rounded to precision\r\n   * significant digits using rounding mode `rounding`.\r\n   *\r\n   * x {number|string|Decimal} The base.\r\n   * y {number|string|Decimal} The exponent.\r\n   *\r\n   */\r\n  function pow(x, y) {\r\n    return new this(x).pow(y);\r\n  }\r\n\r\n\r\n  /*\r\n   * Returns a new Decimal with a random value equal to or greater than 0 and less than 1, and with\r\n   * `sd`, or `Decimal.precision` if `sd` is omitted, significant digits (or less if trailing zeros\r\n   * are produced).\r\n   *\r\n   * [sd] {number} Significant digits. Integer, 0 to MAX_DIGITS inclusive.\r\n   *\r\n   */\r\n  function random(sd) {\r\n    var d, e, k, n,\r\n      i = 0,\r\n      r = new this(1),\r\n      rd = [];\r\n\r\n    if (sd === void 0) sd = this.precision;\r\n    else checkInt32(sd, 1, MAX_DIGITS);\r\n\r\n    k = Math.ceil(sd / LOG_BASE);\r\n\r\n    if (!this.crypto) {\r\n      for (; i < k;) rd[i++] = Math.random() * 1e7 | 0;\r\n\r\n    // Browsers supporting crypto.getRandomValues.\r\n    } else if (crypto.getRandomValues) {\r\n      d = crypto.getRandomValues(new Uint32Array(k));\r\n\r\n      for (; i < k;) {\r\n        n = d[i];\r\n\r\n        // 0 <= n < 4294967296\r\n        // Probability n >= 4.29e9, is 4967296 / 4294967296 = 0.00116 (1 in 865).\r\n        if (n >= 4.29e9) {\r\n          d[i] = crypto.getRandomValues(new Uint32Array(1))[0];\r\n        } else {\r\n\r\n          // 0 <= n <= 4289999999\r\n          // 0 <= (n % 1e7) <= 9999999\r\n          rd[i++] = n % 1e7;\r\n        }\r\n      }\r\n\r\n    // Node.js supporting crypto.randomBytes.\r\n    } else if (crypto.randomBytes) {\r\n\r\n      // buffer\r\n      d = crypto.randomBytes(k *= 4);\r\n\r\n      for (; i < k;) {\r\n\r\n        // 0 <= n < 2147483648\r\n        n = d[i] + (d[i + 1] << 8) + (d[i + 2] << 16) + ((d[i + 3] & 0x7f) << 24);\r\n\r\n        // Probability n >= 2.14e9, is 7483648 / 2147483648 = 0.0035 (1 in 286).\r\n        if (n >= 2.14e9) {\r\n          crypto.randomBytes(4).copy(d, i);\r\n        } else {\r\n\r\n          // 0 <= n <= 2139999999\r\n          // 0 <= (n % 1e7) <= 9999999\r\n          rd.push(n % 1e7);\r\n          i += 4;\r\n        }\r\n      }\r\n\r\n      i = k / 4;\r\n    } else {\r\n      throw Error(cryptoUnavailable);\r\n    }\r\n\r\n    k = rd[--i];\r\n    sd %= LOG_BASE;\r\n\r\n    // Convert trailing digits to zeros according to sd.\r\n    if (k && sd) {\r\n      n = mathpow(10, LOG_BASE - sd);\r\n      rd[i] = (k / n | 0) * n;\r\n    }\r\n\r\n    // Remove trailing words which are zero.\r\n    for (; rd[i] === 0; i--) rd.pop();\r\n\r\n    // Zero?\r\n    if (i < 0) {\r\n      e = 0;\r\n      rd = [0];\r\n    } else {\r\n      e = -1;\r\n\r\n      // Remove leading words which are zero and adjust exponent accordingly.\r\n      for (; rd[0] === 0; e -= LOG_BASE) rd.shift();\r\n\r\n      // Count the digits of the first word of rd to determine leading zeros.\r\n      for (k = 1, n = rd[0]; n >= 10; n /= 10) k++;\r\n\r\n      // Adjust the exponent for leading zeros of the first word of rd.\r\n      if (k < LOG_BASE) e -= LOG_BASE - k;\r\n    }\r\n\r\n    r.e = e;\r\n    r.d = rd;\r\n\r\n    return r;\r\n  }\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is `x` rounded to an integer using rounding mode `rounding`.\r\n   *\r\n   * To emulate `Math.round`, set rounding to 7 (ROUND_HALF_CEIL).\r\n   *\r\n   * x {number|string|Decimal}\r\n   *\r\n   */\r\n  function round(x) {\r\n    return finalise(x = new this(x), x.e + 1, this.rounding);\r\n  }\r\n\r\n\r\n  /*\r\n   * Return\r\n   *   1    if x > 0,\r\n   *  -1    if x < 0,\r\n   *   0    if x is 0,\r\n   *  -0    if x is -0,\r\n   *   NaN  otherwise\r\n   *\r\n   * x {number|string|Decimal}\r\n   *\r\n   */\r\n  function sign(x) {\r\n    x = new this(x);\r\n    return x.d ? (x.d[0] ? x.s : 0 * x.s) : x.s || NaN;\r\n  }\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the sine of `x`, rounded to `precision` significant digits\r\n   * using rounding mode `rounding`.\r\n   *\r\n   * x {number|string|Decimal} A value in radians.\r\n   *\r\n   */\r\n  function sin(x) {\r\n    return new this(x).sin();\r\n  }\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the hyperbolic sine of `x`, rounded to `precision`\r\n   * significant digits using rounding mode `rounding`.\r\n   *\r\n   * x {number|string|Decimal} A value in radians.\r\n   *\r\n   */\r\n  function sinh(x) {\r\n    return new this(x).sinh();\r\n  }\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the square root of `x`, rounded to `precision` significant\r\n   * digits using rounding mode `rounding`.\r\n   *\r\n   * x {number|string|Decimal}\r\n   *\r\n   */\r\n  function sqrt(x) {\r\n    return new this(x).sqrt();\r\n  }\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is `x` minus `y`, rounded to `precision` significant digits\r\n   * using rounding mode `rounding`.\r\n   *\r\n   * x {number|string|Decimal}\r\n   * y {number|string|Decimal}\r\n   *\r\n   */\r\n  function sub(x, y) {\r\n    return new this(x).sub(y);\r\n  }\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the sum of the arguments, rounded to `precision`\r\n   * significant digits using rounding mode `rounding`.\r\n   *\r\n   * Only the result is rounded, not the intermediate calculations.\r\n   *\r\n   * arguments {number|string|Decimal}\r\n   *\r\n   */\r\n  function sum() {\r\n    var i = 0,\r\n      args = arguments,\r\n      x = new this(args[i]);\r\n\r\n    external = false;\r\n    for (; x.s && ++i < args.length;) x = x.plus(args[i]);\r\n    external = true;\r\n\r\n    return finalise(x, this.precision, this.rounding);\r\n  }\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the tangent of `x`, rounded to `precision` significant\r\n   * digits using rounding mode `rounding`.\r\n   *\r\n   * x {number|string|Decimal} A value in radians.\r\n   *\r\n   */\r\n  function tan(x) {\r\n    return new this(x).tan();\r\n  }\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the hyperbolic tangent of `x`, rounded to `precision`\r\n   * significant digits using rounding mode `rounding`.\r\n   *\r\n   * x {number|string|Decimal} A value in radians.\r\n   *\r\n   */\r\n  function tanh(x) {\r\n    return new this(x).tanh();\r\n  }\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is `x` truncated to an integer.\r\n   *\r\n   * x {number|string|Decimal}\r\n   *\r\n   */\r\n  function trunc(x) {\r\n    return finalise(x = new this(x), x.e + 1, 1);\r\n  }\r\n\r\n\r\n  // Create and configure initial Decimal constructor.\r\n  Decimal = clone(DEFAULTS);\r\n  Decimal.prototype.constructor = Decimal;\r\n  Decimal['default'] = Decimal.Decimal = Decimal;\r\n\r\n  // Create the internal constants from their string values.\r\n  LN10 = new Decimal(LN10);\r\n  PI = new Decimal(PI);\r\n\r\n\r\n  // Export.\r\n\r\n\r\n  // AMD.\r\n  if (typeof define == 'function' && define.amd) {\r\n    define(function () {\r\n      return Decimal;\r\n    });\r\n\r\n  // Node and other environments that support module.exports.\r\n  } else if (typeof module != 'undefined' && module.exports) {\r\n    if (typeof Symbol == 'function' && typeof Symbol.iterator == 'symbol') {\r\n      P[Symbol['for']('nodejs.util.inspect.custom')] = P.toString;\r\n      P[Symbol.toStringTag] = 'Decimal';\r\n    }\r\n\r\n    module.exports = Decimal;\r\n\r\n  // Browser.\r\n  } else {\r\n    if (!globalScope) {\r\n      globalScope = typeof self != 'undefined' && self && self.self == self ? self : window;\r\n    }\r\n\r\n    noConflict = globalScope.Decimal;\r\n    Decimal.noConflict = function () {\r\n      globalScope.Decimal = noConflict;\r\n      return Decimal;\r\n    };\r\n\r\n    globalScope.Decimal = Decimal;\r\n  }\r\n})(this);\r\n"],"sourceRoot":""}