{"version":3,"file":"numbro.min.js","sources":["../src/en-US.js","../src/unformatting.js","../src/validating.js","../src/parsing.js","../src/globalState.js","../src/loading.js","../node_modules/bignumber.js/bignumber.js","../src/formatting.js","../src/manipulating.js","../src/numbro.js"],"sourcesContent":["/*!\n * Copyright (c) 2017 Benjamin Van Ryseghem<benjamin@vanryseghem.com>\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\n\nmodule.exports = {\n    languageTag: \"en-US\",\n    delimiters: {\n        thousands: \",\",\n        decimal: \".\"\n    },\n    abbreviations: {\n        thousand: \"k\",\n        million: \"m\",\n        billion: \"b\",\n        trillion: \"t\"\n    },\n    spaceSeparated: false,\n    ordinal: function(number) {\n        let b = number % 10;\n        return (~~(number % 100 / 10) === 1) ? \"th\" : (b === 1) ? \"st\" : (b === 2) ? \"nd\" : (b === 3) ? \"rd\" : \"th\";\n    },\n    bytes: {\n        binarySuffixes: [\"B\", \"KiB\", \"MiB\", \"GiB\", \"TiB\", \"PiB\", \"EiB\", \"ZiB\", \"YiB\"],\n        decimalSuffixes: [\"B\", \"KB\", \"MB\", \"GB\", \"TB\", \"PB\", \"EB\", \"ZB\", \"YB\"]\n    },\n    currency: {\n        symbol: \"$\",\n        position: \"prefix\",\n        code: \"USD\"\n    },\n    currencyFormat: {\n        thousandSeparated: true,\n        totalLength: 4,\n        spaceSeparated: true,\n        spaceSeparatedCurrency: true\n    },\n    formats: {\n        fourDigits: {\n            totalLength: 4,\n            spaceSeparated: true\n        },\n        fullWithTwoDecimals: {\n            output: \"currency\",\n            thousandSeparated: true,\n            mantissa: 2\n        },\n        fullWithTwoDecimalsNoCurrency: {\n            thousandSeparated: true,\n            mantissa: 2\n        },\n        fullWithNoDecimals: {\n            output: \"currency\",\n            thousandSeparated: true,\n            mantissa: 0\n        }\n    }\n};\n","/*!\n * Copyright (c) 2017 Benjamin Van Ryseghem<benjamin@vanryseghem.com>\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\n\nconst allSuffixes = [\n    {key: \"ZiB\", factor: Math.pow(1024, 7)},\n    {key: \"ZB\", factor: Math.pow(1000, 7)},\n    {key: \"YiB\", factor: Math.pow(1024, 8)},\n    {key: \"YB\", factor: Math.pow(1000, 8)},\n    {key: \"TiB\", factor: Math.pow(1024, 4)},\n    {key: \"TB\", factor: Math.pow(1000, 4)},\n    {key: \"PiB\", factor: Math.pow(1024, 5)},\n    {key: \"PB\", factor: Math.pow(1000, 5)},\n    {key: \"MiB\", factor: Math.pow(1024, 2)},\n    {key: \"MB\", factor: Math.pow(1000, 2)},\n    {key: \"KiB\", factor: Math.pow(1024, 1)},\n    {key: \"KB\", factor: Math.pow(1000, 1)},\n    {key: \"GiB\", factor: Math.pow(1024, 3)},\n    {key: \"GB\", factor: Math.pow(1000, 3)},\n    {key: \"EiB\", factor: Math.pow(1024, 6)},\n    {key: \"EB\", factor: Math.pow(1000, 6)},\n    {key: \"B\", factor: 1}\n];\n\n/**\n * Generate a RegExp where S get all RegExp specific characters escaped.\n *\n * @param {string} s - string representing a RegExp\n * @return {string}\n */\nfunction escapeRegExp(s) {\n    return s.replace(/[-/\\\\^$*+?.()|[\\]{}]/g, \"\\\\$&\");\n}\n\n/**\n * Recursively compute the unformatted value.\n *\n * @param {string} inputString - string to unformat\n * @param {*} delimiters - Delimiters used to generate the inputString\n * @param {string} [currencySymbol] - symbol used for currency while generating the inputString\n * @param {function} ordinal - function used to generate an ordinal out of a number\n * @param {string} zeroFormat - string representing zero\n * @param {*} abbreviations - abbreviations used while generating the inputString\n * @param {NumbroFormat} format - format used while generating the inputString\n * @return {number|undefined}\n */\nfunction computeUnformattedValue(inputString, delimiters, currencySymbol, ordinal, zeroFormat, abbreviations, format) {\n    if (!isNaN(+inputString)) {\n        return +inputString;\n    }\n\n    let stripped = \"\";\n    // Negative\n\n    let newInput = inputString.replace(/(^[^(]*)\\((.*)\\)([^)]*$)/, \"$1$2$3\");\n\n    if (newInput !== inputString) {\n        return -1 * computeUnformattedValue(newInput, delimiters, currencySymbol, ordinal, zeroFormat, abbreviations, format);\n    }\n\n    // Byte\n\n    for (let i = 0; i < allSuffixes.length; i++) {\n        let suffix = allSuffixes[i];\n        stripped = inputString.replace(RegExp(`([0-9 ])(${suffix.key})$`), \"$1\");\n\n        if (stripped !== inputString) {\n            return computeUnformattedValue(stripped, delimiters, currencySymbol, ordinal, zeroFormat, abbreviations, format) * suffix.factor;\n        }\n    }\n\n    // Percent\n\n    stripped = inputString.replace(\"%\", \"\");\n\n    if (stripped !== inputString) {\n        return computeUnformattedValue(stripped, delimiters, currencySymbol, ordinal, zeroFormat, abbreviations, format) / 100;\n    }\n\n    // Ordinal\n\n    let possibleOrdinalValue = parseFloat(inputString);\n\n    if (isNaN(possibleOrdinalValue)) {\n        return undefined;\n    }\n\n    let ordinalString = ordinal(possibleOrdinalValue);\n    if (ordinalString && ordinalString !== \".\") { // if ordinal is \".\" it will be caught next round in the +inputString\n        stripped = inputString.replace(new RegExp(`${escapeRegExp(ordinalString)}$`), \"\");\n\n        if (stripped !== inputString) {\n            return computeUnformattedValue(stripped, delimiters, currencySymbol, ordinal, zeroFormat, abbreviations, format);\n        }\n    }\n\n    // Average\n\n    let inversedAbbreviations = {};\n    Object.keys(abbreviations).forEach((key) => {\n        inversedAbbreviations[abbreviations[key]] = key;\n    });\n\n    let abbreviationValues = Object.keys(inversedAbbreviations).sort().reverse();\n    let numberOfAbbreviations = abbreviationValues.length;\n\n    for (let i = 0; i < numberOfAbbreviations; i++) {\n        let value = abbreviationValues[i];\n        let key = inversedAbbreviations[value];\n\n        stripped = inputString.replace(value, \"\");\n        if (stripped !== inputString) {\n            let factor = undefined;\n            switch (key) { // eslint-disable-line default-case\n                case \"thousand\":\n                    factor = Math.pow(10, 3);\n                    break;\n                case \"million\":\n                    factor = Math.pow(10, 6);\n                    break;\n                case \"billion\":\n                    factor = Math.pow(10, 9);\n                    break;\n                case \"trillion\":\n                    factor = Math.pow(10, 12);\n                    break;\n            }\n            return computeUnformattedValue(stripped, delimiters, currencySymbol, ordinal, zeroFormat, abbreviations, format) * factor;\n        }\n    }\n\n    return undefined;\n}\n\n/**\n * Removes in one pass all formatting symbols.\n *\n * @param {string} inputString - string to unformat\n * @param {*} delimiters - Delimiters used to generate the inputString\n * @param {string} [currencySymbol] - symbol used for currency while generating the inputString\n * @return {string}\n */\nfunction removeFormattingSymbols(inputString, delimiters, currencySymbol) {\n    // Currency\n\n    let stripped = inputString.replace(currencySymbol, \"\");\n\n    // Thousand separators\n\n    stripped = stripped.replace(new RegExp(`([0-9])${escapeRegExp(delimiters.thousands)}([0-9])`, \"g\"), \"$1$2\");\n\n    // Decimal\n\n    stripped = stripped.replace(delimiters.decimal, \".\");\n\n    return stripped;\n}\n\n/**\n * Unformat a numbro-generated string to retrieve the original value.\n *\n * @param {string} inputString - string to unformat\n * @param {*} delimiters - Delimiters used to generate the inputString\n * @param {string} [currencySymbol] - symbol used for currency while generating the inputString\n * @param {function} ordinal - function used to generate an ordinal out of a number\n * @param {string} zeroFormat - string representing zero\n * @param {*} abbreviations - abbreviations used while generating the inputString\n * @param {NumbroFormat} format - format used while generating the inputString\n * @return {number|undefined}\n */\nfunction unformatValue(inputString, delimiters, currencySymbol = \"\", ordinal, zeroFormat, abbreviations, format) {\n    if (inputString === \"\") {\n        return undefined;\n    }\n\n    // Zero Format\n\n    if (inputString === zeroFormat) {\n        return 0;\n    }\n\n    let value = removeFormattingSymbols(inputString, delimiters, currencySymbol);\n    return computeUnformattedValue(value, delimiters, currencySymbol, ordinal, zeroFormat, abbreviations, format);\n}\n\n/**\n * Check if the INPUTSTRING represents a time.\n *\n * @param {string} inputString - string to check\n * @param {*} delimiters - Delimiters used while generating the inputString\n * @return {boolean}\n */\nfunction matchesTime(inputString, delimiters) {\n    let separators = inputString.indexOf(\":\") && delimiters.thousands !== \":\";\n\n    if (!separators) {\n        return false;\n    }\n\n    let segments = inputString.split(\":\");\n    if (segments.length !== 3) {\n        return false;\n    }\n\n    let hours = +segments[0];\n    let minutes = +segments[1];\n    let seconds = +segments[2];\n\n    return !isNaN(hours) && !isNaN(minutes) && !isNaN(seconds);\n}\n\n/**\n * Unformat a numbro-generated string representing a time to retrieve the original value.\n *\n * @param {string} inputString - string to unformat\n * @return {number}\n */\nfunction unformatTime(inputString) {\n    let segments = inputString.split(\":\");\n\n    let hours = +segments[0];\n    let minutes = +segments[1];\n    let seconds = +segments[2];\n\n    return seconds + 60 * minutes + 3600 * hours;\n}\n\n/**\n * Unformat a numbro-generated string to retrieve the original value.\n *\n * @param {string} inputString - string to unformat\n * @param {NumbroFormat} format - format used  while generating the inputString\n * @return {number}\n */\nfunction unformat(inputString, format) {\n    // Avoid circular references\n    const globalState = require(\"./globalState\");\n\n    let delimiters = globalState.currentDelimiters();\n    let currencySymbol = globalState.currentCurrency().symbol;\n    let ordinal = globalState.currentOrdinal();\n    let zeroFormat = globalState.getZeroFormat();\n    let abbreviations = globalState.currentAbbreviations();\n\n    let value = undefined;\n\n    if (typeof inputString === \"string\") {\n        if (matchesTime(inputString, delimiters)) {\n            value = unformatTime(inputString);\n        } else {\n            value = unformatValue(inputString, delimiters, currencySymbol, ordinal, zeroFormat, abbreviations, format);\n        }\n    } else if (typeof inputString === \"number\") {\n        value = inputString;\n    } else {\n        return undefined;\n    }\n\n    if (value === undefined) {\n        return undefined;\n    }\n\n    return value;\n}\n\nmodule.exports = {\n    unformat\n};\n","/*!\n * Copyright (c) 2017 Benjamin Van Ryseghem<benjamin@vanryseghem.com>\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\n\nlet unformatter = require(\"./unformatting\");\n\n// Simplified regexp supporting only `language`, `script`, and `region`\nconst bcp47RegExp = /^[a-z]{2,3}(-[a-zA-Z]{4})?(-([A-Z]{2}|[0-9]{3}))?$/;\n\nconst validOutputValues = [\n    \"currency\",\n    \"percent\",\n    \"byte\",\n    \"time\",\n    \"ordinal\",\n    \"number\"\n];\n\nconst validForceAverageValues = [\n    \"trillion\",\n    \"billion\",\n    \"million\",\n    \"thousand\"\n];\n\nconst validCurrencyPosition = [\n    \"prefix\",\n    \"infix\",\n    \"postfix\"\n];\n\nconst validNegativeValues = [\n    \"sign\",\n    \"parenthesis\"\n];\n\nconst validMandatoryAbbreviations = {\n    type: \"object\",\n    children: {\n        thousand: {\n            type: \"string\",\n            mandatory: true\n        },\n        million: {\n            type: \"string\",\n            mandatory: true\n        },\n        billion: {\n            type: \"string\",\n            mandatory: true\n        },\n        trillion: {\n            type: \"string\",\n            mandatory: true\n        }\n    },\n    mandatory: true\n};\n\nconst validAbbreviations = {\n    type: \"object\",\n    children: {\n        thousand: \"string\",\n        million: \"string\",\n        billion: \"string\",\n        trillion: \"string\"\n    }\n};\n\nconst validBaseValues = [\n    \"decimal\",\n    \"binary\",\n    \"general\"\n];\n\nconst validFormat = {\n    output: {\n        type: \"string\",\n        validValues: validOutputValues\n    },\n    base: {\n        type: \"string\",\n        validValues: validBaseValues,\n        restriction: (number, format) => format.output === \"byte\",\n        message: \"`base` must be provided only when the output is `byte`\",\n        mandatory: (format) => format.output === \"byte\"\n    },\n    characteristic: {\n        type: \"number\",\n        restriction: (number) => number >= 0,\n        message: \"value must be positive\"\n    },\n    prefix: \"string\",\n    postfix: \"string\",\n    forceAverage: {\n        type: \"string\",\n        validValues: validForceAverageValues\n    },\n    average: \"boolean\",\n    lowPrecision: {\n        type: \"boolean\",\n        restriction: (number, format) => format.average === true,\n        message: \"`lowPrecision` must be provided only when the option `average` is set\"\n    },\n    currencyPosition: {\n        type: \"string\",\n        validValues: validCurrencyPosition\n    },\n    currencySymbol: \"string\",\n    totalLength: {\n        type: \"number\",\n        restrictions: [\n            {\n                restriction: (number) => number >= 0,\n                message: \"value must be positive\"\n            },\n            {\n                restriction: (number, format) => !format.exponential,\n                message: \"`totalLength` is incompatible with `exponential`\"\n            }\n        ]\n    },\n    mantissa: {\n        type: \"number\",\n        restriction: (number) => number >= 0,\n        message: \"value must be positive\"\n    },\n    optionalMantissa: \"boolean\",\n    trimMantissa: \"boolean\",\n    roundingFunction: \"function\",\n    optionalCharacteristic: \"boolean\",\n    thousandSeparated: \"boolean\",\n    spaceSeparated: \"boolean\",\n    spaceSeparatedCurrency: \"boolean\",\n    spaceSeparatedAbbreviation: \"boolean\",\n    abbreviations: validAbbreviations,\n    negative: {\n        type: \"string\",\n        validValues: validNegativeValues\n    },\n    forceSign: \"boolean\",\n    exponential: {\n        type: \"boolean\"\n    },\n    prefixSymbol: {\n        type: \"boolean\",\n        restriction: (number, format) => format.output === \"percent\",\n        message: \"`prefixSymbol` can be provided only when the output is `percent`\"\n    }\n};\n\nconst validLanguage = {\n    languageTag: {\n        type: \"string\",\n        mandatory: true,\n        restriction: (tag) => {\n            return tag.match(bcp47RegExp);\n        },\n        message: \"the language tag must follow the BCP 47 specification (see https://tools.ieft.org/html/bcp47)\"\n    },\n    delimiters: {\n        type: \"object\",\n        children: {\n            thousands: \"string\",\n            decimal: \"string\",\n            thousandsSize: \"number\"\n        },\n        mandatory: true\n    },\n    abbreviations: validMandatoryAbbreviations,\n    spaceSeparated: \"boolean\",\n    spaceSeparatedCurrency: \"boolean\",\n    ordinal: {\n        type: \"function\",\n        mandatory: true\n    },\n    bytes: {\n        type: \"object\",\n        children: {\n            binarySuffixes: \"object\",\n            decimalSuffixes: \"object\"\n        }\n    },\n    currency: {\n        type: \"object\",\n        children: {\n            symbol: \"string\",\n            position: \"string\",\n            code: \"string\"\n        },\n        mandatory: true\n    },\n    defaults: \"format\",\n    ordinalFormat: \"format\",\n    byteFormat: \"format\",\n    percentageFormat: \"format\",\n    currencyFormat: \"format\",\n    timeDefaults: \"format\",\n    formats: {\n        type: \"object\",\n        children: {\n            fourDigits: {\n                type: \"format\",\n                mandatory: true\n            },\n            fullWithTwoDecimals: {\n                type: \"format\",\n                mandatory: true\n            },\n            fullWithTwoDecimalsNoCurrency: {\n                type: \"format\",\n                mandatory: true\n            },\n            fullWithNoDecimals: {\n                type: \"format\",\n                mandatory: true\n            }\n        }\n    }\n};\n\n/**\n * Check the validity of the provided input and format.\n * The check is NOT lazy.\n *\n * @param {string|number|Numbro} input - input to check\n * @param {NumbroFormat} format - format to check\n * @return {boolean} True when everything is correct\n */\nfunction validate(input, format) {\n    let validInput = validateInput(input);\n    let isFormatValid = validateFormat(format);\n\n    return validInput && isFormatValid;\n}\n\n/**\n * Check the validity of the numbro input.\n *\n * @param {string|number|Numbro} input - input to check\n * @return {boolean} True when everything is correct\n */\nfunction validateInput(input) {\n    let value = unformatter.unformat(input);\n\n    return value !== undefined;\n}\n\n/**\n * Check the validity of the provided format TOVALIDATE against SPEC.\n *\n * @param {NumbroFormat} toValidate - format to check\n * @param {*} spec - specification against which to check\n * @param {string} prefix - prefix use for error messages\n * @param {boolean} skipMandatoryCheck - `true` when the check for mandatory key must be skipped\n * @return {boolean} True when everything is correct\n */\nfunction validateSpec(toValidate, spec, prefix, skipMandatoryCheck = false) {\n    let results = Object.keys(toValidate).map((key) => {\n        if (!spec[key]) {\n            console.error(`${prefix} Invalid key: ${key}`); // eslint-disable-line no-console\n            return false;\n        }\n\n        let value = toValidate[key];\n        let data = spec[key];\n\n        if (typeof data === \"string\") {\n            data = {type: data};\n        }\n\n        if (data.type === \"format\") { // all formats are partial (a.k.a will be merged with some default values) thus no need to check mandatory values\n            let valid = validateSpec(value, validFormat, `[Validate ${key}]`, true);\n\n            if (!valid) {\n                return false;\n            }\n        } else if (typeof value !== data.type) {\n            console.error(`${prefix} ${key} type mismatched: \"${data.type}\" expected, \"${typeof value}\" provided`); // eslint-disable-line no-console\n            return false;\n        }\n\n        if (data.restrictions && data.restrictions.length) {\n            let length = data.restrictions.length;\n            for (let i = 0; i < length; i++) {\n                let {restriction, message} = data.restrictions[i];\n                if (!restriction(value, toValidate)) {\n                    console.error(`${prefix} ${key} invalid value: ${message}`); // eslint-disable-line no-console\n                    return false;\n                }\n            }\n        }\n\n        if (data.restriction && !data.restriction(value, toValidate)) {\n            console.error(`${prefix} ${key} invalid value: ${data.message}`); // eslint-disable-line no-console\n            return false;\n        }\n\n        if (data.validValues && data.validValues.indexOf(value) === -1) {\n            console.error(`${prefix} ${key} invalid value: must be among ${JSON.stringify(data.validValues)}, \"${value}\" provided`); // eslint-disable-line no-console\n            return false;\n        }\n\n        if (data.children) {\n            let valid = validateSpec(value, data.children, `[Validate ${key}]`);\n\n            if (!valid) {\n                return false;\n            }\n        }\n\n        return true;\n    });\n\n    if (!skipMandatoryCheck) {\n        results.push(...Object.keys(spec).map((key) => {\n            let data = spec[key];\n            if (typeof data === \"string\") {\n                data = {type: data};\n            }\n\n            if (data.mandatory) {\n                let mandatory = data.mandatory;\n                if (typeof mandatory === \"function\") {\n                    mandatory = mandatory(toValidate);\n                }\n\n                if (mandatory && toValidate[key] === undefined) {\n                    console.error(`${prefix} Missing mandatory key \"${key}\"`); // eslint-disable-line no-console\n                    return false;\n                }\n            }\n\n            return true;\n        }));\n    }\n\n    return results.reduce((acc, current) => {\n        return acc && current;\n    }, true);\n}\n\n/**\n * Check the provided FORMAT.\n *\n * @param {NumbroFormat} format - format to check\n * @return {boolean}\n */\nfunction validateFormat(format) {\n    return validateSpec(format, validFormat, \"[Validate format]\");\n}\n\n/**\n * Check the provided LANGUAGE.\n *\n * @param {NumbroLanguage} language - language to check\n * @return {boolean}\n */\nfunction validateLanguage(language) {\n    return validateSpec(language, validLanguage, \"[Validate language]\");\n}\n\nmodule.exports = {\n    validate,\n    validateFormat,\n    validateInput,\n    validateLanguage\n};\n","/*!\n * Copyright (c) 2017 Benjamin Van Ryseghem<benjamin@vanryseghem.com>\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\n\n/**\n * Parse the format STRING looking for a prefix. Append it to RESULT when found.\n *\n * @param {string} string - format\n * @param {NumbroFormat} result - Result accumulator\n * @return {string} - format\n */\nfunction parsePrefix(string, result) {\n    let match = string.match(/^{([^}]*)}/);\n    if (match) {\n        result.prefix = match[1];\n        return string.slice(match[0].length);\n    }\n\n    return string;\n}\n\n/**\n * Parse the format STRING looking for a postfix. Append it to RESULT when found.\n *\n * @param {string} string - format\n * @param {NumbroFormat} result - Result accumulator\n * @return {string} - format\n */\nfunction parsePostfix(string, result) {\n    let match = string.match(/{([^}]*)}$/);\n    if (match) {\n        result.postfix = match[1];\n\n        return string.slice(0, -match[0].length);\n    }\n\n    return string;\n}\n\n/**\n * Parse the format STRING looking for the output value. Append it to RESULT when found.\n *\n * @param {string} string - format\n * @param {NumbroFormat} result - Result accumulator\n */\nfunction parseOutput(string, result) {\n    if (string.indexOf(\"$\") !== -1) {\n        result.output = \"currency\";\n        return;\n    }\n\n    if (string.indexOf(\"%\") !== -1) {\n        result.output = \"percent\";\n        return;\n    }\n\n    if (string.indexOf(\"bd\") !== -1) {\n        result.output = \"byte\";\n        result.base = \"general\";\n        return;\n    }\n\n    if (string.indexOf(\"b\") !== -1) {\n        result.output = \"byte\";\n        result.base = \"binary\";\n        return;\n\n    }\n\n    if (string.indexOf(\"d\") !== -1) {\n        result.output = \"byte\";\n        result.base = \"decimal\";\n        return;\n\n    }\n\n    if (string.indexOf(\":\") !== -1) {\n        result.output = \"time\";\n        return;\n    }\n\n    if (string.indexOf(\"o\") !== -1) {\n        result.output = \"ordinal\";\n    }\n}\n\n/**\n * Parse the format STRING looking for the thousand separated value. Append it to RESULT when found.\n *\n * @param {string} string - format\n * @param {NumbroFormat} result - Result accumulator\n * @return {string} - format\n */\nfunction parseThousandSeparated(string, result) {\n    if (string.indexOf(\",\") !== -1) {\n        result.thousandSeparated = true;\n    }\n}\n\n/**\n * Parse the format STRING looking for the space separated value. Append it to RESULT when found.\n *\n * @param {string} string - format\n * @param {NumbroFormat} result - Result accumulator\n * @return {string} - format\n */\nfunction parseSpaceSeparated(string, result) {\n    if (string.indexOf(\" \") !== -1) {\n        result.spaceSeparated = true;\n        result.spaceSeparatedCurrency = true;\n\n        if (result.average || result.forceAverage) {\n            result.spaceSeparatedAbbreviation = true;\n        }\n    }\n}\n\n/**\n * Parse the format STRING looking for the total length. Append it to RESULT when found.\n *\n * @param {string} string - format\n * @param {NumbroFormat} result - Result accumulator\n * @return {string} - format\n */\nfunction parseTotalLength(string, result) {\n    let match = string.match(/[1-9]+[0-9]*/);\n\n    if (match) {\n        result.totalLength = +match[0];\n    }\n}\n\n/**\n * Parse the format STRING looking for the characteristic length. Append it to RESULT when found.\n *\n * @param {string} string - format\n * @param {NumbroFormat} result - Result accumulator\n * @return {string} - format\n */\nfunction parseCharacteristic(string, result) {\n    let characteristic = string.split(\".\")[0];\n    let match = characteristic.match(/0+/);\n    if (match) {\n        result.characteristic = match[0].length;\n    }\n}\n\n/**\n * Parse the format STRING looking for the mantissa length. Append it to RESULT when found.\n *\n * @param {string} string - format\n * @param {NumbroFormat} result - Result accumulator\n * @return {string} - format\n */\nfunction parseMantissa(string, result) {\n    let mantissa = string.split(\".\")[1];\n    if (mantissa) {\n        let match = mantissa.match(/0+/);\n        if (match) {\n            result.mantissa = match[0].length;\n        }\n    }\n}\n\n/**\n * Parse the format STRING looking for a trimmed mantissa. Append it to RESULT when found.\n *\n * @param {string} string - format\n * @param {NumbroFormat} result - Result accumulator\n */\nfunction parseTrimMantissa(string, result) {\n    const mantissa = string.split(\".\")[1];\n    if (mantissa) {\n        result.trimMantissa = mantissa.indexOf(\"[\") !== -1;\n    }\n}\n\n/**\n * Parse the format STRING looking for the average value. Append it to RESULT when found.\n *\n * @param {string} string - format\n * @param {NumbroFormat} result - Result accumulator\n * @return {string} - format\n */\nfunction parseAverage(string, result) {\n    if (string.indexOf(\"a\") !== -1) {\n        result.average = true;\n    }\n}\n\n/**\n * Parse the format STRING looking for a forced average precision. Append it to RESULT when found.\n *\n * @param {string} string - format\n * @param {NumbroFormat} result - Result accumulator\n * @return {string} - format\n */\nfunction parseForceAverage(string, result) {\n    if (string.indexOf(\"K\") !== -1) {\n        result.forceAverage = \"thousand\";\n    } else if (string.indexOf(\"M\") !== -1) {\n        result.forceAverage = \"million\";\n    } else if (string.indexOf(\"B\") !== -1) {\n        result.forceAverage = \"billion\";\n    } else if (string.indexOf(\"T\") !== -1) {\n        result.forceAverage = \"trillion\";\n    }\n}\n\n/**\n * Parse the format STRING finding if the mantissa is optional. Append it to RESULT when found.\n *\n * @param {string} string - format\n * @param {NumbroFormat} result - Result accumulator\n * @return {string} - format\n */\nfunction parseOptionalMantissa(string, result) {\n    if (string.match(/\\[\\.]/)) {\n        result.optionalMantissa = true;\n    } else if (string.match(/\\./)) {\n        result.optionalMantissa = false;\n    }\n}\n\n/**\n * Parse the format STRING finding if the characteristic is optional. Append it to RESULT when found.\n *\n * @param {string} string - format\n * @param {NumbroFormat} result - Result accumulator\n * @return {string} - format\n */\nfunction parseOptionalCharacteristic(string, result) {\n    if (string.indexOf(\".\") !== -1) {\n        let characteristic = string.split(\".\")[0];\n        result.optionalCharacteristic = characteristic.indexOf(\"0\") === -1;\n    }\n}\n\n/**\n * Parse the format STRING looking for the negative format. Append it to RESULT when found.\n *\n * @param {string} string - format\n * @param {NumbroFormat} result - Result accumulator\n * @return {string} - format\n */\nfunction parseNegative(string, result) {\n    if (string.match(/^\\+?\\([^)]*\\)$/)) {\n        result.negative = \"parenthesis\";\n    }\n    if (string.match(/^\\+?-/)) {\n        result.negative = \"sign\";\n    }\n}\n\n/**\n * Parse the format STRING finding if the sign is mandatory. Append it to RESULT when found.\n *\n * @param {string} string - format\n * @param {NumbroFormat} result - Result accumulator\n */\nfunction parseForceSign(string, result) {\n    if (string.match(/^\\+/)) {\n        result.forceSign = true;\n    }\n}\n\n/**\n * Parse the format STRING and accumulating the values ie RESULT.\n *\n * @param {string} string - format\n * @param {NumbroFormat} result - Result accumulator\n * @return {NumbroFormat} - format\n */\nfunction parseFormat(string, result = {}) {\n    if (typeof string !== \"string\") {\n        return string;\n    }\n\n    string = parsePrefix(string, result);\n    string = parsePostfix(string, result);\n    parseOutput(string, result);\n    parseTotalLength(string, result);\n    parseCharacteristic(string, result);\n    parseOptionalCharacteristic(string, result);\n    parseAverage(string, result);\n    parseForceAverage(string, result);\n    parseMantissa(string, result);\n    parseOptionalMantissa(string, result);\n    parseTrimMantissa(string, result);\n    parseThousandSeparated(string, result);\n    parseSpaceSeparated(string, result);\n    parseNegative(string, result);\n    parseForceSign(string, result);\n\n    return result;\n}\n\nmodule.exports = {\n    parseFormat\n};\n","/*!\n * Copyright (c) 2017 Benjamin Van Ryseghem<benjamin@vanryseghem.com>\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\n\nconst enUS = require(\"./en-US\");\nconst validating = require(\"./validating\");\nconst parsing = require(\"./parsing\");\n\nlet state = {};\n\nlet currentLanguageTag = undefined;\nlet languages = {};\n\nlet zeroFormat = null;\n\nlet globalDefaults = {};\n\nfunction chooseLanguage(tag) { currentLanguageTag = tag; }\n\nfunction currentLanguageData() { return languages[currentLanguageTag]; }\n\n/**\n * Return all the register languages\n *\n * @return {{}}\n */\nstate.languages = () => Object.assign({}, languages);\n\n//\n// Current language accessors\n//\n\n/**\n * Return the current language tag\n *\n * @return {string}\n */\nstate.currentLanguage = () => currentLanguageTag;\n\n/**\n * Return the current language bytes data\n *\n * @return {{}}\n */\nstate.currentBytes = () => currentLanguageData().bytes || {};\n\n/**\n * Return the current language currency data\n *\n * @return {{}}\n */\nstate.currentCurrency = () => currentLanguageData().currency;\n\n/**\n * Return the current language abbreviations data\n *\n * @return {{}}\n */\nstate.currentAbbreviations = () => currentLanguageData().abbreviations;\n\n/**\n * Return the current language delimiters data\n *\n * @return {{}}\n */\nstate.currentDelimiters = () => currentLanguageData().delimiters;\n\n/**\n * Return the current language ordinal function\n *\n * @return {function}\n */\nstate.currentOrdinal = () => currentLanguageData().ordinal;\n\n//\n// Defaults\n//\n\n/**\n * Return the current formatting defaults.\n * First use the current language default, then fallback to the globally defined defaults.\n *\n * @return {{}}\n */\nstate.currentDefaults = () => Object.assign({}, currentLanguageData().defaults, globalDefaults);\n\n/**\n * Return the ordinal default-format.\n * First use the current language ordinal default, then fallback to the regular defaults.\n *\n * @return {{}}\n */\nstate.currentOrdinalDefaultFormat = () => Object.assign({}, state.currentDefaults(), currentLanguageData().ordinalFormat);\n\n/**\n * Return the byte default-format.\n * First use the current language byte default, then fallback to the regular defaults.\n *\n * @return {{}}\n */\nstate.currentByteDefaultFormat = () => Object.assign({}, state.currentDefaults(), currentLanguageData().byteFormat);\n\n/**\n * Return the percentage default-format.\n * First use the current language percentage default, then fallback to the regular defaults.\n *\n * @return {{}}\n */\nstate.currentPercentageDefaultFormat = () => Object.assign({}, state.currentDefaults(), currentLanguageData().percentageFormat);\n\n/**\n * Return the currency default-format.\n * First use the current language currency default, then fallback to the regular defaults.\n *\n * @return {{}}\n */\nstate.currentCurrencyDefaultFormat = () => Object.assign({}, state.currentDefaults(), currentLanguageData().currencyFormat);\n\n/**\n * Return the time default-format.\n * First use the current language currency default, then fallback to the regular defaults.\n *\n * @return {{}}\n */\nstate.currentTimeDefaultFormat = () => Object.assign({}, state.currentDefaults(), currentLanguageData().timeFormat);\n\n/**\n * Set the global formatting defaults.\n *\n * @param {{}|string} format - formatting options to use as defaults\n */\nstate.setDefaults = (format) => {\n    format = parsing.parseFormat(format);\n    if (validating.validateFormat(format)) {\n        globalDefaults = format;\n    }\n};\n\n//\n// Zero format\n//\n\n/**\n * Return the format string for 0.\n *\n * @return {string}\n */\nstate.getZeroFormat = () => zeroFormat;\n\n/**\n * Set a STRING to output when the value is 0.\n *\n * @param {{}|string} string - string to set\n */\nstate.setZeroFormat = (string) => zeroFormat = typeof(string) === \"string\" ? string : null;\n\n/**\n * Return true if a format for 0 has been set already.\n *\n * @return {boolean}\n */\nstate.hasZeroFormat = () => zeroFormat !== null;\n\n//\n// Getters/Setters\n//\n\n/**\n * Return the language data for the provided TAG.\n * Return the current language data if no tag is provided.\n *\n * Throw an error if the tag doesn't match any registered language.\n *\n * @param {string} [tag] - language tag of a registered language\n * @return {{}}\n */\nstate.languageData = (tag) => {\n    if (tag) {\n        if (languages[tag]) {\n            return languages[tag];\n        }\n        throw new Error(`Unknown tag \"${tag}\"`);\n    }\n\n    return currentLanguageData();\n};\n\n/**\n * Register the provided DATA as a language if and only if the data is valid.\n * If the data is not valid, an error is thrown.\n *\n * When USELANGUAGE is true, the registered language is then used.\n *\n * @param {{}} data - language data to register\n * @param {boolean} [useLanguage] - `true` if the provided data should become the current language\n */\nstate.registerLanguage = (data, useLanguage = false) => {\n    if (!validating.validateLanguage(data)) {\n        throw new Error(\"Invalid language data\");\n    }\n\n    languages[data.languageTag] = data;\n\n    if (useLanguage) {\n        chooseLanguage(data.languageTag);\n    }\n};\n\n/**\n * Set the current language according to TAG.\n * If TAG doesn't match a registered language, another language matching\n * the \"language\" part of the tag (according to BCP47: https://tools.ietf.org/rfc/bcp/bcp47.txt).\n * If none, the FALLBACKTAG is used. If the FALLBACKTAG doesn't match a register language,\n * `en-US` is finally used.\n *\n * @param tag\n * @param fallbackTag\n */\nstate.setLanguage = (tag, fallbackTag = enUS.languageTag) => {\n    if (!languages[tag]) {\n        let suffix = tag.split(\"-\")[0];\n\n        let matchingLanguageTag = Object.keys(languages).find(each => {\n            return each.split(\"-\")[0] === suffix;\n        });\n\n        if (!languages[matchingLanguageTag]) {\n            chooseLanguage(fallbackTag);\n            return;\n        }\n\n        chooseLanguage(matchingLanguageTag);\n        return;\n    }\n\n    chooseLanguage(tag);\n};\n\nstate.registerLanguage(enUS);\ncurrentLanguageTag = enUS.languageTag;\n\nmodule.exports = state;\n","/*!\n * Copyright (c) 2017 Benjamin Van Ryseghem<benjamin@vanryseghem.com>\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\n\n/**\n * Load languages matching TAGS. Silently pass over the failing load.\n *\n * We assume here that we are in a node environment, so we don't check for it.\n * @param {[String]} tags - list of tags to load\n * @param {Numbro} numbro - the numbro singleton\n */\nfunction loadLanguagesInNode(tags, numbro) {\n    tags.forEach((tag) => {\n        let data = undefined;\n        try {\n            data = require(`../languages/${tag}`);\n        } catch (e) {\n            console.error(`Unable to load \"${tag}\". No matching language file found.`); // eslint-disable-line no-console\n        }\n\n        if (data) {\n            numbro.registerLanguage(data);\n        }\n    });\n}\n\nmodule.exports = (numbro) => ({\n    loadLanguagesInNode: (tags) => loadLanguagesInNode(tags, numbro)\n});\n",";(function (globalObject) {\r\n  'use strict';\r\n\r\n/*\r\n *      bignumber.js v9.1.2\r\n *      A JavaScript library for arbitrary-precision arithmetic.\r\n *      https://github.com/MikeMcl/bignumber.js\r\n *      Copyright (c) 2022 Michael Mclaughlin <M8ch88l@gmail.com>\r\n *      MIT Licensed.\r\n *\r\n *      BigNumber.prototype methods     |  BigNumber methods\r\n *                                      |\r\n *      absoluteValue            abs    |  clone\r\n *      comparedTo                      |  config               set\r\n *      decimalPlaces            dp     |      DECIMAL_PLACES\r\n *      dividedBy                div    |      ROUNDING_MODE\r\n *      dividedToIntegerBy       idiv   |      EXPONENTIAL_AT\r\n *      exponentiatedBy          pow    |      RANGE\r\n *      integerValue                    |      CRYPTO\r\n *      isEqualTo                eq     |      MODULO_MODE\r\n *      isFinite                        |      POW_PRECISION\r\n *      isGreaterThan            gt     |      FORMAT\r\n *      isGreaterThanOrEqualTo   gte    |      ALPHABET\r\n *      isInteger                       |  isBigNumber\r\n *      isLessThan               lt     |  maximum              max\r\n *      isLessThanOrEqualTo      lte    |  minimum              min\r\n *      isNaN                           |  random\r\n *      isNegative                      |  sum\r\n *      isPositive                      |\r\n *      isZero                          |\r\n *      minus                           |\r\n *      modulo                   mod    |\r\n *      multipliedBy             times  |\r\n *      negated                         |\r\n *      plus                            |\r\n *      precision                sd     |\r\n *      shiftedBy                       |\r\n *      squareRoot               sqrt   |\r\n *      toExponential                   |\r\n *      toFixed                         |\r\n *      toFormat                        |\r\n *      toFraction                      |\r\n *      toJSON                          |\r\n *      toNumber                        |\r\n *      toPrecision                     |\r\n *      toString                        |\r\n *      valueOf                         |\r\n *\r\n */\r\n\r\n\r\n  var BigNumber,\r\n    isNumeric = /^-?(?:\\d+(?:\\.\\d*)?|\\.\\d+)(?:e[+-]?\\d+)?$/i,\r\n    mathceil = Math.ceil,\r\n    mathfloor = Math.floor,\r\n\r\n    bignumberError = '[BigNumber Error] ',\r\n    tooManyDigits = bignumberError + 'Number primitive has more than 15 significant digits: ',\r\n\r\n    BASE = 1e14,\r\n    LOG_BASE = 14,\r\n    MAX_SAFE_INTEGER = 0x1fffffffffffff,         // 2^53 - 1\r\n    // MAX_INT32 = 0x7fffffff,                   // 2^31 - 1\r\n    POWS_TEN = [1, 10, 100, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, 1e10, 1e11, 1e12, 1e13],\r\n    SQRT_BASE = 1e7,\r\n\r\n    // EDITABLE\r\n    // The limit on the value of DECIMAL_PLACES, TO_EXP_NEG, TO_EXP_POS, MIN_EXP, MAX_EXP, and\r\n    // the arguments to toExponential, toFixed, toFormat, and toPrecision.\r\n    MAX = 1E9;                                   // 0 to MAX_INT32\r\n\r\n\r\n  /*\r\n   * Create and return a BigNumber constructor.\r\n   */\r\n  function clone(configObject) {\r\n    var div, convertBase, parseNumeric,\r\n      P = BigNumber.prototype = { constructor: BigNumber, toString: null, valueOf: null },\r\n      ONE = new BigNumber(1),\r\n\r\n\r\n      //----------------------------- EDITABLE CONFIG DEFAULTS -------------------------------\r\n\r\n\r\n      // The default values below must be integers within the inclusive ranges stated.\r\n      // The values can also be changed at run-time using BigNumber.set.\r\n\r\n      // The maximum number of decimal places for operations involving division.\r\n      DECIMAL_PLACES = 20,                     // 0 to MAX\r\n\r\n      // The rounding mode used when rounding to the above decimal places, and when using\r\n      // toExponential, toFixed, toFormat and toPrecision, and round (default value).\r\n      // UP         0 Away from zero.\r\n      // DOWN       1 Towards zero.\r\n      // CEIL       2 Towards +Infinity.\r\n      // FLOOR      3 Towards -Infinity.\r\n      // HALF_UP    4 Towards nearest neighbour. If equidistant, up.\r\n      // HALF_DOWN  5 Towards nearest neighbour. If equidistant, down.\r\n      // HALF_EVEN  6 Towards nearest neighbour. If equidistant, towards even neighbour.\r\n      // HALF_CEIL  7 Towards nearest neighbour. If equidistant, towards +Infinity.\r\n      // HALF_FLOOR 8 Towards nearest neighbour. If equidistant, towards -Infinity.\r\n      ROUNDING_MODE = 4,                       // 0 to 8\r\n\r\n      // EXPONENTIAL_AT : [TO_EXP_NEG , TO_EXP_POS]\r\n\r\n      // The exponent value at and beneath which toString returns exponential notation.\r\n      // Number type: -7\r\n      TO_EXP_NEG = -7,                         // 0 to -MAX\r\n\r\n      // The exponent value at and above which toString returns exponential notation.\r\n      // Number type: 21\r\n      TO_EXP_POS = 21,                         // 0 to MAX\r\n\r\n      // RANGE : [MIN_EXP, MAX_EXP]\r\n\r\n      // The minimum exponent value, beneath which underflow to zero occurs.\r\n      // Number type: -324  (5e-324)\r\n      MIN_EXP = -1e7,                          // -1 to -MAX\r\n\r\n      // The maximum exponent value, above which overflow to Infinity occurs.\r\n      // Number type:  308  (1.7976931348623157e+308)\r\n      // For MAX_EXP > 1e7, e.g. new BigNumber('1e100000000').plus(1) may be slow.\r\n      MAX_EXP = 1e7,                           // 1 to MAX\r\n\r\n      // Whether to use cryptographically-secure random number generation, if available.\r\n      CRYPTO = false,                          // true or false\r\n\r\n      // The modulo mode used when calculating the modulus: a mod n.\r\n      // The quotient (q = a / n) is calculated according to the corresponding rounding mode.\r\n      // The remainder (r) is calculated as: r = a - n * q.\r\n      //\r\n      // UP        0 The remainder is positive if the dividend is negative, else is negative.\r\n      // DOWN      1 The remainder has the same sign as the dividend.\r\n      //             This modulo mode is commonly known as 'truncated division' and is\r\n      //             equivalent to (a % n) in JavaScript.\r\n      // FLOOR     3 The remainder has the same sign as the divisor (Python %).\r\n      // HALF_EVEN 6 This modulo mode implements the IEEE 754 remainder function.\r\n      // EUCLID    9 Euclidian division. q = sign(n) * floor(a / abs(n)).\r\n      //             The remainder is always positive.\r\n      //\r\n      // The truncated division, floored division, Euclidian division and IEEE 754 remainder\r\n      // modes are commonly used for the modulus operation.\r\n      // Although the other rounding modes can also be used, they may not give useful results.\r\n      MODULO_MODE = 1,                         // 0 to 9\r\n\r\n      // The maximum number of significant digits of the result of the exponentiatedBy operation.\r\n      // If POW_PRECISION is 0, there will be unlimited significant digits.\r\n      POW_PRECISION = 0,                       // 0 to MAX\r\n\r\n      // The format specification used by the BigNumber.prototype.toFormat method.\r\n      FORMAT = {\r\n        prefix: '',\r\n        groupSize: 3,\r\n        secondaryGroupSize: 0,\r\n        groupSeparator: ',',\r\n        decimalSeparator: '.',\r\n        fractionGroupSize: 0,\r\n        fractionGroupSeparator: '\\xA0',        // non-breaking space\r\n        suffix: ''\r\n      },\r\n\r\n      // The alphabet used for base conversion. It must be at least 2 characters long, with no '+',\r\n      // '-', '.', whitespace, or repeated character.\r\n      // '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ$_'\r\n      ALPHABET = '0123456789abcdefghijklmnopqrstuvwxyz',\r\n      alphabetHasNormalDecimalDigits = true;\r\n\r\n\r\n    //------------------------------------------------------------------------------------------\r\n\r\n\r\n    // CONSTRUCTOR\r\n\r\n\r\n    /*\r\n     * The BigNumber constructor and exported function.\r\n     * Create and return a new instance of a BigNumber object.\r\n     *\r\n     * v {number|string|BigNumber} A numeric value.\r\n     * [b] {number} The base of v. Integer, 2 to ALPHABET.length inclusive.\r\n     */\r\n    function BigNumber(v, b) {\r\n      var alphabet, c, caseChanged, e, i, isNum, len, str,\r\n        x = this;\r\n\r\n      // Enable constructor call without `new`.\r\n      if (!(x instanceof BigNumber)) return new BigNumber(v, b);\r\n\r\n      if (b == null) {\r\n\r\n        if (v && v._isBigNumber === true) {\r\n          x.s = v.s;\r\n\r\n          if (!v.c || v.e > MAX_EXP) {\r\n            x.c = x.e = null;\r\n          } else if (v.e < MIN_EXP) {\r\n            x.c = [x.e = 0];\r\n          } else {\r\n            x.e = v.e;\r\n            x.c = v.c.slice();\r\n          }\r\n\r\n          return;\r\n        }\r\n\r\n        if ((isNum = typeof v == 'number') && v * 0 == 0) {\r\n\r\n          // Use `1 / n` to handle minus zero also.\r\n          x.s = 1 / v < 0 ? (v = -v, -1) : 1;\r\n\r\n          // Fast path for integers, where n < 2147483648 (2**31).\r\n          if (v === ~~v) {\r\n            for (e = 0, i = v; i >= 10; i /= 10, e++);\r\n\r\n            if (e > MAX_EXP) {\r\n              x.c = x.e = null;\r\n            } else {\r\n              x.e = e;\r\n              x.c = [v];\r\n            }\r\n\r\n            return;\r\n          }\r\n\r\n          str = String(v);\r\n        } else {\r\n\r\n          if (!isNumeric.test(str = String(v))) return parseNumeric(x, str, isNum);\r\n\r\n          x.s = str.charCodeAt(0) == 45 ? (str = str.slice(1), -1) : 1;\r\n        }\r\n\r\n        // Decimal point?\r\n        if ((e = str.indexOf('.')) > -1) str = str.replace('.', '');\r\n\r\n        // Exponential form?\r\n        if ((i = str.search(/e/i)) > 0) {\r\n\r\n          // Determine exponent.\r\n          if (e < 0) e = i;\r\n          e += +str.slice(i + 1);\r\n          str = str.substring(0, i);\r\n        } else if (e < 0) {\r\n\r\n          // Integer.\r\n          e = str.length;\r\n        }\r\n\r\n      } else {\r\n\r\n        // '[BigNumber Error] Base {not a primitive number|not an integer|out of range}: {b}'\r\n        intCheck(b, 2, ALPHABET.length, 'Base');\r\n\r\n        // Allow exponential notation to be used with base 10 argument, while\r\n        // also rounding to DECIMAL_PLACES as with other bases.\r\n        if (b == 10 && alphabetHasNormalDecimalDigits) {\r\n          x = new BigNumber(v);\r\n          return round(x, DECIMAL_PLACES + x.e + 1, ROUNDING_MODE);\r\n        }\r\n\r\n        str = String(v);\r\n\r\n        if (isNum = typeof v == 'number') {\r\n\r\n          // Avoid potential interpretation of Infinity and NaN as base 44+ values.\r\n          if (v * 0 != 0) return parseNumeric(x, str, isNum, b);\r\n\r\n          x.s = 1 / v < 0 ? (str = str.slice(1), -1) : 1;\r\n\r\n          // '[BigNumber Error] Number primitive has more than 15 significant digits: {n}'\r\n          if (BigNumber.DEBUG && str.replace(/^0\\.0*|\\./, '').length > 15) {\r\n            throw Error\r\n             (tooManyDigits + v);\r\n          }\r\n        } else {\r\n          x.s = str.charCodeAt(0) === 45 ? (str = str.slice(1), -1) : 1;\r\n        }\r\n\r\n        alphabet = ALPHABET.slice(0, b);\r\n        e = i = 0;\r\n\r\n        // Check that str is a valid base b number.\r\n        // Don't use RegExp, so alphabet can contain special characters.\r\n        for (len = str.length; i < len; i++) {\r\n          if (alphabet.indexOf(c = str.charAt(i)) < 0) {\r\n            if (c == '.') {\r\n\r\n              // If '.' is not the first character and it has not be found before.\r\n              if (i > e) {\r\n                e = len;\r\n                continue;\r\n              }\r\n            } else if (!caseChanged) {\r\n\r\n              // Allow e.g. hexadecimal 'FF' as well as 'ff'.\r\n              if (str == str.toUpperCase() && (str = str.toLowerCase()) ||\r\n                  str == str.toLowerCase() && (str = str.toUpperCase())) {\r\n                caseChanged = true;\r\n                i = -1;\r\n                e = 0;\r\n                continue;\r\n              }\r\n            }\r\n\r\n            return parseNumeric(x, String(v), isNum, b);\r\n          }\r\n        }\r\n\r\n        // Prevent later check for length on converted number.\r\n        isNum = false;\r\n        str = convertBase(str, b, 10, x.s);\r\n\r\n        // Decimal point?\r\n        if ((e = str.indexOf('.')) > -1) str = str.replace('.', '');\r\n        else e = str.length;\r\n      }\r\n\r\n      // Determine leading zeros.\r\n      for (i = 0; str.charCodeAt(i) === 48; i++);\r\n\r\n      // Determine trailing zeros.\r\n      for (len = str.length; str.charCodeAt(--len) === 48;);\r\n\r\n      if (str = str.slice(i, ++len)) {\r\n        len -= i;\r\n\r\n        // '[BigNumber Error] Number primitive has more than 15 significant digits: {n}'\r\n        if (isNum && BigNumber.DEBUG &&\r\n          len > 15 && (v > MAX_SAFE_INTEGER || v !== mathfloor(v))) {\r\n            throw Error\r\n             (tooManyDigits + (x.s * v));\r\n        }\r\n\r\n         // Overflow?\r\n        if ((e = e - i - 1) > MAX_EXP) {\r\n\r\n          // Infinity.\r\n          x.c = x.e = null;\r\n\r\n        // Underflow?\r\n        } else if (e < MIN_EXP) {\r\n\r\n          // Zero.\r\n          x.c = [x.e = 0];\r\n        } else {\r\n          x.e = e;\r\n          x.c = [];\r\n\r\n          // Transform base\r\n\r\n          // e is the base 10 exponent.\r\n          // i is where to slice str to get the first element of the coefficient array.\r\n          i = (e + 1) % LOG_BASE;\r\n          if (e < 0) i += LOG_BASE;  // i < 1\r\n\r\n          if (i < len) {\r\n            if (i) x.c.push(+str.slice(0, i));\r\n\r\n            for (len -= LOG_BASE; i < len;) {\r\n              x.c.push(+str.slice(i, i += LOG_BASE));\r\n            }\r\n\r\n            i = LOG_BASE - (str = str.slice(i)).length;\r\n          } else {\r\n            i -= len;\r\n          }\r\n\r\n          for (; i--; str += '0');\r\n          x.c.push(+str);\r\n        }\r\n      } else {\r\n\r\n        // Zero.\r\n        x.c = [x.e = 0];\r\n      }\r\n    }\r\n\r\n\r\n    // CONSTRUCTOR PROPERTIES\r\n\r\n\r\n    BigNumber.clone = clone;\r\n\r\n    BigNumber.ROUND_UP = 0;\r\n    BigNumber.ROUND_DOWN = 1;\r\n    BigNumber.ROUND_CEIL = 2;\r\n    BigNumber.ROUND_FLOOR = 3;\r\n    BigNumber.ROUND_HALF_UP = 4;\r\n    BigNumber.ROUND_HALF_DOWN = 5;\r\n    BigNumber.ROUND_HALF_EVEN = 6;\r\n    BigNumber.ROUND_HALF_CEIL = 7;\r\n    BigNumber.ROUND_HALF_FLOOR = 8;\r\n    BigNumber.EUCLID = 9;\r\n\r\n\r\n    /*\r\n     * Configure infrequently-changing library-wide settings.\r\n     *\r\n     * Accept an object with the following optional properties (if the value of a property is\r\n     * a number, it must be an integer within the inclusive range stated):\r\n     *\r\n     *   DECIMAL_PLACES   {number}           0 to MAX\r\n     *   ROUNDING_MODE    {number}           0 to 8\r\n     *   EXPONENTIAL_AT   {number|number[]}  -MAX to MAX  or  [-MAX to 0, 0 to MAX]\r\n     *   RANGE            {number|number[]}  -MAX to MAX (not zero)  or  [-MAX to -1, 1 to MAX]\r\n     *   CRYPTO           {boolean}          true or false\r\n     *   MODULO_MODE      {number}           0 to 9\r\n     *   POW_PRECISION       {number}           0 to MAX\r\n     *   ALPHABET         {string}           A string of two or more unique characters which does\r\n     *                                       not contain '.'.\r\n     *   FORMAT           {object}           An object with some of the following properties:\r\n     *     prefix                 {string}\r\n     *     groupSize              {number}\r\n     *     secondaryGroupSize     {number}\r\n     *     groupSeparator         {string}\r\n     *     decimalSeparator       {string}\r\n     *     fractionGroupSize      {number}\r\n     *     fractionGroupSeparator {string}\r\n     *     suffix                 {string}\r\n     *\r\n     * (The values assigned to the above FORMAT object properties are not checked for validity.)\r\n     *\r\n     * E.g.\r\n     * BigNumber.config({ DECIMAL_PLACES : 20, ROUNDING_MODE : 4 })\r\n     *\r\n     * Ignore properties/parameters set to null or undefined, except for ALPHABET.\r\n     *\r\n     * Return an object with the properties current values.\r\n     */\r\n    BigNumber.config = BigNumber.set = function (obj) {\r\n      var p, v;\r\n\r\n      if (obj != null) {\r\n\r\n        if (typeof obj == 'object') {\r\n\r\n          // DECIMAL_PLACES {number} Integer, 0 to MAX inclusive.\r\n          // '[BigNumber Error] DECIMAL_PLACES {not a primitive number|not an integer|out of range}: {v}'\r\n          if (obj.hasOwnProperty(p = 'DECIMAL_PLACES')) {\r\n            v = obj[p];\r\n            intCheck(v, 0, MAX, p);\r\n            DECIMAL_PLACES = v;\r\n          }\r\n\r\n          // ROUNDING_MODE {number} Integer, 0 to 8 inclusive.\r\n          // '[BigNumber Error] ROUNDING_MODE {not a primitive number|not an integer|out of range}: {v}'\r\n          if (obj.hasOwnProperty(p = 'ROUNDING_MODE')) {\r\n            v = obj[p];\r\n            intCheck(v, 0, 8, p);\r\n            ROUNDING_MODE = v;\r\n          }\r\n\r\n          // EXPONENTIAL_AT {number|number[]}\r\n          // Integer, -MAX to MAX inclusive or\r\n          // [integer -MAX to 0 inclusive, 0 to MAX inclusive].\r\n          // '[BigNumber Error] EXPONENTIAL_AT {not a primitive number|not an integer|out of range}: {v}'\r\n          if (obj.hasOwnProperty(p = 'EXPONENTIAL_AT')) {\r\n            v = obj[p];\r\n            if (v && v.pop) {\r\n              intCheck(v[0], -MAX, 0, p);\r\n              intCheck(v[1], 0, MAX, p);\r\n              TO_EXP_NEG = v[0];\r\n              TO_EXP_POS = v[1];\r\n            } else {\r\n              intCheck(v, -MAX, MAX, p);\r\n              TO_EXP_NEG = -(TO_EXP_POS = v < 0 ? -v : v);\r\n            }\r\n          }\r\n\r\n          // RANGE {number|number[]} Non-zero integer, -MAX to MAX inclusive or\r\n          // [integer -MAX to -1 inclusive, integer 1 to MAX inclusive].\r\n          // '[BigNumber Error] RANGE {not a primitive number|not an integer|out of range|cannot be zero}: {v}'\r\n          if (obj.hasOwnProperty(p = 'RANGE')) {\r\n            v = obj[p];\r\n            if (v && v.pop) {\r\n              intCheck(v[0], -MAX, -1, p);\r\n              intCheck(v[1], 1, MAX, p);\r\n              MIN_EXP = v[0];\r\n              MAX_EXP = v[1];\r\n            } else {\r\n              intCheck(v, -MAX, MAX, p);\r\n              if (v) {\r\n                MIN_EXP = -(MAX_EXP = v < 0 ? -v : v);\r\n              } else {\r\n                throw Error\r\n                 (bignumberError + p + ' cannot be zero: ' + v);\r\n              }\r\n            }\r\n          }\r\n\r\n          // CRYPTO {boolean} true or false.\r\n          // '[BigNumber Error] CRYPTO not true or false: {v}'\r\n          // '[BigNumber Error] crypto unavailable'\r\n          if (obj.hasOwnProperty(p = 'CRYPTO')) {\r\n            v = obj[p];\r\n            if (v === !!v) {\r\n              if (v) {\r\n                if (typeof crypto != 'undefined' && crypto &&\r\n                 (crypto.getRandomValues || crypto.randomBytes)) {\r\n                  CRYPTO = v;\r\n                } else {\r\n                  CRYPTO = !v;\r\n                  throw Error\r\n                   (bignumberError + 'crypto unavailable');\r\n                }\r\n              } else {\r\n                CRYPTO = v;\r\n              }\r\n            } else {\r\n              throw Error\r\n               (bignumberError + p + ' not true or false: ' + v);\r\n            }\r\n          }\r\n\r\n          // MODULO_MODE {number} Integer, 0 to 9 inclusive.\r\n          // '[BigNumber Error] MODULO_MODE {not a primitive number|not an integer|out of range}: {v}'\r\n          if (obj.hasOwnProperty(p = 'MODULO_MODE')) {\r\n            v = obj[p];\r\n            intCheck(v, 0, 9, p);\r\n            MODULO_MODE = v;\r\n          }\r\n\r\n          // POW_PRECISION {number} Integer, 0 to MAX inclusive.\r\n          // '[BigNumber Error] POW_PRECISION {not a primitive number|not an integer|out of range}: {v}'\r\n          if (obj.hasOwnProperty(p = 'POW_PRECISION')) {\r\n            v = obj[p];\r\n            intCheck(v, 0, MAX, p);\r\n            POW_PRECISION = v;\r\n          }\r\n\r\n          // FORMAT {object}\r\n          // '[BigNumber Error] FORMAT not an object: {v}'\r\n          if (obj.hasOwnProperty(p = 'FORMAT')) {\r\n            v = obj[p];\r\n            if (typeof v == 'object') FORMAT = v;\r\n            else throw Error\r\n             (bignumberError + p + ' not an object: ' + v);\r\n          }\r\n\r\n          // ALPHABET {string}\r\n          // '[BigNumber Error] ALPHABET invalid: {v}'\r\n          if (obj.hasOwnProperty(p = 'ALPHABET')) {\r\n            v = obj[p];\r\n\r\n            // Disallow if less than two characters,\r\n            // or if it contains '+', '-', '.', whitespace, or a repeated character.\r\n            if (typeof v == 'string' && !/^.?$|[+\\-.\\s]|(.).*\\1/.test(v)) {\r\n              alphabetHasNormalDecimalDigits = v.slice(0, 10) == '0123456789';\r\n              ALPHABET = v;\r\n            } else {\r\n              throw Error\r\n               (bignumberError + p + ' invalid: ' + v);\r\n            }\r\n          }\r\n\r\n        } else {\r\n\r\n          // '[BigNumber Error] Object expected: {v}'\r\n          throw Error\r\n           (bignumberError + 'Object expected: ' + obj);\r\n        }\r\n      }\r\n\r\n      return {\r\n        DECIMAL_PLACES: DECIMAL_PLACES,\r\n        ROUNDING_MODE: ROUNDING_MODE,\r\n        EXPONENTIAL_AT: [TO_EXP_NEG, TO_EXP_POS],\r\n        RANGE: [MIN_EXP, MAX_EXP],\r\n        CRYPTO: CRYPTO,\r\n        MODULO_MODE: MODULO_MODE,\r\n        POW_PRECISION: POW_PRECISION,\r\n        FORMAT: FORMAT,\r\n        ALPHABET: ALPHABET\r\n      };\r\n    };\r\n\r\n\r\n    /*\r\n     * Return true if v is a BigNumber instance, otherwise return false.\r\n     *\r\n     * If BigNumber.DEBUG is true, throw if a BigNumber instance is not well-formed.\r\n     *\r\n     * v {any}\r\n     *\r\n     * '[BigNumber Error] Invalid BigNumber: {v}'\r\n     */\r\n    BigNumber.isBigNumber = function (v) {\r\n      if (!v || v._isBigNumber !== true) return false;\r\n      if (!BigNumber.DEBUG) return true;\r\n\r\n      var i, n,\r\n        c = v.c,\r\n        e = v.e,\r\n        s = v.s;\r\n\r\n      out: if ({}.toString.call(c) == '[object Array]') {\r\n\r\n        if ((s === 1 || s === -1) && e >= -MAX && e <= MAX && e === mathfloor(e)) {\r\n\r\n          // If the first element is zero, the BigNumber value must be zero.\r\n          if (c[0] === 0) {\r\n            if (e === 0 && c.length === 1) return true;\r\n            break out;\r\n          }\r\n\r\n          // Calculate number of digits that c[0] should have, based on the exponent.\r\n          i = (e + 1) % LOG_BASE;\r\n          if (i < 1) i += LOG_BASE;\r\n\r\n          // Calculate number of digits of c[0].\r\n          //if (Math.ceil(Math.log(c[0] + 1) / Math.LN10) == i) {\r\n          if (String(c[0]).length == i) {\r\n\r\n            for (i = 0; i < c.length; i++) {\r\n              n = c[i];\r\n              if (n < 0 || n >= BASE || n !== mathfloor(n)) break out;\r\n            }\r\n\r\n            // Last element cannot be zero, unless it is the only element.\r\n            if (n !== 0) return true;\r\n          }\r\n        }\r\n\r\n      // Infinity/NaN\r\n      } else if (c === null && e === null && (s === null || s === 1 || s === -1)) {\r\n        return true;\r\n      }\r\n\r\n      throw Error\r\n        (bignumberError + 'Invalid BigNumber: ' + v);\r\n    };\r\n\r\n\r\n    /*\r\n     * Return a new BigNumber whose value is the maximum of the arguments.\r\n     *\r\n     * arguments {number|string|BigNumber}\r\n     */\r\n    BigNumber.maximum = BigNumber.max = function () {\r\n      return maxOrMin(arguments, -1);\r\n    };\r\n\r\n\r\n    /*\r\n     * Return a new BigNumber whose value is the minimum of the arguments.\r\n     *\r\n     * arguments {number|string|BigNumber}\r\n     */\r\n    BigNumber.minimum = BigNumber.min = function () {\r\n      return maxOrMin(arguments, 1);\r\n    };\r\n\r\n\r\n    /*\r\n     * Return a new BigNumber with a random value equal to or greater than 0 and less than 1,\r\n     * and with dp, or DECIMAL_PLACES if dp is omitted, decimal places (or less if trailing\r\n     * zeros are produced).\r\n     *\r\n     * [dp] {number} Decimal places. Integer, 0 to MAX inclusive.\r\n     *\r\n     * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {dp}'\r\n     * '[BigNumber Error] crypto unavailable'\r\n     */\r\n    BigNumber.random = (function () {\r\n      var pow2_53 = 0x20000000000000;\r\n\r\n      // Return a 53 bit integer n, where 0 <= n < 9007199254740992.\r\n      // Check if Math.random() produces more than 32 bits of randomness.\r\n      // If it does, assume at least 53 bits are produced, otherwise assume at least 30 bits.\r\n      // 0x40000000 is 2^30, 0x800000 is 2^23, 0x1fffff is 2^21 - 1.\r\n      var random53bitInt = (Math.random() * pow2_53) & 0x1fffff\r\n       ? function () { return mathfloor(Math.random() * pow2_53); }\r\n       : function () { return ((Math.random() * 0x40000000 | 0) * 0x800000) +\r\n         (Math.random() * 0x800000 | 0); };\r\n\r\n      return function (dp) {\r\n        var a, b, e, k, v,\r\n          i = 0,\r\n          c = [],\r\n          rand = new BigNumber(ONE);\r\n\r\n        if (dp == null) dp = DECIMAL_PLACES;\r\n        else intCheck(dp, 0, MAX);\r\n\r\n        k = mathceil(dp / LOG_BASE);\r\n\r\n        if (CRYPTO) {\r\n\r\n          // Browsers supporting crypto.getRandomValues.\r\n          if (crypto.getRandomValues) {\r\n\r\n            a = crypto.getRandomValues(new Uint32Array(k *= 2));\r\n\r\n            for (; i < k;) {\r\n\r\n              // 53 bits:\r\n              // ((Math.pow(2, 32) - 1) * Math.pow(2, 21)).toString(2)\r\n              // 11111 11111111 11111111 11111111 11100000 00000000 00000000\r\n              // ((Math.pow(2, 32) - 1) >>> 11).toString(2)\r\n              //                                     11111 11111111 11111111\r\n              // 0x20000 is 2^21.\r\n              v = a[i] * 0x20000 + (a[i + 1] >>> 11);\r\n\r\n              // Rejection sampling:\r\n              // 0 <= v < 9007199254740992\r\n              // Probability that v >= 9e15, is\r\n              // 7199254740992 / 9007199254740992 ~= 0.0008, i.e. 1 in 1251\r\n              if (v >= 9e15) {\r\n                b = crypto.getRandomValues(new Uint32Array(2));\r\n                a[i] = b[0];\r\n                a[i + 1] = b[1];\r\n              } else {\r\n\r\n                // 0 <= v <= 8999999999999999\r\n                // 0 <= (v % 1e14) <= 99999999999999\r\n                c.push(v % 1e14);\r\n                i += 2;\r\n              }\r\n            }\r\n            i = k / 2;\r\n\r\n          // Node.js supporting crypto.randomBytes.\r\n          } else if (crypto.randomBytes) {\r\n\r\n            // buffer\r\n            a = crypto.randomBytes(k *= 7);\r\n\r\n            for (; i < k;) {\r\n\r\n              // 0x1000000000000 is 2^48, 0x10000000000 is 2^40\r\n              // 0x100000000 is 2^32, 0x1000000 is 2^24\r\n              // 11111 11111111 11111111 11111111 11111111 11111111 11111111\r\n              // 0 <= v < 9007199254740992\r\n              v = ((a[i] & 31) * 0x1000000000000) + (a[i + 1] * 0x10000000000) +\r\n                 (a[i + 2] * 0x100000000) + (a[i + 3] * 0x1000000) +\r\n                 (a[i + 4] << 16) + (a[i + 5] << 8) + a[i + 6];\r\n\r\n              if (v >= 9e15) {\r\n                crypto.randomBytes(7).copy(a, i);\r\n              } else {\r\n\r\n                // 0 <= (v % 1e14) <= 99999999999999\r\n                c.push(v % 1e14);\r\n                i += 7;\r\n              }\r\n            }\r\n            i = k / 7;\r\n          } else {\r\n            CRYPTO = false;\r\n            throw Error\r\n             (bignumberError + 'crypto unavailable');\r\n          }\r\n        }\r\n\r\n        // Use Math.random.\r\n        if (!CRYPTO) {\r\n\r\n          for (; i < k;) {\r\n            v = random53bitInt();\r\n            if (v < 9e15) c[i++] = v % 1e14;\r\n          }\r\n        }\r\n\r\n        k = c[--i];\r\n        dp %= LOG_BASE;\r\n\r\n        // Convert trailing digits to zeros according to dp.\r\n        if (k && dp) {\r\n          v = POWS_TEN[LOG_BASE - dp];\r\n          c[i] = mathfloor(k / v) * v;\r\n        }\r\n\r\n        // Remove trailing elements which are zero.\r\n        for (; c[i] === 0; c.pop(), i--);\r\n\r\n        // Zero?\r\n        if (i < 0) {\r\n          c = [e = 0];\r\n        } else {\r\n\r\n          // Remove leading elements which are zero and adjust exponent accordingly.\r\n          for (e = -1 ; c[0] === 0; c.splice(0, 1), e -= LOG_BASE);\r\n\r\n          // Count the digits of the first element of c to determine leading zeros, and...\r\n          for (i = 1, v = c[0]; v >= 10; v /= 10, i++);\r\n\r\n          // adjust the exponent accordingly.\r\n          if (i < LOG_BASE) e -= LOG_BASE - i;\r\n        }\r\n\r\n        rand.e = e;\r\n        rand.c = c;\r\n        return rand;\r\n      };\r\n    })();\r\n\r\n\r\n    /*\r\n     * Return a BigNumber whose value is the sum of the arguments.\r\n     *\r\n     * arguments {number|string|BigNumber}\r\n     */\r\n    BigNumber.sum = function () {\r\n      var i = 1,\r\n        args = arguments,\r\n        sum = new BigNumber(args[0]);\r\n      for (; i < args.length;) sum = sum.plus(args[i++]);\r\n      return sum;\r\n    };\r\n\r\n\r\n    // PRIVATE FUNCTIONS\r\n\r\n\r\n    // Called by BigNumber and BigNumber.prototype.toString.\r\n    convertBase = (function () {\r\n      var decimal = '0123456789';\r\n\r\n      /*\r\n       * Convert string of baseIn to an array of numbers of baseOut.\r\n       * Eg. toBaseOut('255', 10, 16) returns [15, 15].\r\n       * Eg. toBaseOut('ff', 16, 10) returns [2, 5, 5].\r\n       */\r\n      function toBaseOut(str, baseIn, baseOut, alphabet) {\r\n        var j,\r\n          arr = [0],\r\n          arrL,\r\n          i = 0,\r\n          len = str.length;\r\n\r\n        for (; i < len;) {\r\n          for (arrL = arr.length; arrL--; arr[arrL] *= baseIn);\r\n\r\n          arr[0] += alphabet.indexOf(str.charAt(i++));\r\n\r\n          for (j = 0; j < arr.length; j++) {\r\n\r\n            if (arr[j] > baseOut - 1) {\r\n              if (arr[j + 1] == null) arr[j + 1] = 0;\r\n              arr[j + 1] += arr[j] / baseOut | 0;\r\n              arr[j] %= baseOut;\r\n            }\r\n          }\r\n        }\r\n\r\n        return arr.reverse();\r\n      }\r\n\r\n      // Convert a numeric string of baseIn to a numeric string of baseOut.\r\n      // If the caller is toString, we are converting from base 10 to baseOut.\r\n      // If the caller is BigNumber, we are converting from baseIn to base 10.\r\n      return function (str, baseIn, baseOut, sign, callerIsToString) {\r\n        var alphabet, d, e, k, r, x, xc, y,\r\n          i = str.indexOf('.'),\r\n          dp = DECIMAL_PLACES,\r\n          rm = ROUNDING_MODE;\r\n\r\n        // Non-integer.\r\n        if (i >= 0) {\r\n          k = POW_PRECISION;\r\n\r\n          // Unlimited precision.\r\n          POW_PRECISION = 0;\r\n          str = str.replace('.', '');\r\n          y = new BigNumber(baseIn);\r\n          x = y.pow(str.length - i);\r\n          POW_PRECISION = k;\r\n\r\n          // Convert str as if an integer, then restore the fraction part by dividing the\r\n          // result by its base raised to a power.\r\n\r\n          y.c = toBaseOut(toFixedPoint(coeffToString(x.c), x.e, '0'),\r\n           10, baseOut, decimal);\r\n          y.e = y.c.length;\r\n        }\r\n\r\n        // Convert the number as integer.\r\n\r\n        xc = toBaseOut(str, baseIn, baseOut, callerIsToString\r\n         ? (alphabet = ALPHABET, decimal)\r\n         : (alphabet = decimal, ALPHABET));\r\n\r\n        // xc now represents str as an integer and converted to baseOut. e is the exponent.\r\n        e = k = xc.length;\r\n\r\n        // Remove trailing zeros.\r\n        for (; xc[--k] == 0; xc.pop());\r\n\r\n        // Zero?\r\n        if (!xc[0]) return alphabet.charAt(0);\r\n\r\n        // Does str represent an integer? If so, no need for the division.\r\n        if (i < 0) {\r\n          --e;\r\n        } else {\r\n          x.c = xc;\r\n          x.e = e;\r\n\r\n          // The sign is needed for correct rounding.\r\n          x.s = sign;\r\n          x = div(x, y, dp, rm, baseOut);\r\n          xc = x.c;\r\n          r = x.r;\r\n          e = x.e;\r\n        }\r\n\r\n        // xc now represents str converted to baseOut.\r\n\r\n        // THe index of the rounding digit.\r\n        d = e + dp + 1;\r\n\r\n        // The rounding digit: the digit to the right of the digit that may be rounded up.\r\n        i = xc[d];\r\n\r\n        // Look at the rounding digits and mode to determine whether to round up.\r\n\r\n        k = baseOut / 2;\r\n        r = r || d < 0 || xc[d + 1] != null;\r\n\r\n        r = rm < 4 ? (i != null || r) && (rm == 0 || rm == (x.s < 0 ? 3 : 2))\r\n              : i > k || i == k &&(rm == 4 || r || rm == 6 && xc[d - 1] & 1 ||\r\n               rm == (x.s < 0 ? 8 : 7));\r\n\r\n        // If the index of the rounding digit is not greater than zero, or xc represents\r\n        // zero, then the result of the base conversion is zero or, if rounding up, a value\r\n        // such as 0.00001.\r\n        if (d < 1 || !xc[0]) {\r\n\r\n          // 1^-dp or 0\r\n          str = r ? toFixedPoint(alphabet.charAt(1), -dp, alphabet.charAt(0)) : alphabet.charAt(0);\r\n        } else {\r\n\r\n          // Truncate xc to the required number of decimal places.\r\n          xc.length = d;\r\n\r\n          // Round up?\r\n          if (r) {\r\n\r\n            // Rounding up may mean the previous digit has to be rounded up and so on.\r\n            for (--baseOut; ++xc[--d] > baseOut;) {\r\n              xc[d] = 0;\r\n\r\n              if (!d) {\r\n                ++e;\r\n                xc = [1].concat(xc);\r\n              }\r\n            }\r\n          }\r\n\r\n          // Determine trailing zeros.\r\n          for (k = xc.length; !xc[--k];);\r\n\r\n          // E.g. [4, 11, 15] becomes 4bf.\r\n          for (i = 0, str = ''; i <= k; str += alphabet.charAt(xc[i++]));\r\n\r\n          // Add leading zeros, decimal point and trailing zeros as required.\r\n          str = toFixedPoint(str, e, alphabet.charAt(0));\r\n        }\r\n\r\n        // The caller will add the sign.\r\n        return str;\r\n      };\r\n    })();\r\n\r\n\r\n    // Perform division in the specified base. Called by div and convertBase.\r\n    div = (function () {\r\n\r\n      // Assume non-zero x and k.\r\n      function multiply(x, k, base) {\r\n        var m, temp, xlo, xhi,\r\n          carry = 0,\r\n          i = x.length,\r\n          klo = k % SQRT_BASE,\r\n          khi = k / SQRT_BASE | 0;\r\n\r\n        for (x = x.slice(); i--;) {\r\n          xlo = x[i] % SQRT_BASE;\r\n          xhi = x[i] / SQRT_BASE | 0;\r\n          m = khi * xlo + xhi * klo;\r\n          temp = klo * xlo + ((m % SQRT_BASE) * SQRT_BASE) + carry;\r\n          carry = (temp / base | 0) + (m / SQRT_BASE | 0) + khi * xhi;\r\n          x[i] = temp % base;\r\n        }\r\n\r\n        if (carry) x = [carry].concat(x);\r\n\r\n        return x;\r\n      }\r\n\r\n      function compare(a, b, aL, bL) {\r\n        var i, cmp;\r\n\r\n        if (aL != bL) {\r\n          cmp = aL > bL ? 1 : -1;\r\n        } else {\r\n\r\n          for (i = cmp = 0; i < aL; i++) {\r\n\r\n            if (a[i] != b[i]) {\r\n              cmp = a[i] > b[i] ? 1 : -1;\r\n              break;\r\n            }\r\n          }\r\n        }\r\n\r\n        return cmp;\r\n      }\r\n\r\n      function subtract(a, b, aL, base) {\r\n        var i = 0;\r\n\r\n        // Subtract b from a.\r\n        for (; aL--;) {\r\n          a[aL] -= i;\r\n          i = a[aL] < b[aL] ? 1 : 0;\r\n          a[aL] = i * base + a[aL] - b[aL];\r\n        }\r\n\r\n        // Remove leading zeros.\r\n        for (; !a[0] && a.length > 1; a.splice(0, 1));\r\n      }\r\n\r\n      // x: dividend, y: divisor.\r\n      return function (x, y, dp, rm, base) {\r\n        var cmp, e, i, more, n, prod, prodL, q, qc, rem, remL, rem0, xi, xL, yc0,\r\n          yL, yz,\r\n          s = x.s == y.s ? 1 : -1,\r\n          xc = x.c,\r\n          yc = y.c;\r\n\r\n        // Either NaN, Infinity or 0?\r\n        if (!xc || !xc[0] || !yc || !yc[0]) {\r\n\r\n          return new BigNumber(\r\n\r\n           // Return NaN if either NaN, or both Infinity or 0.\r\n           !x.s || !y.s || (xc ? yc && xc[0] == yc[0] : !yc) ? NaN :\r\n\r\n            // Return ±0 if x is ±0 or y is ±Infinity, or return ±Infinity as y is ±0.\r\n            xc && xc[0] == 0 || !yc ? s * 0 : s / 0\r\n         );\r\n        }\r\n\r\n        q = new BigNumber(s);\r\n        qc = q.c = [];\r\n        e = x.e - y.e;\r\n        s = dp + e + 1;\r\n\r\n        if (!base) {\r\n          base = BASE;\r\n          e = bitFloor(x.e / LOG_BASE) - bitFloor(y.e / LOG_BASE);\r\n          s = s / LOG_BASE | 0;\r\n        }\r\n\r\n        // Result exponent may be one less then the current value of e.\r\n        // The coefficients of the BigNumbers from convertBase may have trailing zeros.\r\n        for (i = 0; yc[i] == (xc[i] || 0); i++);\r\n\r\n        if (yc[i] > (xc[i] || 0)) e--;\r\n\r\n        if (s < 0) {\r\n          qc.push(1);\r\n          more = true;\r\n        } else {\r\n          xL = xc.length;\r\n          yL = yc.length;\r\n          i = 0;\r\n          s += 2;\r\n\r\n          // Normalise xc and yc so highest order digit of yc is >= base / 2.\r\n\r\n          n = mathfloor(base / (yc[0] + 1));\r\n\r\n          // Not necessary, but to handle odd bases where yc[0] == (base / 2) - 1.\r\n          // if (n > 1 || n++ == 1 && yc[0] < base / 2) {\r\n          if (n > 1) {\r\n            yc = multiply(yc, n, base);\r\n            xc = multiply(xc, n, base);\r\n            yL = yc.length;\r\n            xL = xc.length;\r\n          }\r\n\r\n          xi = yL;\r\n          rem = xc.slice(0, yL);\r\n          remL = rem.length;\r\n\r\n          // Add zeros to make remainder as long as divisor.\r\n          for (; remL < yL; rem[remL++] = 0);\r\n          yz = yc.slice();\r\n          yz = [0].concat(yz);\r\n          yc0 = yc[0];\r\n          if (yc[1] >= base / 2) yc0++;\r\n          // Not necessary, but to prevent trial digit n > base, when using base 3.\r\n          // else if (base == 3 && yc0 == 1) yc0 = 1 + 1e-15;\r\n\r\n          do {\r\n            n = 0;\r\n\r\n            // Compare divisor and remainder.\r\n            cmp = compare(yc, rem, yL, remL);\r\n\r\n            // If divisor < remainder.\r\n            if (cmp < 0) {\r\n\r\n              // Calculate trial digit, n.\r\n\r\n              rem0 = rem[0];\r\n              if (yL != remL) rem0 = rem0 * base + (rem[1] || 0);\r\n\r\n              // n is how many times the divisor goes into the current remainder.\r\n              n = mathfloor(rem0 / yc0);\r\n\r\n              //  Algorithm:\r\n              //  product = divisor multiplied by trial digit (n).\r\n              //  Compare product and remainder.\r\n              //  If product is greater than remainder:\r\n              //    Subtract divisor from product, decrement trial digit.\r\n              //  Subtract product from remainder.\r\n              //  If product was less than remainder at the last compare:\r\n              //    Compare new remainder and divisor.\r\n              //    If remainder is greater than divisor:\r\n              //      Subtract divisor from remainder, increment trial digit.\r\n\r\n              if (n > 1) {\r\n\r\n                // n may be > base only when base is 3.\r\n                if (n >= base) n = base - 1;\r\n\r\n                // product = divisor * trial digit.\r\n                prod = multiply(yc, n, base);\r\n                prodL = prod.length;\r\n                remL = rem.length;\r\n\r\n                // Compare product and remainder.\r\n                // If product > remainder then trial digit n too high.\r\n                // n is 1 too high about 5% of the time, and is not known to have\r\n                // ever been more than 1 too high.\r\n                while (compare(prod, rem, prodL, remL) == 1) {\r\n                  n--;\r\n\r\n                  // Subtract divisor from product.\r\n                  subtract(prod, yL < prodL ? yz : yc, prodL, base);\r\n                  prodL = prod.length;\r\n                  cmp = 1;\r\n                }\r\n              } else {\r\n\r\n                // n is 0 or 1, cmp is -1.\r\n                // If n is 0, there is no need to compare yc and rem again below,\r\n                // so change cmp to 1 to avoid it.\r\n                // If n is 1, leave cmp as -1, so yc and rem are compared again.\r\n                if (n == 0) {\r\n\r\n                  // divisor < remainder, so n must be at least 1.\r\n                  cmp = n = 1;\r\n                }\r\n\r\n                // product = divisor\r\n                prod = yc.slice();\r\n                prodL = prod.length;\r\n              }\r\n\r\n              if (prodL < remL) prod = [0].concat(prod);\r\n\r\n              // Subtract product from remainder.\r\n              subtract(rem, prod, remL, base);\r\n              remL = rem.length;\r\n\r\n               // If product was < remainder.\r\n              if (cmp == -1) {\r\n\r\n                // Compare divisor and new remainder.\r\n                // If divisor < new remainder, subtract divisor from remainder.\r\n                // Trial digit n too low.\r\n                // n is 1 too low about 5% of the time, and very rarely 2 too low.\r\n                while (compare(yc, rem, yL, remL) < 1) {\r\n                  n++;\r\n\r\n                  // Subtract divisor from remainder.\r\n                  subtract(rem, yL < remL ? yz : yc, remL, base);\r\n                  remL = rem.length;\r\n                }\r\n              }\r\n            } else if (cmp === 0) {\r\n              n++;\r\n              rem = [0];\r\n            } // else cmp === 1 and n will be 0\r\n\r\n            // Add the next digit, n, to the result array.\r\n            qc[i++] = n;\r\n\r\n            // Update the remainder.\r\n            if (rem[0]) {\r\n              rem[remL++] = xc[xi] || 0;\r\n            } else {\r\n              rem = [xc[xi]];\r\n              remL = 1;\r\n            }\r\n          } while ((xi++ < xL || rem[0] != null) && s--);\r\n\r\n          more = rem[0] != null;\r\n\r\n          // Leading zero?\r\n          if (!qc[0]) qc.splice(0, 1);\r\n        }\r\n\r\n        if (base == BASE) {\r\n\r\n          // To calculate q.e, first get the number of digits of qc[0].\r\n          for (i = 1, s = qc[0]; s >= 10; s /= 10, i++);\r\n\r\n          round(q, dp + (q.e = i + e * LOG_BASE - 1) + 1, rm, more);\r\n\r\n        // Caller is convertBase.\r\n        } else {\r\n          q.e = e;\r\n          q.r = +more;\r\n        }\r\n\r\n        return q;\r\n      };\r\n    })();\r\n\r\n\r\n    /*\r\n     * Return a string representing the value of BigNumber n in fixed-point or exponential\r\n     * notation rounded to the specified decimal places or significant digits.\r\n     *\r\n     * n: a BigNumber.\r\n     * i: the index of the last digit required (i.e. the digit that may be rounded up).\r\n     * rm: the rounding mode.\r\n     * id: 1 (toExponential) or 2 (toPrecision).\r\n     */\r\n    function format(n, i, rm, id) {\r\n      var c0, e, ne, len, str;\r\n\r\n      if (rm == null) rm = ROUNDING_MODE;\r\n      else intCheck(rm, 0, 8);\r\n\r\n      if (!n.c) return n.toString();\r\n\r\n      c0 = n.c[0];\r\n      ne = n.e;\r\n\r\n      if (i == null) {\r\n        str = coeffToString(n.c);\r\n        str = id == 1 || id == 2 && (ne <= TO_EXP_NEG || ne >= TO_EXP_POS)\r\n         ? toExponential(str, ne)\r\n         : toFixedPoint(str, ne, '0');\r\n      } else {\r\n        n = round(new BigNumber(n), i, rm);\r\n\r\n        // n.e may have changed if the value was rounded up.\r\n        e = n.e;\r\n\r\n        str = coeffToString(n.c);\r\n        len = str.length;\r\n\r\n        // toPrecision returns exponential notation if the number of significant digits\r\n        // specified is less than the number of digits necessary to represent the integer\r\n        // part of the value in fixed-point notation.\r\n\r\n        // Exponential notation.\r\n        if (id == 1 || id == 2 && (i <= e || e <= TO_EXP_NEG)) {\r\n\r\n          // Append zeros?\r\n          for (; len < i; str += '0', len++);\r\n          str = toExponential(str, e);\r\n\r\n        // Fixed-point notation.\r\n        } else {\r\n          i -= ne;\r\n          str = toFixedPoint(str, e, '0');\r\n\r\n          // Append zeros?\r\n          if (e + 1 > len) {\r\n            if (--i > 0) for (str += '.'; i--; str += '0');\r\n          } else {\r\n            i += e - len;\r\n            if (i > 0) {\r\n              if (e + 1 == len) str += '.';\r\n              for (; i--; str += '0');\r\n            }\r\n          }\r\n        }\r\n      }\r\n\r\n      return n.s < 0 && c0 ? '-' + str : str;\r\n    }\r\n\r\n\r\n    // Handle BigNumber.max and BigNumber.min.\r\n    // If any number is NaN, return NaN.\r\n    function maxOrMin(args, n) {\r\n      var k, y,\r\n        i = 1,\r\n        x = new BigNumber(args[0]);\r\n\r\n      for (; i < args.length; i++) {\r\n        y = new BigNumber(args[i]);\r\n        if (!y.s || (k = compare(x, y)) === n || k === 0 && x.s === n) {\r\n          x = y;\r\n        }\r\n      }\r\n\r\n      return x;\r\n    }\r\n\r\n\r\n    /*\r\n     * Strip trailing zeros, calculate base 10 exponent and check against MIN_EXP and MAX_EXP.\r\n     * Called by minus, plus and times.\r\n     */\r\n    function normalise(n, c, e) {\r\n      var i = 1,\r\n        j = c.length;\r\n\r\n       // Remove trailing zeros.\r\n      for (; !c[--j]; c.pop());\r\n\r\n      // Calculate the base 10 exponent. First get the number of digits of c[0].\r\n      for (j = c[0]; j >= 10; j /= 10, i++);\r\n\r\n      // Overflow?\r\n      if ((e = i + e * LOG_BASE - 1) > MAX_EXP) {\r\n\r\n        // Infinity.\r\n        n.c = n.e = null;\r\n\r\n      // Underflow?\r\n      } else if (e < MIN_EXP) {\r\n\r\n        // Zero.\r\n        n.c = [n.e = 0];\r\n      } else {\r\n        n.e = e;\r\n        n.c = c;\r\n      }\r\n\r\n      return n;\r\n    }\r\n\r\n\r\n    // Handle values that fail the validity test in BigNumber.\r\n    parseNumeric = (function () {\r\n      var basePrefix = /^(-?)0([xbo])(?=\\w[\\w.]*$)/i,\r\n        dotAfter = /^([^.]+)\\.$/,\r\n        dotBefore = /^\\.([^.]+)$/,\r\n        isInfinityOrNaN = /^-?(Infinity|NaN)$/,\r\n        whitespaceOrPlus = /^\\s*\\+(?=[\\w.])|^\\s+|\\s+$/g;\r\n\r\n      return function (x, str, isNum, b) {\r\n        var base,\r\n          s = isNum ? str : str.replace(whitespaceOrPlus, '');\r\n\r\n        // No exception on ±Infinity or NaN.\r\n        if (isInfinityOrNaN.test(s)) {\r\n          x.s = isNaN(s) ? null : s < 0 ? -1 : 1;\r\n        } else {\r\n          if (!isNum) {\r\n\r\n            // basePrefix = /^(-?)0([xbo])(?=\\w[\\w.]*$)/i\r\n            s = s.replace(basePrefix, function (m, p1, p2) {\r\n              base = (p2 = p2.toLowerCase()) == 'x' ? 16 : p2 == 'b' ? 2 : 8;\r\n              return !b || b == base ? p1 : m;\r\n            });\r\n\r\n            if (b) {\r\n              base = b;\r\n\r\n              // E.g. '1.' to '1', '.1' to '0.1'\r\n              s = s.replace(dotAfter, '$1').replace(dotBefore, '0.$1');\r\n            }\r\n\r\n            if (str != s) return new BigNumber(s, base);\r\n          }\r\n\r\n          // '[BigNumber Error] Not a number: {n}'\r\n          // '[BigNumber Error] Not a base {b} number: {n}'\r\n          if (BigNumber.DEBUG) {\r\n            throw Error\r\n              (bignumberError + 'Not a' + (b ? ' base ' + b : '') + ' number: ' + str);\r\n          }\r\n\r\n          // NaN\r\n          x.s = null;\r\n        }\r\n\r\n        x.c = x.e = null;\r\n      }\r\n    })();\r\n\r\n\r\n    /*\r\n     * Round x to sd significant digits using rounding mode rm. Check for over/under-flow.\r\n     * If r is truthy, it is known that there are more digits after the rounding digit.\r\n     */\r\n    function round(x, sd, rm, r) {\r\n      var d, i, j, k, n, ni, rd,\r\n        xc = x.c,\r\n        pows10 = POWS_TEN;\r\n\r\n      // if x is not Infinity or NaN...\r\n      if (xc) {\r\n\r\n        // rd is the rounding digit, i.e. the digit after the digit that may be rounded up.\r\n        // n is a base 1e14 number, the value of the element of array x.c containing rd.\r\n        // ni is the index of n within x.c.\r\n        // d is the number of digits of n.\r\n        // i is the index of rd within n including leading zeros.\r\n        // j is the actual index of rd within n (if < 0, rd is a leading zero).\r\n        out: {\r\n\r\n          // Get the number of digits of the first element of xc.\r\n          for (d = 1, k = xc[0]; k >= 10; k /= 10, d++);\r\n          i = sd - d;\r\n\r\n          // If the rounding digit is in the first element of xc...\r\n          if (i < 0) {\r\n            i += LOG_BASE;\r\n            j = sd;\r\n            n = xc[ni = 0];\r\n\r\n            // Get the rounding digit at index j of n.\r\n            rd = mathfloor(n / pows10[d - j - 1] % 10);\r\n          } else {\r\n            ni = mathceil((i + 1) / LOG_BASE);\r\n\r\n            if (ni >= xc.length) {\r\n\r\n              if (r) {\r\n\r\n                // Needed by sqrt.\r\n                for (; xc.length <= ni; xc.push(0));\r\n                n = rd = 0;\r\n                d = 1;\r\n                i %= LOG_BASE;\r\n                j = i - LOG_BASE + 1;\r\n              } else {\r\n                break out;\r\n              }\r\n            } else {\r\n              n = k = xc[ni];\r\n\r\n              // Get the number of digits of n.\r\n              for (d = 1; k >= 10; k /= 10, d++);\r\n\r\n              // Get the index of rd within n.\r\n              i %= LOG_BASE;\r\n\r\n              // Get the index of rd within n, adjusted for leading zeros.\r\n              // The number of leading zeros of n is given by LOG_BASE - d.\r\n              j = i - LOG_BASE + d;\r\n\r\n              // Get the rounding digit at index j of n.\r\n              rd = j < 0 ? 0 : mathfloor(n / pows10[d - j - 1] % 10);\r\n            }\r\n          }\r\n\r\n          r = r || sd < 0 ||\r\n\r\n          // Are there any non-zero digits after the rounding digit?\r\n          // The expression  n % pows10[d - j - 1]  returns all digits of n to the right\r\n          // of the digit at j, e.g. if n is 908714 and j is 2, the expression gives 714.\r\n           xc[ni + 1] != null || (j < 0 ? n : n % pows10[d - j - 1]);\r\n\r\n          r = rm < 4\r\n           ? (rd || r) && (rm == 0 || rm == (x.s < 0 ? 3 : 2))\r\n           : rd > 5 || rd == 5 && (rm == 4 || r || rm == 6 &&\r\n\r\n            // Check whether the digit to the left of the rounding digit is odd.\r\n            ((i > 0 ? j > 0 ? n / pows10[d - j] : 0 : xc[ni - 1]) % 10) & 1 ||\r\n             rm == (x.s < 0 ? 8 : 7));\r\n\r\n          if (sd < 1 || !xc[0]) {\r\n            xc.length = 0;\r\n\r\n            if (r) {\r\n\r\n              // Convert sd to decimal places.\r\n              sd -= x.e + 1;\r\n\r\n              // 1, 0.1, 0.01, 0.001, 0.0001 etc.\r\n              xc[0] = pows10[(LOG_BASE - sd % LOG_BASE) % LOG_BASE];\r\n              x.e = -sd || 0;\r\n            } else {\r\n\r\n              // Zero.\r\n              xc[0] = x.e = 0;\r\n            }\r\n\r\n            return x;\r\n          }\r\n\r\n          // Remove excess digits.\r\n          if (i == 0) {\r\n            xc.length = ni;\r\n            k = 1;\r\n            ni--;\r\n          } else {\r\n            xc.length = ni + 1;\r\n            k = pows10[LOG_BASE - i];\r\n\r\n            // E.g. 56700 becomes 56000 if 7 is the rounding digit.\r\n            // j > 0 means i > number of leading zeros of n.\r\n            xc[ni] = j > 0 ? mathfloor(n / pows10[d - j] % pows10[j]) * k : 0;\r\n          }\r\n\r\n          // Round up?\r\n          if (r) {\r\n\r\n            for (; ;) {\r\n\r\n              // If the digit to be rounded up is in the first element of xc...\r\n              if (ni == 0) {\r\n\r\n                // i will be the length of xc[0] before k is added.\r\n                for (i = 1, j = xc[0]; j >= 10; j /= 10, i++);\r\n                j = xc[0] += k;\r\n                for (k = 1; j >= 10; j /= 10, k++);\r\n\r\n                // if i != k the length has increased.\r\n                if (i != k) {\r\n                  x.e++;\r\n                  if (xc[0] == BASE) xc[0] = 1;\r\n                }\r\n\r\n                break;\r\n              } else {\r\n                xc[ni] += k;\r\n                if (xc[ni] != BASE) break;\r\n                xc[ni--] = 0;\r\n                k = 1;\r\n              }\r\n            }\r\n          }\r\n\r\n          // Remove trailing zeros.\r\n          for (i = xc.length; xc[--i] === 0; xc.pop());\r\n        }\r\n\r\n        // Overflow? Infinity.\r\n        if (x.e > MAX_EXP) {\r\n          x.c = x.e = null;\r\n\r\n        // Underflow? Zero.\r\n        } else if (x.e < MIN_EXP) {\r\n          x.c = [x.e = 0];\r\n        }\r\n      }\r\n\r\n      return x;\r\n    }\r\n\r\n\r\n    function valueOf(n) {\r\n      var str,\r\n        e = n.e;\r\n\r\n      if (e === null) return n.toString();\r\n\r\n      str = coeffToString(n.c);\r\n\r\n      str = e <= TO_EXP_NEG || e >= TO_EXP_POS\r\n        ? toExponential(str, e)\r\n        : toFixedPoint(str, e, '0');\r\n\r\n      return n.s < 0 ? '-' + str : str;\r\n    }\r\n\r\n\r\n    // PROTOTYPE/INSTANCE METHODS\r\n\r\n\r\n    /*\r\n     * Return a new BigNumber whose value is the absolute value of this BigNumber.\r\n     */\r\n    P.absoluteValue = P.abs = function () {\r\n      var x = new BigNumber(this);\r\n      if (x.s < 0) x.s = 1;\r\n      return x;\r\n    };\r\n\r\n\r\n    /*\r\n     * Return\r\n     *   1 if the value of this BigNumber is greater than the value of BigNumber(y, b),\r\n     *   -1 if the value of this BigNumber is less than the value of BigNumber(y, b),\r\n     *   0 if they have the same value,\r\n     *   or null if the value of either is NaN.\r\n     */\r\n    P.comparedTo = function (y, b) {\r\n      return compare(this, new BigNumber(y, b));\r\n    };\r\n\r\n\r\n    /*\r\n     * If dp is undefined or null or true or false, return the number of decimal places of the\r\n     * value of this BigNumber, or null if the value of this BigNumber is ±Infinity or NaN.\r\n     *\r\n     * Otherwise, if dp is a number, return a new BigNumber whose value is the value of this\r\n     * BigNumber rounded to a maximum of dp decimal places using rounding mode rm, or\r\n     * ROUNDING_MODE if rm is omitted.\r\n     *\r\n     * [dp] {number} Decimal places: integer, 0 to MAX inclusive.\r\n     * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n     *\r\n     * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {dp|rm}'\r\n     */\r\n    P.decimalPlaces = P.dp = function (dp, rm) {\r\n      var c, n, v,\r\n        x = this;\r\n\r\n      if (dp != null) {\r\n        intCheck(dp, 0, MAX);\r\n        if (rm == null) rm = ROUNDING_MODE;\r\n        else intCheck(rm, 0, 8);\r\n\r\n        return round(new BigNumber(x), dp + x.e + 1, rm);\r\n      }\r\n\r\n      if (!(c = x.c)) return null;\r\n      n = ((v = c.length - 1) - bitFloor(this.e / LOG_BASE)) * LOG_BASE;\r\n\r\n      // Subtract the number of trailing zeros of the last number.\r\n      if (v = c[v]) for (; v % 10 == 0; v /= 10, n--);\r\n      if (n < 0) n = 0;\r\n\r\n      return n;\r\n    };\r\n\r\n\r\n    /*\r\n     *  n / 0 = I\r\n     *  n / N = N\r\n     *  n / I = 0\r\n     *  0 / n = 0\r\n     *  0 / 0 = N\r\n     *  0 / N = N\r\n     *  0 / I = 0\r\n     *  N / n = N\r\n     *  N / 0 = N\r\n     *  N / N = N\r\n     *  N / I = N\r\n     *  I / n = I\r\n     *  I / 0 = I\r\n     *  I / N = N\r\n     *  I / I = N\r\n     *\r\n     * Return a new BigNumber whose value is the value of this BigNumber divided by the value of\r\n     * BigNumber(y, b), rounded according to DECIMAL_PLACES and ROUNDING_MODE.\r\n     */\r\n    P.dividedBy = P.div = function (y, b) {\r\n      return div(this, new BigNumber(y, b), DECIMAL_PLACES, ROUNDING_MODE);\r\n    };\r\n\r\n\r\n    /*\r\n     * Return a new BigNumber whose value is the integer part of dividing the value of this\r\n     * BigNumber by the value of BigNumber(y, b).\r\n     */\r\n    P.dividedToIntegerBy = P.idiv = function (y, b) {\r\n      return div(this, new BigNumber(y, b), 0, 1);\r\n    };\r\n\r\n\r\n    /*\r\n     * Return a BigNumber whose value is the value of this BigNumber exponentiated by n.\r\n     *\r\n     * If m is present, return the result modulo m.\r\n     * If n is negative round according to DECIMAL_PLACES and ROUNDING_MODE.\r\n     * If POW_PRECISION is non-zero and m is not present, round to POW_PRECISION using ROUNDING_MODE.\r\n     *\r\n     * The modular power operation works efficiently when x, n, and m are integers, otherwise it\r\n     * is equivalent to calculating x.exponentiatedBy(n).modulo(m) with a POW_PRECISION of 0.\r\n     *\r\n     * n {number|string|BigNumber} The exponent. An integer.\r\n     * [m] {number|string|BigNumber} The modulus.\r\n     *\r\n     * '[BigNumber Error] Exponent not an integer: {n}'\r\n     */\r\n    P.exponentiatedBy = P.pow = function (n, m) {\r\n      var half, isModExp, i, k, more, nIsBig, nIsNeg, nIsOdd, y,\r\n        x = this;\r\n\r\n      n = new BigNumber(n);\r\n\r\n      // Allow NaN and ±Infinity, but not other non-integers.\r\n      if (n.c && !n.isInteger()) {\r\n        throw Error\r\n          (bignumberError + 'Exponent not an integer: ' + valueOf(n));\r\n      }\r\n\r\n      if (m != null) m = new BigNumber(m);\r\n\r\n      // Exponent of MAX_SAFE_INTEGER is 15.\r\n      nIsBig = n.e > 14;\r\n\r\n      // If x is NaN, ±Infinity, ±0 or ±1, or n is ±Infinity, NaN or ±0.\r\n      if (!x.c || !x.c[0] || x.c[0] == 1 && !x.e && x.c.length == 1 || !n.c || !n.c[0]) {\r\n\r\n        // The sign of the result of pow when x is negative depends on the evenness of n.\r\n        // If +n overflows to ±Infinity, the evenness of n would be not be known.\r\n        y = new BigNumber(Math.pow(+valueOf(x), nIsBig ? n.s * (2 - isOdd(n)) : +valueOf(n)));\r\n        return m ? y.mod(m) : y;\r\n      }\r\n\r\n      nIsNeg = n.s < 0;\r\n\r\n      if (m) {\r\n\r\n        // x % m returns NaN if abs(m) is zero, or m is NaN.\r\n        if (m.c ? !m.c[0] : !m.s) return new BigNumber(NaN);\r\n\r\n        isModExp = !nIsNeg && x.isInteger() && m.isInteger();\r\n\r\n        if (isModExp) x = x.mod(m);\r\n\r\n      // Overflow to ±Infinity: >=2**1e10 or >=1.0000024**1e15.\r\n      // Underflow to ±0: <=0.79**1e10 or <=0.9999975**1e15.\r\n      } else if (n.e > 9 && (x.e > 0 || x.e < -1 || (x.e == 0\r\n        // [1, 240000000]\r\n        ? x.c[0] > 1 || nIsBig && x.c[1] >= 24e7\r\n        // [80000000000000]  [99999750000000]\r\n        : x.c[0] < 8e13 || nIsBig && x.c[0] <= 9999975e7))) {\r\n\r\n        // If x is negative and n is odd, k = -0, else k = 0.\r\n        k = x.s < 0 && isOdd(n) ? -0 : 0;\r\n\r\n        // If x >= 1, k = ±Infinity.\r\n        if (x.e > -1) k = 1 / k;\r\n\r\n        // If n is negative return ±0, else return ±Infinity.\r\n        return new BigNumber(nIsNeg ? 1 / k : k);\r\n\r\n      } else if (POW_PRECISION) {\r\n\r\n        // Truncating each coefficient array to a length of k after each multiplication\r\n        // equates to truncating significant digits to POW_PRECISION + [28, 41],\r\n        // i.e. there will be a minimum of 28 guard digits retained.\r\n        k = mathceil(POW_PRECISION / LOG_BASE + 2);\r\n      }\r\n\r\n      if (nIsBig) {\r\n        half = new BigNumber(0.5);\r\n        if (nIsNeg) n.s = 1;\r\n        nIsOdd = isOdd(n);\r\n      } else {\r\n        i = Math.abs(+valueOf(n));\r\n        nIsOdd = i % 2;\r\n      }\r\n\r\n      y = new BigNumber(ONE);\r\n\r\n      // Performs 54 loop iterations for n of 9007199254740991.\r\n      for (; ;) {\r\n\r\n        if (nIsOdd) {\r\n          y = y.times(x);\r\n          if (!y.c) break;\r\n\r\n          if (k) {\r\n            if (y.c.length > k) y.c.length = k;\r\n          } else if (isModExp) {\r\n            y = y.mod(m);    //y = y.minus(div(y, m, 0, MODULO_MODE).times(m));\r\n          }\r\n        }\r\n\r\n        if (i) {\r\n          i = mathfloor(i / 2);\r\n          if (i === 0) break;\r\n          nIsOdd = i % 2;\r\n        } else {\r\n          n = n.times(half);\r\n          round(n, n.e + 1, 1);\r\n\r\n          if (n.e > 14) {\r\n            nIsOdd = isOdd(n);\r\n          } else {\r\n            i = +valueOf(n);\r\n            if (i === 0) break;\r\n            nIsOdd = i % 2;\r\n          }\r\n        }\r\n\r\n        x = x.times(x);\r\n\r\n        if (k) {\r\n          if (x.c && x.c.length > k) x.c.length = k;\r\n        } else if (isModExp) {\r\n          x = x.mod(m);    //x = x.minus(div(x, m, 0, MODULO_MODE).times(m));\r\n        }\r\n      }\r\n\r\n      if (isModExp) return y;\r\n      if (nIsNeg) y = ONE.div(y);\r\n\r\n      return m ? y.mod(m) : k ? round(y, POW_PRECISION, ROUNDING_MODE, more) : y;\r\n    };\r\n\r\n\r\n    /*\r\n     * Return a new BigNumber whose value is the value of this BigNumber rounded to an integer\r\n     * using rounding mode rm, or ROUNDING_MODE if rm is omitted.\r\n     *\r\n     * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n     *\r\n     * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {rm}'\r\n     */\r\n    P.integerValue = function (rm) {\r\n      var n = new BigNumber(this);\r\n      if (rm == null) rm = ROUNDING_MODE;\r\n      else intCheck(rm, 0, 8);\r\n      return round(n, n.e + 1, rm);\r\n    };\r\n\r\n\r\n    /*\r\n     * Return true if the value of this BigNumber is equal to the value of BigNumber(y, b),\r\n     * otherwise return false.\r\n     */\r\n    P.isEqualTo = P.eq = function (y, b) {\r\n      return compare(this, new BigNumber(y, b)) === 0;\r\n    };\r\n\r\n\r\n    /*\r\n     * Return true if the value of this BigNumber is a finite number, otherwise return false.\r\n     */\r\n    P.isFinite = function () {\r\n      return !!this.c;\r\n    };\r\n\r\n\r\n    /*\r\n     * Return true if the value of this BigNumber is greater than the value of BigNumber(y, b),\r\n     * otherwise return false.\r\n     */\r\n    P.isGreaterThan = P.gt = function (y, b) {\r\n      return compare(this, new BigNumber(y, b)) > 0;\r\n    };\r\n\r\n\r\n    /*\r\n     * Return true if the value of this BigNumber is greater than or equal to the value of\r\n     * BigNumber(y, b), otherwise return false.\r\n     */\r\n    P.isGreaterThanOrEqualTo = P.gte = function (y, b) {\r\n      return (b = compare(this, new BigNumber(y, b))) === 1 || b === 0;\r\n\r\n    };\r\n\r\n\r\n    /*\r\n     * Return true if the value of this BigNumber is an integer, otherwise return false.\r\n     */\r\n    P.isInteger = function () {\r\n      return !!this.c && bitFloor(this.e / LOG_BASE) > this.c.length - 2;\r\n    };\r\n\r\n\r\n    /*\r\n     * Return true if the value of this BigNumber is less than the value of BigNumber(y, b),\r\n     * otherwise return false.\r\n     */\r\n    P.isLessThan = P.lt = function (y, b) {\r\n      return compare(this, new BigNumber(y, b)) < 0;\r\n    };\r\n\r\n\r\n    /*\r\n     * Return true if the value of this BigNumber is less than or equal to the value of\r\n     * BigNumber(y, b), otherwise return false.\r\n     */\r\n    P.isLessThanOrEqualTo = P.lte = function (y, b) {\r\n      return (b = compare(this, new BigNumber(y, b))) === -1 || b === 0;\r\n    };\r\n\r\n\r\n    /*\r\n     * Return true if the value of this BigNumber is NaN, otherwise return false.\r\n     */\r\n    P.isNaN = function () {\r\n      return !this.s;\r\n    };\r\n\r\n\r\n    /*\r\n     * Return true if the value of this BigNumber is negative, otherwise return false.\r\n     */\r\n    P.isNegative = function () {\r\n      return this.s < 0;\r\n    };\r\n\r\n\r\n    /*\r\n     * Return true if the value of this BigNumber is positive, otherwise return false.\r\n     */\r\n    P.isPositive = function () {\r\n      return this.s > 0;\r\n    };\r\n\r\n\r\n    /*\r\n     * Return true if the value of this BigNumber is 0 or -0, otherwise return false.\r\n     */\r\n    P.isZero = function () {\r\n      return !!this.c && this.c[0] == 0;\r\n    };\r\n\r\n\r\n    /*\r\n     *  n - 0 = n\r\n     *  n - N = N\r\n     *  n - I = -I\r\n     *  0 - n = -n\r\n     *  0 - 0 = 0\r\n     *  0 - N = N\r\n     *  0 - I = -I\r\n     *  N - n = N\r\n     *  N - 0 = N\r\n     *  N - N = N\r\n     *  N - I = N\r\n     *  I - n = I\r\n     *  I - 0 = I\r\n     *  I - N = N\r\n     *  I - I = N\r\n     *\r\n     * Return a new BigNumber whose value is the value of this BigNumber minus the value of\r\n     * BigNumber(y, b).\r\n     */\r\n    P.minus = function (y, b) {\r\n      var i, j, t, xLTy,\r\n        x = this,\r\n        a = x.s;\r\n\r\n      y = new BigNumber(y, b);\r\n      b = y.s;\r\n\r\n      // Either NaN?\r\n      if (!a || !b) return new BigNumber(NaN);\r\n\r\n      // Signs differ?\r\n      if (a != b) {\r\n        y.s = -b;\r\n        return x.plus(y);\r\n      }\r\n\r\n      var xe = x.e / LOG_BASE,\r\n        ye = y.e / LOG_BASE,\r\n        xc = x.c,\r\n        yc = y.c;\r\n\r\n      if (!xe || !ye) {\r\n\r\n        // Either Infinity?\r\n        if (!xc || !yc) return xc ? (y.s = -b, y) : new BigNumber(yc ? x : NaN);\r\n\r\n        // Either zero?\r\n        if (!xc[0] || !yc[0]) {\r\n\r\n          // Return y if y is non-zero, x if x is non-zero, or zero if both are zero.\r\n          return yc[0] ? (y.s = -b, y) : new BigNumber(xc[0] ? x :\r\n\r\n           // IEEE 754 (2008) 6.3: n - n = -0 when rounding to -Infinity\r\n           ROUNDING_MODE == 3 ? -0 : 0);\r\n        }\r\n      }\r\n\r\n      xe = bitFloor(xe);\r\n      ye = bitFloor(ye);\r\n      xc = xc.slice();\r\n\r\n      // Determine which is the bigger number.\r\n      if (a = xe - ye) {\r\n\r\n        if (xLTy = a < 0) {\r\n          a = -a;\r\n          t = xc;\r\n        } else {\r\n          ye = xe;\r\n          t = yc;\r\n        }\r\n\r\n        t.reverse();\r\n\r\n        // Prepend zeros to equalise exponents.\r\n        for (b = a; b--; t.push(0));\r\n        t.reverse();\r\n      } else {\r\n\r\n        // Exponents equal. Check digit by digit.\r\n        j = (xLTy = (a = xc.length) < (b = yc.length)) ? a : b;\r\n\r\n        for (a = b = 0; b < j; b++) {\r\n\r\n          if (xc[b] != yc[b]) {\r\n            xLTy = xc[b] < yc[b];\r\n            break;\r\n          }\r\n        }\r\n      }\r\n\r\n      // x < y? Point xc to the array of the bigger number.\r\n      if (xLTy) {\r\n        t = xc;\r\n        xc = yc;\r\n        yc = t;\r\n        y.s = -y.s;\r\n      }\r\n\r\n      b = (j = yc.length) - (i = xc.length);\r\n\r\n      // Append zeros to xc if shorter.\r\n      // No need to add zeros to yc if shorter as subtract only needs to start at yc.length.\r\n      if (b > 0) for (; b--; xc[i++] = 0);\r\n      b = BASE - 1;\r\n\r\n      // Subtract yc from xc.\r\n      for (; j > a;) {\r\n\r\n        if (xc[--j] < yc[j]) {\r\n          for (i = j; i && !xc[--i]; xc[i] = b);\r\n          --xc[i];\r\n          xc[j] += BASE;\r\n        }\r\n\r\n        xc[j] -= yc[j];\r\n      }\r\n\r\n      // Remove leading zeros and adjust exponent accordingly.\r\n      for (; xc[0] == 0; xc.splice(0, 1), --ye);\r\n\r\n      // Zero?\r\n      if (!xc[0]) {\r\n\r\n        // Following IEEE 754 (2008) 6.3,\r\n        // n - n = +0  but  n - n = -0  when rounding towards -Infinity.\r\n        y.s = ROUNDING_MODE == 3 ? -1 : 1;\r\n        y.c = [y.e = 0];\r\n        return y;\r\n      }\r\n\r\n      // No need to check for Infinity as +x - +y != Infinity && -x - -y != Infinity\r\n      // for finite x and y.\r\n      return normalise(y, xc, ye);\r\n    };\r\n\r\n\r\n    /*\r\n     *   n % 0 =  N\r\n     *   n % N =  N\r\n     *   n % I =  n\r\n     *   0 % n =  0\r\n     *  -0 % n = -0\r\n     *   0 % 0 =  N\r\n     *   0 % N =  N\r\n     *   0 % I =  0\r\n     *   N % n =  N\r\n     *   N % 0 =  N\r\n     *   N % N =  N\r\n     *   N % I =  N\r\n     *   I % n =  N\r\n     *   I % 0 =  N\r\n     *   I % N =  N\r\n     *   I % I =  N\r\n     *\r\n     * Return a new BigNumber whose value is the value of this BigNumber modulo the value of\r\n     * BigNumber(y, b). The result depends on the value of MODULO_MODE.\r\n     */\r\n    P.modulo = P.mod = function (y, b) {\r\n      var q, s,\r\n        x = this;\r\n\r\n      y = new BigNumber(y, b);\r\n\r\n      // Return NaN if x is Infinity or NaN, or y is NaN or zero.\r\n      if (!x.c || !y.s || y.c && !y.c[0]) {\r\n        return new BigNumber(NaN);\r\n\r\n      // Return x if y is Infinity or x is zero.\r\n      } else if (!y.c || x.c && !x.c[0]) {\r\n        return new BigNumber(x);\r\n      }\r\n\r\n      if (MODULO_MODE == 9) {\r\n\r\n        // Euclidian division: q = sign(y) * floor(x / abs(y))\r\n        // r = x - qy    where  0 <= r < abs(y)\r\n        s = y.s;\r\n        y.s = 1;\r\n        q = div(x, y, 0, 3);\r\n        y.s = s;\r\n        q.s *= s;\r\n      } else {\r\n        q = div(x, y, 0, MODULO_MODE);\r\n      }\r\n\r\n      y = x.minus(q.times(y));\r\n\r\n      // To match JavaScript %, ensure sign of zero is sign of dividend.\r\n      if (!y.c[0] && MODULO_MODE == 1) y.s = x.s;\r\n\r\n      return y;\r\n    };\r\n\r\n\r\n    /*\r\n     *  n * 0 = 0\r\n     *  n * N = N\r\n     *  n * I = I\r\n     *  0 * n = 0\r\n     *  0 * 0 = 0\r\n     *  0 * N = N\r\n     *  0 * I = N\r\n     *  N * n = N\r\n     *  N * 0 = N\r\n     *  N * N = N\r\n     *  N * I = N\r\n     *  I * n = I\r\n     *  I * 0 = N\r\n     *  I * N = N\r\n     *  I * I = I\r\n     *\r\n     * Return a new BigNumber whose value is the value of this BigNumber multiplied by the value\r\n     * of BigNumber(y, b).\r\n     */\r\n    P.multipliedBy = P.times = function (y, b) {\r\n      var c, e, i, j, k, m, xcL, xlo, xhi, ycL, ylo, yhi, zc,\r\n        base, sqrtBase,\r\n        x = this,\r\n        xc = x.c,\r\n        yc = (y = new BigNumber(y, b)).c;\r\n\r\n      // Either NaN, ±Infinity or ±0?\r\n      if (!xc || !yc || !xc[0] || !yc[0]) {\r\n\r\n        // Return NaN if either is NaN, or one is 0 and the other is Infinity.\r\n        if (!x.s || !y.s || xc && !xc[0] && !yc || yc && !yc[0] && !xc) {\r\n          y.c = y.e = y.s = null;\r\n        } else {\r\n          y.s *= x.s;\r\n\r\n          // Return ±Infinity if either is ±Infinity.\r\n          if (!xc || !yc) {\r\n            y.c = y.e = null;\r\n\r\n          // Return ±0 if either is ±0.\r\n          } else {\r\n            y.c = [0];\r\n            y.e = 0;\r\n          }\r\n        }\r\n\r\n        return y;\r\n      }\r\n\r\n      e = bitFloor(x.e / LOG_BASE) + bitFloor(y.e / LOG_BASE);\r\n      y.s *= x.s;\r\n      xcL = xc.length;\r\n      ycL = yc.length;\r\n\r\n      // Ensure xc points to longer array and xcL to its length.\r\n      if (xcL < ycL) {\r\n        zc = xc;\r\n        xc = yc;\r\n        yc = zc;\r\n        i = xcL;\r\n        xcL = ycL;\r\n        ycL = i;\r\n      }\r\n\r\n      // Initialise the result array with zeros.\r\n      for (i = xcL + ycL, zc = []; i--; zc.push(0));\r\n\r\n      base = BASE;\r\n      sqrtBase = SQRT_BASE;\r\n\r\n      for (i = ycL; --i >= 0;) {\r\n        c = 0;\r\n        ylo = yc[i] % sqrtBase;\r\n        yhi = yc[i] / sqrtBase | 0;\r\n\r\n        for (k = xcL, j = i + k; j > i;) {\r\n          xlo = xc[--k] % sqrtBase;\r\n          xhi = xc[k] / sqrtBase | 0;\r\n          m = yhi * xlo + xhi * ylo;\r\n          xlo = ylo * xlo + ((m % sqrtBase) * sqrtBase) + zc[j] + c;\r\n          c = (xlo / base | 0) + (m / sqrtBase | 0) + yhi * xhi;\r\n          zc[j--] = xlo % base;\r\n        }\r\n\r\n        zc[j] = c;\r\n      }\r\n\r\n      if (c) {\r\n        ++e;\r\n      } else {\r\n        zc.splice(0, 1);\r\n      }\r\n\r\n      return normalise(y, zc, e);\r\n    };\r\n\r\n\r\n    /*\r\n     * Return a new BigNumber whose value is the value of this BigNumber negated,\r\n     * i.e. multiplied by -1.\r\n     */\r\n    P.negated = function () {\r\n      var x = new BigNumber(this);\r\n      x.s = -x.s || null;\r\n      return x;\r\n    };\r\n\r\n\r\n    /*\r\n     *  n + 0 = n\r\n     *  n + N = N\r\n     *  n + I = I\r\n     *  0 + n = n\r\n     *  0 + 0 = 0\r\n     *  0 + N = N\r\n     *  0 + I = I\r\n     *  N + n = N\r\n     *  N + 0 = N\r\n     *  N + N = N\r\n     *  N + I = N\r\n     *  I + n = I\r\n     *  I + 0 = I\r\n     *  I + N = N\r\n     *  I + I = I\r\n     *\r\n     * Return a new BigNumber whose value is the value of this BigNumber plus the value of\r\n     * BigNumber(y, b).\r\n     */\r\n    P.plus = function (y, b) {\r\n      var t,\r\n        x = this,\r\n        a = x.s;\r\n\r\n      y = new BigNumber(y, b);\r\n      b = y.s;\r\n\r\n      // Either NaN?\r\n      if (!a || !b) return new BigNumber(NaN);\r\n\r\n      // Signs differ?\r\n       if (a != b) {\r\n        y.s = -b;\r\n        return x.minus(y);\r\n      }\r\n\r\n      var xe = x.e / LOG_BASE,\r\n        ye = y.e / LOG_BASE,\r\n        xc = x.c,\r\n        yc = y.c;\r\n\r\n      if (!xe || !ye) {\r\n\r\n        // Return ±Infinity if either ±Infinity.\r\n        if (!xc || !yc) return new BigNumber(a / 0);\r\n\r\n        // Either zero?\r\n        // Return y if y is non-zero, x if x is non-zero, or zero if both are zero.\r\n        if (!xc[0] || !yc[0]) return yc[0] ? y : new BigNumber(xc[0] ? x : a * 0);\r\n      }\r\n\r\n      xe = bitFloor(xe);\r\n      ye = bitFloor(ye);\r\n      xc = xc.slice();\r\n\r\n      // Prepend zeros to equalise exponents. Faster to use reverse then do unshifts.\r\n      if (a = xe - ye) {\r\n        if (a > 0) {\r\n          ye = xe;\r\n          t = yc;\r\n        } else {\r\n          a = -a;\r\n          t = xc;\r\n        }\r\n\r\n        t.reverse();\r\n        for (; a--; t.push(0));\r\n        t.reverse();\r\n      }\r\n\r\n      a = xc.length;\r\n      b = yc.length;\r\n\r\n      // Point xc to the longer array, and b to the shorter length.\r\n      if (a - b < 0) {\r\n        t = yc;\r\n        yc = xc;\r\n        xc = t;\r\n        b = a;\r\n      }\r\n\r\n      // Only start adding at yc.length - 1 as the further digits of xc can be ignored.\r\n      for (a = 0; b;) {\r\n        a = (xc[--b] = xc[b] + yc[b] + a) / BASE | 0;\r\n        xc[b] = BASE === xc[b] ? 0 : xc[b] % BASE;\r\n      }\r\n\r\n      if (a) {\r\n        xc = [a].concat(xc);\r\n        ++ye;\r\n      }\r\n\r\n      // No need to check for zero, as +x + +y != 0 && -x + -y != 0\r\n      // ye = MAX_EXP + 1 possible\r\n      return normalise(y, xc, ye);\r\n    };\r\n\r\n\r\n    /*\r\n     * If sd is undefined or null or true or false, return the number of significant digits of\r\n     * the value of this BigNumber, or null if the value of this BigNumber is ±Infinity or NaN.\r\n     * If sd is true include integer-part trailing zeros in the count.\r\n     *\r\n     * Otherwise, if sd is a number, return a new BigNumber whose value is the value of this\r\n     * BigNumber rounded to a maximum of sd significant digits using rounding mode rm, or\r\n     * ROUNDING_MODE if rm is omitted.\r\n     *\r\n     * sd {number|boolean} number: significant digits: integer, 1 to MAX inclusive.\r\n     *                     boolean: whether to count integer-part trailing zeros: true or false.\r\n     * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n     *\r\n     * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {sd|rm}'\r\n     */\r\n    P.precision = P.sd = function (sd, rm) {\r\n      var c, n, v,\r\n        x = this;\r\n\r\n      if (sd != null && sd !== !!sd) {\r\n        intCheck(sd, 1, MAX);\r\n        if (rm == null) rm = ROUNDING_MODE;\r\n        else intCheck(rm, 0, 8);\r\n\r\n        return round(new BigNumber(x), sd, rm);\r\n      }\r\n\r\n      if (!(c = x.c)) return null;\r\n      v = c.length - 1;\r\n      n = v * LOG_BASE + 1;\r\n\r\n      if (v = c[v]) {\r\n\r\n        // Subtract the number of trailing zeros of the last element.\r\n        for (; v % 10 == 0; v /= 10, n--);\r\n\r\n        // Add the number of digits of the first element.\r\n        for (v = c[0]; v >= 10; v /= 10, n++);\r\n      }\r\n\r\n      if (sd && x.e + 1 > n) n = x.e + 1;\r\n\r\n      return n;\r\n    };\r\n\r\n\r\n    /*\r\n     * Return a new BigNumber whose value is the value of this BigNumber shifted by k places\r\n     * (powers of 10). Shift to the right if n > 0, and to the left if n < 0.\r\n     *\r\n     * k {number} Integer, -MAX_SAFE_INTEGER to MAX_SAFE_INTEGER inclusive.\r\n     *\r\n     * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {k}'\r\n     */\r\n    P.shiftedBy = function (k) {\r\n      intCheck(k, -MAX_SAFE_INTEGER, MAX_SAFE_INTEGER);\r\n      return this.times('1e' + k);\r\n    };\r\n\r\n\r\n    /*\r\n     *  sqrt(-n) =  N\r\n     *  sqrt(N) =  N\r\n     *  sqrt(-I) =  N\r\n     *  sqrt(I) =  I\r\n     *  sqrt(0) =  0\r\n     *  sqrt(-0) = -0\r\n     *\r\n     * Return a new BigNumber whose value is the square root of the value of this BigNumber,\r\n     * rounded according to DECIMAL_PLACES and ROUNDING_MODE.\r\n     */\r\n    P.squareRoot = P.sqrt = function () {\r\n      var m, n, r, rep, t,\r\n        x = this,\r\n        c = x.c,\r\n        s = x.s,\r\n        e = x.e,\r\n        dp = DECIMAL_PLACES + 4,\r\n        half = new BigNumber('0.5');\r\n\r\n      // Negative/NaN/Infinity/zero?\r\n      if (s !== 1 || !c || !c[0]) {\r\n        return new BigNumber(!s || s < 0 && (!c || c[0]) ? NaN : c ? x : 1 / 0);\r\n      }\r\n\r\n      // Initial estimate.\r\n      s = Math.sqrt(+valueOf(x));\r\n\r\n      // Math.sqrt underflow/overflow?\r\n      // Pass x to Math.sqrt as integer, then adjust the exponent of the result.\r\n      if (s == 0 || s == 1 / 0) {\r\n        n = coeffToString(c);\r\n        if ((n.length + e) % 2 == 0) n += '0';\r\n        s = Math.sqrt(+n);\r\n        e = bitFloor((e + 1) / 2) - (e < 0 || e % 2);\r\n\r\n        if (s == 1 / 0) {\r\n          n = '5e' + e;\r\n        } else {\r\n          n = s.toExponential();\r\n          n = n.slice(0, n.indexOf('e') + 1) + e;\r\n        }\r\n\r\n        r = new BigNumber(n);\r\n      } else {\r\n        r = new BigNumber(s + '');\r\n      }\r\n\r\n      // Check for zero.\r\n      // r could be zero if MIN_EXP is changed after the this value was created.\r\n      // This would cause a division by zero (x/t) and hence Infinity below, which would cause\r\n      // coeffToString to throw.\r\n      if (r.c[0]) {\r\n        e = r.e;\r\n        s = e + dp;\r\n        if (s < 3) s = 0;\r\n\r\n        // Newton-Raphson iteration.\r\n        for (; ;) {\r\n          t = r;\r\n          r = half.times(t.plus(div(x, t, dp, 1)));\r\n\r\n          if (coeffToString(t.c).slice(0, s) === (n = coeffToString(r.c)).slice(0, s)) {\r\n\r\n            // The exponent of r may here be one less than the final result exponent,\r\n            // e.g 0.0009999 (e-4) --> 0.001 (e-3), so adjust s so the rounding digits\r\n            // are indexed correctly.\r\n            if (r.e < e) --s;\r\n            n = n.slice(s - 3, s + 1);\r\n\r\n            // The 4th rounding digit may be in error by -1 so if the 4 rounding digits\r\n            // are 9999 or 4999 (i.e. approaching a rounding boundary) continue the\r\n            // iteration.\r\n            if (n == '9999' || !rep && n == '4999') {\r\n\r\n              // On the first iteration only, check to see if rounding up gives the\r\n              // exact result as the nines may infinitely repeat.\r\n              if (!rep) {\r\n                round(t, t.e + DECIMAL_PLACES + 2, 0);\r\n\r\n                if (t.times(t).eq(x)) {\r\n                  r = t;\r\n                  break;\r\n                }\r\n              }\r\n\r\n              dp += 4;\r\n              s += 4;\r\n              rep = 1;\r\n            } else {\r\n\r\n              // If rounding digits are null, 0{0,4} or 50{0,3}, check for exact\r\n              // result. If not, then there are further digits and m will be truthy.\r\n              if (!+n || !+n.slice(1) && n.charAt(0) == '5') {\r\n\r\n                // Truncate to the first rounding digit.\r\n                round(r, r.e + DECIMAL_PLACES + 2, 1);\r\n                m = !r.times(r).eq(x);\r\n              }\r\n\r\n              break;\r\n            }\r\n          }\r\n        }\r\n      }\r\n\r\n      return round(r, r.e + DECIMAL_PLACES + 1, ROUNDING_MODE, m);\r\n    };\r\n\r\n\r\n    /*\r\n     * Return a string representing the value of this BigNumber in exponential notation and\r\n     * rounded using ROUNDING_MODE to dp fixed decimal places.\r\n     *\r\n     * [dp] {number} Decimal places. Integer, 0 to MAX inclusive.\r\n     * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n     *\r\n     * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {dp|rm}'\r\n     */\r\n    P.toExponential = function (dp, rm) {\r\n      if (dp != null) {\r\n        intCheck(dp, 0, MAX);\r\n        dp++;\r\n      }\r\n      return format(this, dp, rm, 1);\r\n    };\r\n\r\n\r\n    /*\r\n     * Return a string representing the value of this BigNumber in fixed-point notation rounding\r\n     * to dp fixed decimal places using rounding mode rm, or ROUNDING_MODE if rm is omitted.\r\n     *\r\n     * Note: as with JavaScript's number type, (-0).toFixed(0) is '0',\r\n     * but e.g. (-0.00001).toFixed(0) is '-0'.\r\n     *\r\n     * [dp] {number} Decimal places. Integer, 0 to MAX inclusive.\r\n     * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n     *\r\n     * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {dp|rm}'\r\n     */\r\n    P.toFixed = function (dp, rm) {\r\n      if (dp != null) {\r\n        intCheck(dp, 0, MAX);\r\n        dp = dp + this.e + 1;\r\n      }\r\n      return format(this, dp, rm);\r\n    };\r\n\r\n\r\n    /*\r\n     * Return a string representing the value of this BigNumber in fixed-point notation rounded\r\n     * using rm or ROUNDING_MODE to dp decimal places, and formatted according to the properties\r\n     * of the format or FORMAT object (see BigNumber.set).\r\n     *\r\n     * The formatting object may contain some or all of the properties shown below.\r\n     *\r\n     * FORMAT = {\r\n     *   prefix: '',\r\n     *   groupSize: 3,\r\n     *   secondaryGroupSize: 0,\r\n     *   groupSeparator: ',',\r\n     *   decimalSeparator: '.',\r\n     *   fractionGroupSize: 0,\r\n     *   fractionGroupSeparator: '\\xA0',      // non-breaking space\r\n     *   suffix: ''\r\n     * };\r\n     *\r\n     * [dp] {number} Decimal places. Integer, 0 to MAX inclusive.\r\n     * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n     * [format] {object} Formatting options. See FORMAT pbject above.\r\n     *\r\n     * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {dp|rm}'\r\n     * '[BigNumber Error] Argument not an object: {format}'\r\n     */\r\n    P.toFormat = function (dp, rm, format) {\r\n      var str,\r\n        x = this;\r\n\r\n      if (format == null) {\r\n        if (dp != null && rm && typeof rm == 'object') {\r\n          format = rm;\r\n          rm = null;\r\n        } else if (dp && typeof dp == 'object') {\r\n          format = dp;\r\n          dp = rm = null;\r\n        } else {\r\n          format = FORMAT;\r\n        }\r\n      } else if (typeof format != 'object') {\r\n        throw Error\r\n          (bignumberError + 'Argument not an object: ' + format);\r\n      }\r\n\r\n      str = x.toFixed(dp, rm);\r\n\r\n      if (x.c) {\r\n        var i,\r\n          arr = str.split('.'),\r\n          g1 = +format.groupSize,\r\n          g2 = +format.secondaryGroupSize,\r\n          groupSeparator = format.groupSeparator || '',\r\n          intPart = arr[0],\r\n          fractionPart = arr[1],\r\n          isNeg = x.s < 0,\r\n          intDigits = isNeg ? intPart.slice(1) : intPart,\r\n          len = intDigits.length;\r\n\r\n        if (g2) {\r\n          i = g1;\r\n          g1 = g2;\r\n          g2 = i;\r\n          len -= i;\r\n        }\r\n\r\n        if (g1 > 0 && len > 0) {\r\n          i = len % g1 || g1;\r\n          intPart = intDigits.substr(0, i);\r\n          for (; i < len; i += g1) intPart += groupSeparator + intDigits.substr(i, g1);\r\n          if (g2 > 0) intPart += groupSeparator + intDigits.slice(i);\r\n          if (isNeg) intPart = '-' + intPart;\r\n        }\r\n\r\n        str = fractionPart\r\n         ? intPart + (format.decimalSeparator || '') + ((g2 = +format.fractionGroupSize)\r\n          ? fractionPart.replace(new RegExp('\\\\d{' + g2 + '}\\\\B', 'g'),\r\n           '$&' + (format.fractionGroupSeparator || ''))\r\n          : fractionPart)\r\n         : intPart;\r\n      }\r\n\r\n      return (format.prefix || '') + str + (format.suffix || '');\r\n    };\r\n\r\n\r\n    /*\r\n     * Return an array of two BigNumbers representing the value of this BigNumber as a simple\r\n     * fraction with an integer numerator and an integer denominator.\r\n     * The denominator will be a positive non-zero value less than or equal to the specified\r\n     * maximum denominator. If a maximum denominator is not specified, the denominator will be\r\n     * the lowest value necessary to represent the number exactly.\r\n     *\r\n     * [md] {number|string|BigNumber} Integer >= 1, or Infinity. The maximum denominator.\r\n     *\r\n     * '[BigNumber Error] Argument {not an integer|out of range} : {md}'\r\n     */\r\n    P.toFraction = function (md) {\r\n      var d, d0, d1, d2, e, exp, n, n0, n1, q, r, s,\r\n        x = this,\r\n        xc = x.c;\r\n\r\n      if (md != null) {\r\n        n = new BigNumber(md);\r\n\r\n        // Throw if md is less than one or is not an integer, unless it is Infinity.\r\n        if (!n.isInteger() && (n.c || n.s !== 1) || n.lt(ONE)) {\r\n          throw Error\r\n            (bignumberError + 'Argument ' +\r\n              (n.isInteger() ? 'out of range: ' : 'not an integer: ') + valueOf(n));\r\n        }\r\n      }\r\n\r\n      if (!xc) return new BigNumber(x);\r\n\r\n      d = new BigNumber(ONE);\r\n      n1 = d0 = new BigNumber(ONE);\r\n      d1 = n0 = new BigNumber(ONE);\r\n      s = coeffToString(xc);\r\n\r\n      // Determine initial denominator.\r\n      // d is a power of 10 and the minimum max denominator that specifies the value exactly.\r\n      e = d.e = s.length - x.e - 1;\r\n      d.c[0] = POWS_TEN[(exp = e % LOG_BASE) < 0 ? LOG_BASE + exp : exp];\r\n      md = !md || n.comparedTo(d) > 0 ? (e > 0 ? d : n1) : n;\r\n\r\n      exp = MAX_EXP;\r\n      MAX_EXP = 1 / 0;\r\n      n = new BigNumber(s);\r\n\r\n      // n0 = d1 = 0\r\n      n0.c[0] = 0;\r\n\r\n      for (; ;)  {\r\n        q = div(n, d, 0, 1);\r\n        d2 = d0.plus(q.times(d1));\r\n        if (d2.comparedTo(md) == 1) break;\r\n        d0 = d1;\r\n        d1 = d2;\r\n        n1 = n0.plus(q.times(d2 = n1));\r\n        n0 = d2;\r\n        d = n.minus(q.times(d2 = d));\r\n        n = d2;\r\n      }\r\n\r\n      d2 = div(md.minus(d0), d1, 0, 1);\r\n      n0 = n0.plus(d2.times(n1));\r\n      d0 = d0.plus(d2.times(d1));\r\n      n0.s = n1.s = x.s;\r\n      e = e * 2;\r\n\r\n      // Determine which fraction is closer to x, n0/d0 or n1/d1\r\n      r = div(n1, d1, e, ROUNDING_MODE).minus(x).abs().comparedTo(\r\n          div(n0, d0, e, ROUNDING_MODE).minus(x).abs()) < 1 ? [n1, d1] : [n0, d0];\r\n\r\n      MAX_EXP = exp;\r\n\r\n      return r;\r\n    };\r\n\r\n\r\n    /*\r\n     * Return the value of this BigNumber converted to a number primitive.\r\n     */\r\n    P.toNumber = function () {\r\n      return +valueOf(this);\r\n    };\r\n\r\n\r\n    /*\r\n     * Return a string representing the value of this BigNumber rounded to sd significant digits\r\n     * using rounding mode rm or ROUNDING_MODE. If sd is less than the number of digits\r\n     * necessary to represent the integer part of the value in fixed-point notation, then use\r\n     * exponential notation.\r\n     *\r\n     * [sd] {number} Significant digits. Integer, 1 to MAX inclusive.\r\n     * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n     *\r\n     * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {sd|rm}'\r\n     */\r\n    P.toPrecision = function (sd, rm) {\r\n      if (sd != null) intCheck(sd, 1, MAX);\r\n      return format(this, sd, rm, 2);\r\n    };\r\n\r\n\r\n    /*\r\n     * Return a string representing the value of this BigNumber in base b, or base 10 if b is\r\n     * omitted. If a base is specified, including base 10, round according to DECIMAL_PLACES and\r\n     * ROUNDING_MODE. If a base is not specified, and this BigNumber has a positive exponent\r\n     * that is equal to or greater than TO_EXP_POS, or a negative exponent equal to or less than\r\n     * TO_EXP_NEG, return exponential notation.\r\n     *\r\n     * [b] {number} Integer, 2 to ALPHABET.length inclusive.\r\n     *\r\n     * '[BigNumber Error] Base {not a primitive number|not an integer|out of range}: {b}'\r\n     */\r\n    P.toString = function (b) {\r\n      var str,\r\n        n = this,\r\n        s = n.s,\r\n        e = n.e;\r\n\r\n      // Infinity or NaN?\r\n      if (e === null) {\r\n        if (s) {\r\n          str = 'Infinity';\r\n          if (s < 0) str = '-' + str;\r\n        } else {\r\n          str = 'NaN';\r\n        }\r\n      } else {\r\n        if (b == null) {\r\n          str = e <= TO_EXP_NEG || e >= TO_EXP_POS\r\n           ? toExponential(coeffToString(n.c), e)\r\n           : toFixedPoint(coeffToString(n.c), e, '0');\r\n        } else if (b === 10 && alphabetHasNormalDecimalDigits) {\r\n          n = round(new BigNumber(n), DECIMAL_PLACES + e + 1, ROUNDING_MODE);\r\n          str = toFixedPoint(coeffToString(n.c), n.e, '0');\r\n        } else {\r\n          intCheck(b, 2, ALPHABET.length, 'Base');\r\n          str = convertBase(toFixedPoint(coeffToString(n.c), e, '0'), 10, b, s, true);\r\n        }\r\n\r\n        if (s < 0 && n.c[0]) str = '-' + str;\r\n      }\r\n\r\n      return str;\r\n    };\r\n\r\n\r\n    /*\r\n     * Return as toString, but do not accept a base argument, and include the minus sign for\r\n     * negative zero.\r\n     */\r\n    P.valueOf = P.toJSON = function () {\r\n      return valueOf(this);\r\n    };\r\n\r\n\r\n    P._isBigNumber = true;\r\n\r\n    if (configObject != null) BigNumber.set(configObject);\r\n\r\n    return BigNumber;\r\n  }\r\n\r\n\r\n  // PRIVATE HELPER FUNCTIONS\r\n\r\n  // These functions don't need access to variables,\r\n  // e.g. DECIMAL_PLACES, in the scope of the `clone` function above.\r\n\r\n\r\n  function bitFloor(n) {\r\n    var i = n | 0;\r\n    return n > 0 || n === i ? i : i - 1;\r\n  }\r\n\r\n\r\n  // Return a coefficient array as a string of base 10 digits.\r\n  function coeffToString(a) {\r\n    var s, z,\r\n      i = 1,\r\n      j = a.length,\r\n      r = a[0] + '';\r\n\r\n    for (; i < j;) {\r\n      s = a[i++] + '';\r\n      z = LOG_BASE - s.length;\r\n      for (; z--; s = '0' + s);\r\n      r += s;\r\n    }\r\n\r\n    // Determine trailing zeros.\r\n    for (j = r.length; r.charCodeAt(--j) === 48;);\r\n\r\n    return r.slice(0, j + 1 || 1);\r\n  }\r\n\r\n\r\n  // Compare the value of BigNumbers x and y.\r\n  function compare(x, y) {\r\n    var a, b,\r\n      xc = x.c,\r\n      yc = y.c,\r\n      i = x.s,\r\n      j = y.s,\r\n      k = x.e,\r\n      l = y.e;\r\n\r\n    // Either NaN?\r\n    if (!i || !j) return null;\r\n\r\n    a = xc && !xc[0];\r\n    b = yc && !yc[0];\r\n\r\n    // Either zero?\r\n    if (a || b) return a ? b ? 0 : -j : i;\r\n\r\n    // Signs differ?\r\n    if (i != j) return i;\r\n\r\n    a = i < 0;\r\n    b = k == l;\r\n\r\n    // Either Infinity?\r\n    if (!xc || !yc) return b ? 0 : !xc ^ a ? 1 : -1;\r\n\r\n    // Compare exponents.\r\n    if (!b) return k > l ^ a ? 1 : -1;\r\n\r\n    j = (k = xc.length) < (l = yc.length) ? k : l;\r\n\r\n    // Compare digit by digit.\r\n    for (i = 0; i < j; i++) if (xc[i] != yc[i]) return xc[i] > yc[i] ^ a ? 1 : -1;\r\n\r\n    // Compare lengths.\r\n    return k == l ? 0 : k > l ^ a ? 1 : -1;\r\n  }\r\n\r\n\r\n  /*\r\n   * Check that n is a primitive number, an integer, and in range, otherwise throw.\r\n   */\r\n  function intCheck(n, min, max, name) {\r\n    if (n < min || n > max || n !== mathfloor(n)) {\r\n      throw Error\r\n       (bignumberError + (name || 'Argument') + (typeof n == 'number'\r\n         ? n < min || n > max ? ' out of range: ' : ' not an integer: '\r\n         : ' not a primitive number: ') + String(n));\r\n    }\r\n  }\r\n\r\n\r\n  // Assumes finite n.\r\n  function isOdd(n) {\r\n    var k = n.c.length - 1;\r\n    return bitFloor(n.e / LOG_BASE) == k && n.c[k] % 2 != 0;\r\n  }\r\n\r\n\r\n  function toExponential(str, e) {\r\n    return (str.length > 1 ? str.charAt(0) + '.' + str.slice(1) : str) +\r\n     (e < 0 ? 'e' : 'e+') + e;\r\n  }\r\n\r\n\r\n  function toFixedPoint(str, e, z) {\r\n    var len, zs;\r\n\r\n    // Negative exponent?\r\n    if (e < 0) {\r\n\r\n      // Prepend zeros.\r\n      for (zs = z + '.'; ++e; zs += z);\r\n      str = zs + str;\r\n\r\n    // Positive exponent\r\n    } else {\r\n      len = str.length;\r\n\r\n      // Append zeros.\r\n      if (++e > len) {\r\n        for (zs = z, e -= len; --e; zs += z);\r\n        str += zs;\r\n      } else if (e < len) {\r\n        str = str.slice(0, e) + '.' + str.slice(e);\r\n      }\r\n    }\r\n\r\n    return str;\r\n  }\r\n\r\n\r\n  // EXPORT\r\n\r\n\r\n  BigNumber = clone();\r\n  BigNumber['default'] = BigNumber.BigNumber = BigNumber;\r\n\r\n  // AMD.\r\n  if (typeof define == 'function' && define.amd) {\r\n    define(function () { return BigNumber; });\r\n\r\n  // Node.js and other environments that support module.exports.\r\n  } else if (typeof module != 'undefined' && module.exports) {\r\n    module.exports = BigNumber;\r\n\r\n  // Browser.\r\n  } else {\r\n    if (!globalObject) {\r\n      globalObject = typeof self != 'undefined' && self ? self : window;\r\n    }\r\n\r\n    globalObject.BigNumber = BigNumber;\r\n  }\r\n})(this);\r\n","/*!\n * Copyright (c) 2017 Benjamin Van Ryseghem<benjamin@vanryseghem.com>\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\n\nconst globalState = require(\"./globalState\");\nconst validating = require(\"./validating\");\nconst parsing = require(\"./parsing\");\nconst BigNumber = require(\"bignumber.js\");\n\nconst powers = {\n    trillion: Math.pow(10, 12),\n    billion: Math.pow(10, 9),\n    million: Math.pow(10, 6),\n    thousand: Math.pow(10, 3)\n};\n\nconst defaultOptions = {\n    totalLength: 0,\n    characteristic: 0,\n    forceAverage: false,\n    average: false,\n    mantissa: -1,\n    optionalMantissa: true,\n    thousandSeparated: false,\n    spaceSeparated: false,\n    negative: \"sign\",\n    forceSign: false,\n    roundingFunction: Math.round,\n    spaceSeparatedAbbreviation: false\n};\n\nconst { binarySuffixes, decimalSuffixes } = globalState.currentBytes();\n\nconst bytes = {\n    general: { scale: 1024, suffixes: decimalSuffixes, marker: \"bd\" },\n    binary: { scale: 1024, suffixes: binarySuffixes, marker: \"b\" },\n    decimal: { scale: 1000, suffixes: decimalSuffixes, marker: \"d\" }\n};\n\n/**\n * Entry point. Format the provided INSTANCE according to the PROVIDEDFORMAT.\n * This method ensure the prefix and postfix are added as the last step.\n *\n * @param {Numbro} instance - numbro instance to format\n * @param {NumbroFormat|string} [providedFormat] - specification for formatting\n * @param numbro - the numbro singleton\n * @return {string}\n */\nfunction format(instance, providedFormat = {}, numbro) {\n    if (typeof providedFormat === \"string\") {\n        providedFormat = parsing.parseFormat(providedFormat);\n    }\n\n    let valid = validating.validateFormat(providedFormat);\n\n    if (!valid) {\n        return \"ERROR: invalid format\";\n    }\n\n    let prefix = providedFormat.prefix || \"\";\n    let postfix = providedFormat.postfix || \"\";\n\n    let output = formatNumbro(instance, providedFormat, numbro);\n    output = insertPrefix(output, prefix);\n    output = insertPostfix(output, postfix);\n    return output;\n}\n\n/**\n * Format the provided INSTANCE according to the PROVIDEDFORMAT.\n *\n * @param {Numbro} instance - numbro instance to format\n * @param {{}} providedFormat - specification for formatting\n * @param numbro - the numbro singleton\n * @return {string}\n */\nfunction formatNumbro(instance, providedFormat, numbro) {\n    switch (providedFormat.output) {\n        case \"currency\": {\n            providedFormat = formatOrDefault(providedFormat, globalState.currentCurrencyDefaultFormat());\n            return formatCurrency(instance, providedFormat, globalState, numbro);\n        }\n        case \"percent\": {\n            providedFormat = formatOrDefault(providedFormat, globalState.currentPercentageDefaultFormat());\n            return formatPercentage(instance, providedFormat, globalState, numbro);\n        }\n        case \"byte\":\n            providedFormat = formatOrDefault(providedFormat, globalState.currentByteDefaultFormat());\n            return formatByte(instance, providedFormat, globalState, numbro);\n        case \"time\":\n            providedFormat = formatOrDefault(providedFormat, globalState.currentTimeDefaultFormat());\n            return formatTime(instance, providedFormat, globalState, numbro);\n        case \"ordinal\":\n            providedFormat = formatOrDefault(providedFormat, globalState.currentOrdinalDefaultFormat());\n            return formatOrdinal(instance, providedFormat, globalState, numbro);\n        case \"number\":\n        default:\n            return formatNumber({\n                instance,\n                providedFormat,\n                numbro\n            });\n    }\n}\n\n/**\n * Get the decimal byte unit (MB) for the provided numbro INSTANCE.\n * We go from one unit to another using the decimal system (1000).\n *\n * @param {Numbro} instance - numbro instance to compute\n * @return {String}\n */\nfunction getDecimalByteUnit(instance) {\n    let data = bytes.decimal;\n    return getFormatByteUnits(instance._value, data.suffixes, data.scale).suffix;\n}\n\n/**\n * Get the binary byte unit (MiB) for the provided numbro INSTANCE.\n * We go from one unit to another using the decimal system (1024).\n *\n * @param {Numbro} instance - numbro instance to compute\n * @return {String}\n */\nfunction getBinaryByteUnit(instance) {\n    let data = bytes.binary;\n    return getFormatByteUnits(instance._value, data.suffixes, data.scale).suffix;\n}\n\n/**\n * Get the decimal byte unit (MB) for the provided numbro INSTANCE.\n * We go from one unit to another using the decimal system (1024).\n *\n * @param {Numbro} instance - numbro instance to compute\n * @return {String}\n */\nfunction getByteUnit(instance) {\n    let data = bytes.general;\n    return getFormatByteUnits(instance._value, data.suffixes, data.scale).suffix;\n}\n\n/**\n * Return the value and the suffix computed in byte.\n * It uses the SUFFIXES and the SCALE provided.\n *\n * @param {number} value - Number to format\n * @param {[String]} suffixes - List of suffixes\n * @param {number} scale - Number in-between two units\n * @return {{value: Number, suffix: String}}\n */\nfunction getFormatByteUnits(value, suffixes, scale) {\n    let suffix = suffixes[0];\n    let abs = Math.abs(value);\n\n    if (abs >= scale) {\n        for (let power = 1; power < suffixes.length; ++power) {\n            let min = Math.pow(scale, power);\n            let max = Math.pow(scale, power + 1);\n\n            if (abs >= min && abs < max) {\n                suffix = suffixes[power];\n                value = value / min;\n                break;\n            }\n        }\n\n        // values greater than or equal to [scale] YB never set the suffix\n        if (suffix === suffixes[0]) {\n            value = value / Math.pow(scale, suffixes.length - 1);\n            suffix = suffixes[suffixes.length - 1];\n        }\n    }\n\n    return { value, suffix };\n}\n\n/**\n * Format the provided INSTANCE as bytes using the PROVIDEDFORMAT, and STATE.\n *\n * @param {Numbro} instance - numbro instance to format\n * @param {{}} providedFormat - specification for formatting\n * @param {globalState} state - shared state of the library\n * @param numbro - the numbro singleton\n * @return {string}\n */\nfunction formatByte(instance, providedFormat, state, numbro) {\n    let base = providedFormat.base || \"binary\";\n    let options = Object.assign({}, defaultOptions, providedFormat);\n\n    const { binarySuffixes: localBinarySuffixes, decimalSuffixes: localDecimalSuffixes } = state.currentBytes();\n\n    const localBytes = {\n        general: { scale: 1024, suffixes: localDecimalSuffixes || decimalSuffixes, marker: \"bd\" },\n        binary: { scale: 1024, suffixes: localBinarySuffixes || binarySuffixes, marker: \"b\" },\n        decimal: { scale: 1000, suffixes: localDecimalSuffixes || decimalSuffixes, marker: \"d\" }\n    };\n    let baseInfo = localBytes[base];\n\n    let { value, suffix } = getFormatByteUnits(instance._value, baseInfo.suffixes, baseInfo.scale);\n\n    let output = formatNumber({\n        instance: numbro(value),\n        providedFormat,\n        state,\n        defaults: state.currentByteDefaultFormat()\n    });\n\n    return `${output}${options.spaceSeparated ? \" \" : \"\"}${suffix}`;\n}\n\n/**\n * Format the provided INSTANCE as an ordinal using the PROVIDEDFORMAT,\n * and the STATE.\n *\n * @param {Numbro} instance - numbro instance to format\n * @param {{}} providedFormat - specification for formatting\n * @param {globalState} state - shared state of the library\n * @return {string}\n */\nfunction formatOrdinal(instance, providedFormat, state) {\n    let ordinalFn = state.currentOrdinal();\n    let options = Object.assign({}, defaultOptions, providedFormat);\n\n    let output = formatNumber({\n        instance,\n        providedFormat,\n        state\n    });\n    let ordinal = ordinalFn(instance._value);\n\n    return `${output}${options.spaceSeparated ? \" \" : \"\"}${ordinal}`;\n}\n\n/**\n * Format the provided INSTANCE as a time HH:MM:SS.\n *\n * @param {Numbro} instance - numbro instance to format\n * @return {string}\n */\nfunction formatTime(instance) {\n    let hours = Math.floor(instance._value / 60 / 60);\n    let minutes = Math.floor((instance._value - (hours * 60 * 60)) / 60);\n    let seconds = Math.round(instance._value - (hours * 60 * 60) - (minutes * 60));\n    return `${hours}:${(minutes < 10) ? \"0\" : \"\"}${minutes}:${(seconds < 10) ? \"0\" : \"\"}${seconds}`;\n}\n\n/**\n * Format the provided INSTANCE as a percentage using the PROVIDEDFORMAT,\n * and the STATE.\n *\n * @param {Numbro} instance - numbro instance to format\n * @param {{}} providedFormat - specification for formatting\n * @param {globalState} state - shared state of the library\n * @param numbro - the numbro singleton\n * @return {string}\n */\nfunction formatPercentage(instance, providedFormat, state, numbro) {\n    let prefixSymbol = providedFormat.prefixSymbol;\n\n    let output = formatNumber({\n        instance: numbro(instance._value * 100),\n        providedFormat,\n        state\n    });\n    let options = Object.assign({}, defaultOptions, providedFormat);\n\n    if (prefixSymbol) {\n        return `%${options.spaceSeparated ? \" \" : \"\"}${output}`;\n    }\n\n    return `${output}${options.spaceSeparated ? \" \" : \"\"}%`;\n}\n\n/**\n * Format the provided INSTANCE as a percentage using the PROVIDEDFORMAT,\n * and the STATE.\n *\n * @param {Numbro} instance - numbro instance to format\n * @param {{}} providedFormat - specification for formatting\n * @param {globalState} state - shared state of the library\n * @return {string}\n */\nfunction formatCurrency(instance, providedFormat, state) {\n    const currentCurrency = state.currentCurrency();\n    let clonedFormat = Object.assign({}, providedFormat);\n    let options = Object.assign({}, defaultOptions, clonedFormat);\n    let decimalSeparator = undefined;\n    let space = \"\";\n    let average = !!options.totalLength || !!options.forceAverage || options.average;\n    let position = clonedFormat.currencyPosition || currentCurrency.position;\n    let symbol = clonedFormat.currencySymbol || currentCurrency.symbol;\n    const spaceSeparatedCurrency = options.spaceSeparatedCurrency !== void 0\n        ? options.spaceSeparatedCurrency : options.spaceSeparated;\n\n    if (clonedFormat.lowPrecision === undefined) {\n        clonedFormat.lowPrecision = false;\n    }\n\n    if (spaceSeparatedCurrency) {\n        space = \" \";\n    }\n\n    if (position === \"infix\") {\n        decimalSeparator = space + symbol + space;\n    }\n\n    let output = formatNumber({\n        instance,\n        providedFormat: clonedFormat,\n        state,\n        decimalSeparator\n    });\n\n    if (position === \"prefix\") {\n        if (instance._value < 0 && options.negative === \"sign\") {\n            output = `-${space}${symbol}${output.slice(1)}`;\n        } else if (instance._value > 0 && options.forceSign) {\n            output = `+${space}${symbol}${output.slice(1)}`;\n        } else {\n            output = symbol + space + output;\n        }\n    }\n\n    if (!position || position === \"postfix\") {\n        space = !options.spaceSeparatedAbbreviation && average ? \"\" : space;\n        output = output + space + symbol;\n    }\n\n    return output;\n}\n\n/**\n * Compute the average value out of VALUE.\n * The other parameters are computation options.\n *\n * @param {number} value - value to compute\n * @param {string} [forceAverage] - forced unit used to compute\n * @param {boolean} [lowPrecision=true] - reduce average precision\n * @param {{}} abbreviations - part of the language specification\n * @param {boolean} spaceSeparated - `true` if a space must be inserted between the value and the abbreviation\n * @param {number} [totalLength] - total length of the output including the characteristic and the mantissa\n * @param {function} roundingFunction - function used to round numbers\n * @return {{value: number, abbreviation: string, mantissaPrecision: number}}\n */\nfunction computeAverage({ value, forceAverage, lowPrecision = true, abbreviations, spaceSeparated = false, totalLength = 0, roundingFunction = Math.round }) {\n    let abbreviation = \"\";\n    let abs = Math.abs(value);\n    let mantissaPrecision = -1;\n\n    if (forceAverage && abbreviations[forceAverage] && powers[forceAverage]) {\n        abbreviation = abbreviations[forceAverage];\n        value = value / powers[forceAverage];\n    } else {\n        if (abs >= powers.trillion || (lowPrecision && roundingFunction(abs / powers.trillion) === 1)) {\n            // trillion\n            abbreviation = abbreviations.trillion;\n            value = value / powers.trillion;\n        } else if (abs < powers.trillion && abs >= powers.billion || (lowPrecision && roundingFunction(abs / powers.billion) === 1)) {\n            // billion\n            abbreviation = abbreviations.billion;\n            value = value / powers.billion;\n        } else if (abs < powers.billion && abs >= powers.million || (lowPrecision && roundingFunction(abs / powers.million) === 1)) {\n            // million\n            abbreviation = abbreviations.million;\n            value = value / powers.million;\n        } else if (abs < powers.million && abs >= powers.thousand || (lowPrecision && roundingFunction(abs / powers.thousand) === 1)) {\n            // thousand\n            abbreviation = abbreviations.thousand;\n            value = value / powers.thousand;\n        }\n    }\n\n    let optionalSpace = spaceSeparated ? \" \" : \"\";\n\n    if (abbreviation) {\n        abbreviation = optionalSpace + abbreviation;\n    }\n\n    if (totalLength) {\n        let isNegative = value < 0;\n        let characteristic = value.toString().split(\".\")[0];\n\n        let characteristicLength = isNegative\n            ? characteristic.length - 1\n            : characteristic.length;\n\n        mantissaPrecision = Math.max(totalLength - characteristicLength, 0);\n    }\n\n    return { value, abbreviation, mantissaPrecision };\n}\n\n/**\n * Compute an exponential form for VALUE, taking into account CHARACTERISTIC\n * if provided.\n * @param {number} value - value to compute\n * @param {number} [characteristicPrecision] - optional characteristic length\n * @return {{value: number, abbreviation: string}}\n */\nfunction computeExponential({ value, characteristicPrecision }) {\n    let [numberString, exponential] = value.toExponential().split(\"e\");\n    let number = +numberString;\n\n    if (!characteristicPrecision) {\n        return {\n            value: number,\n            abbreviation: `e${exponential}`\n        };\n    }\n\n    let characteristicLength = 1; // see `toExponential`\n\n    if (characteristicLength < characteristicPrecision) {\n        number = number * Math.pow(10, characteristicPrecision - characteristicLength);\n        exponential = +exponential - (characteristicPrecision - characteristicLength);\n        exponential = exponential >= 0 ? `+${exponential}` : exponential;\n    }\n\n    return {\n        value: number,\n        abbreviation: `e${exponential}`\n    };\n}\n\n/**\n * Return a string of NUMBER zero.\n *\n * @param {number} number - Length of the output\n * @return {string}\n */\nfunction zeroes(number) {\n    let result = \"\";\n    for (let i = 0; i < number; i++) {\n        result += \"0\";\n    }\n\n    return result;\n}\n\n/**\n * Return a string representing VALUE with a PRECISION-long mantissa.\n * This method is for large/small numbers only (a.k.a. including a \"e\").\n *\n * @param {number} value - number to precise\n * @param {number} precision - desired length for the mantissa\n * @return {string}\n */\nfunction toFixedLarge(value, precision) {\n    let result = value.toString();\n\n    let [base, exp] = result.split(\"e\");\n\n    let [characteristic, mantissa = \"\"] = base.split(\".\");\n\n    if (+exp > 0) {\n        result = characteristic + mantissa + zeroes(exp - mantissa.length);\n    } else {\n        let prefix = \".\";\n\n        if (+characteristic < 0) {\n            prefix = `-0${prefix}`;\n        } else {\n            prefix = `0${prefix}`;\n        }\n\n        let suffix = (zeroes(-exp - 1) + Math.abs(characteristic) + mantissa).substr(0, precision);\n        if (suffix.length < precision) {\n            suffix += zeroes(precision - suffix.length);\n        }\n        result = prefix + suffix;\n    }\n\n    if (+exp > 0 && precision > 0) {\n        result += `.${zeroes(precision)}`;\n    }\n\n    return result;\n}\n\n/**\n * Return a string representing VALUE with a PRECISION-long mantissa.\n *\n * @param {number} value - number to precise\n * @param {number} precision - desired length for the mantissa\n * @param {function} roundingFunction - rounding function to be used\n * @return {string}\n */\nfunction toFixed(value, precision, roundingFunction = Math.round) {\n    if (value.toString().indexOf(\"e\") !== -1) {\n        return toFixedLarge(value, precision);\n    }\n\n    const n = new BigNumber(roundingFunction(+`${value}e+${precision}`) / (Math.pow(10, precision)));\n    return n.toFixed(precision);\n}\n\n/**\n * Return the current OUTPUT with a mantissa precision of PRECISION.\n *\n * @param {string} output - output being build in the process of formatting\n * @param {number} value - number being currently formatted\n * @param {boolean} optionalMantissa - if `true`, the mantissa is omitted when it's only zeroes\n * @param {number} precision - desired precision of the mantissa\n * @param {boolean} trim - if `true`, trailing zeroes are removed from the mantissa\n * @return {string}\n */\nfunction setMantissaPrecision(output, value, optionalMantissa, precision, trim, roundingFunction) {\n    if (precision === -1) {\n        return output;\n    }\n\n    let result = toFixed(value, precision, roundingFunction);\n    let [currentCharacteristic, currentMantissa = \"\"] = result.toString().split(\".\");\n\n    if (currentMantissa.match(/^0+$/) && (optionalMantissa || trim)) {\n        return currentCharacteristic;\n    }\n\n    let hasTrailingZeroes = currentMantissa.match(/0+$/);\n    if (trim && hasTrailingZeroes) {\n        return `${currentCharacteristic}.${currentMantissa.toString().slice(0, hasTrailingZeroes.index)}`;\n    }\n\n    return result.toString();\n}\n\n/**\n * Return the current OUTPUT with a characteristic precision of PRECISION.\n *\n * @param {string} output - output being build in the process of formatting\n * @param {number} value - number being currently formatted\n * @param {boolean} optionalCharacteristic - `true` if the characteristic is omitted when it's only zeroes\n * @param {number} precision - desired precision of the characteristic\n * @return {string}\n */\nfunction setCharacteristicPrecision(output, value, optionalCharacteristic, precision) {\n    let result = output;\n    let [currentCharacteristic, currentMantissa] = result.toString().split(\".\");\n\n    if (currentCharacteristic.match(/^-?0$/) && optionalCharacteristic) {\n        if (!currentMantissa) {\n            return currentCharacteristic.replace(\"0\", \"\");\n        }\n\n        return `${currentCharacteristic.replace(\"0\", \"\")}.${currentMantissa}`;\n    }\n\n    const hasNegativeSign = value < 0 && currentCharacteristic.indexOf(\"-\") === 0;\n    if (hasNegativeSign) {\n            // Remove the negative sign\n            currentCharacteristic = currentCharacteristic.slice(1);\n            result = result.slice(1);\n    }\n\n    if (currentCharacteristic.length < precision) {\n        let missingZeros = precision - currentCharacteristic.length;\n        for (let i = 0; i < missingZeros; i++) {\n            result = `0${result}`;\n        }\n    }\n\n    if (hasNegativeSign) {\n        // Add back the minus sign\n        result = `-${result}`;\n    }\n    return result.toString();\n}\n\n/**\n * Return the indexes where are the group separations after splitting\n * `totalLength` in group of `groupSize` size.\n * Important: we start grouping from the right hand side.\n *\n * @param {number} totalLength - total length of the characteristic to split\n * @param {number} groupSize - length of each group\n * @return {[number]}\n */\nfunction indexesOfGroupSpaces(totalLength, groupSize) {\n    let result = [];\n    let counter = 0;\n    for (let i = totalLength; i > 0; i--) {\n        if (counter === groupSize) {\n            result.unshift(i);\n            counter = 0;\n        }\n        counter++;\n    }\n\n    return result;\n}\n\n/**\n * Replace the decimal separator with DECIMALSEPARATOR and insert thousand\n * separators.\n *\n * @param {string} output - output being build in the process of formatting\n * @param {number} value - number being currently formatted\n * @param {boolean} thousandSeparated - `true` if the characteristic must be separated\n * @param {globalState} state - shared state of the library\n * @param {string} decimalSeparator - string to use as decimal separator\n * @return {string}\n */\nfunction replaceDelimiters(output, value, thousandSeparated, state, decimalSeparator) {\n    let delimiters = state.currentDelimiters();\n    let thousandSeparator = delimiters.thousands;\n    decimalSeparator = decimalSeparator || delimiters.decimal;\n    let thousandsSize = delimiters.thousandsSize || 3;\n\n    let result = output.toString();\n    let characteristic = result.split(\".\")[0];\n    let mantissa = result.split(\".\")[1];\n    const hasNegativeSign = value < 0 && characteristic.indexOf(\"-\") === 0;\n\n    if (thousandSeparated) {\n        if (hasNegativeSign) {\n            // Remove the negative sign\n            characteristic = characteristic.slice(1);\n        }\n\n        let indexesToInsertThousandDelimiters = indexesOfGroupSpaces(characteristic.length, thousandsSize);\n        indexesToInsertThousandDelimiters.forEach((position, index) => {\n            characteristic = characteristic.slice(0, position + index) + thousandSeparator + characteristic.slice(position + index);\n        });\n\n        if (hasNegativeSign) {\n            // Add back the negative sign\n            characteristic = `-${characteristic}`;\n        }\n    }\n\n    if (!mantissa) {\n        result = characteristic;\n    } else {\n        result = characteristic + decimalSeparator + mantissa;\n    }\n    return result;\n}\n\n/**\n * Insert the provided ABBREVIATION at the end of OUTPUT.\n *\n * @param {string} output - output being build in the process of formatting\n * @param {string} abbreviation - abbreviation to append\n * @return {*}\n */\nfunction insertAbbreviation(output, abbreviation) {\n    return output + abbreviation;\n}\n\n/**\n * Insert the positive/negative sign according to the NEGATIVE flag.\n * If the value is negative but still output as 0, the negative sign is removed.\n *\n * @param {string} output - output being build in the process of formatting\n * @param {number} value - number being currently formatted\n * @param {string} negative - flag for the negative form (\"sign\" or \"parenthesis\")\n * @return {*}\n */\nfunction insertSign(output, value, negative) {\n    if (value === 0) {\n        return output;\n    }\n\n    if (+output === 0) {\n        return output.replace(\"-\", \"\");\n    }\n\n    if (value > 0) {\n        return `+${output}`;\n    }\n\n    if (negative === \"sign\") {\n        return output;\n    }\n\n    return `(${output.replace(\"-\", \"\")})`;\n}\n\n/**\n * Insert the provided PREFIX at the start of OUTPUT.\n *\n * @param {string} output - output being build in the process of formatting\n * @param {string} prefix - abbreviation to prepend\n * @return {*}\n */\nfunction insertPrefix(output, prefix) {\n    return prefix + output;\n}\n\n/**\n * Insert the provided POSTFIX at the end of OUTPUT.\n *\n * @param {string} output - output being build in the process of formatting\n * @param {string} postfix - abbreviation to append\n * @return {*}\n */\nfunction insertPostfix(output, postfix) {\n    return output + postfix;\n}\n\n/**\n * Format the provided INSTANCE as a number using the PROVIDEDFORMAT,\n * and the STATE.\n * This is the key method of the framework!\n *\n * @param {Numbro} instance - numbro instance to format\n * @param {{}} [providedFormat] - specification for formatting\n * @param {globalState} state - shared state of the library\n * @param {string} decimalSeparator - string to use as decimal separator\n * @param {{}} defaults - Set of default values used for formatting\n * @return {string}\n */\nfunction formatNumber({ instance, providedFormat, state = globalState, decimalSeparator, defaults = state.currentDefaults() }) {\n    let value = instance._value;\n\n    if (value === 0 && state.hasZeroFormat()) {\n        return state.getZeroFormat();\n    }\n\n    if (!isFinite(value)) {\n        return value.toString();\n    }\n\n    let options = Object.assign({}, defaultOptions, defaults, providedFormat);\n\n    let totalLength = options.totalLength;\n    let characteristicPrecision = totalLength ? 0 : options.characteristic;\n    let optionalCharacteristic = options.optionalCharacteristic;\n    let forceAverage = options.forceAverage;\n    let lowPrecision = options.lowPrecision;\n    let average = !!totalLength || !!forceAverage || options.average;\n\n    // default when averaging is to chop off decimals\n    let mantissaPrecision = totalLength ? -1 : (average && providedFormat.mantissa === undefined ? 0 : options.mantissa);\n    let optionalMantissa = totalLength ? false : (providedFormat.optionalMantissa === undefined ? mantissaPrecision === -1 : options.optionalMantissa);\n    let trimMantissa = options.trimMantissa;\n    let thousandSeparated = options.thousandSeparated;\n    let spaceSeparated = options.spaceSeparated;\n    let negative = options.negative;\n    let forceSign = options.forceSign;\n    let exponential = options.exponential;\n    let roundingFunction = options.roundingFunction;\n\n    let abbreviation = \"\";\n    if (average) {\n        let data = computeAverage({\n            value,\n            forceAverage,\n            lowPrecision,\n            abbreviations: state.currentAbbreviations(),\n            spaceSeparated,\n            roundingFunction,\n            totalLength\n        });\n\n        value = data.value;\n        abbreviation += data.abbreviation;\n\n        if (totalLength) {\n            mantissaPrecision = data.mantissaPrecision;\n        }\n    }\n\n    if (exponential) {\n        let data = computeExponential({\n            value,\n            characteristicPrecision\n        });\n\n        value = data.value;\n        abbreviation = data.abbreviation + abbreviation;\n    }\n\n    let output = setMantissaPrecision(value.toString(), value, optionalMantissa, mantissaPrecision, trimMantissa, roundingFunction);\n    output = setCharacteristicPrecision(output, value, optionalCharacteristic, characteristicPrecision);\n    output = replaceDelimiters(output, value, thousandSeparated, state, decimalSeparator);\n\n    if (average || exponential) {\n        output = insertAbbreviation(output, abbreviation);\n    }\n\n    if (forceSign || value < 0) {\n        output = insertSign(output, value, negative);\n    }\n\n    return output;\n}\n\n/**\n * If FORMAT is non-null and not just an output, return FORMAT.\n * Return DEFAULTFORMAT otherwise.\n *\n * @param providedFormat\n * @param defaultFormat\n */\nfunction formatOrDefault(providedFormat, defaultFormat) {\n    if (!providedFormat) {\n        return defaultFormat;\n    }\n\n    let keys = Object.keys(providedFormat);\n    if (keys.length === 1 && keys[0] === \"output\") {\n        return defaultFormat;\n    }\n\n    return providedFormat;\n}\n\nmodule.exports = (numbro) => ({\n    format: (...args) => format(...args, numbro),\n    getByteUnit: (...args) => getByteUnit(...args, numbro),\n    getBinaryByteUnit: (...args) => getBinaryByteUnit(...args, numbro),\n    getDecimalByteUnit: (...args) => getDecimalByteUnit(...args, numbro),\n    formatOrDefault\n});\n","/*!\n * Copyright (c) 2017 Benjamin Van Ryseghem<benjamin@vanryseghem.com>\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\n\nconst BigNumber = require(\"bignumber.js\");\n\n/**\n * Add a number or a numbro to N.\n *\n * @param {Numbro} n - augend\n * @param {number|Numbro} other - addend\n * @param {numbro} numbro - numbro singleton\n * @return {Numbro} n\n */\nfunction add(n, other, numbro) {\n    let value = new BigNumber(n._value);\n    let otherValue = other;\n\n    if (numbro.isNumbro(other)) {\n        otherValue = other._value;\n    }\n\n    otherValue = new BigNumber(otherValue);\n\n    n._value = value.plus(otherValue).toNumber();\n    return n;\n}\n\n/**\n * Subtract a number or a numbro from N.\n *\n * @param {Numbro} n - minuend\n * @param {number|Numbro} other - subtrahend\n * @param {numbro} numbro - numbro singleton\n * @return {Numbro} n\n */\nfunction subtract(n, other, numbro) {\n    let value = new BigNumber(n._value);\n    let otherValue = other;\n\n    if (numbro.isNumbro(other)) {\n        otherValue = other._value;\n    }\n\n    otherValue = new BigNumber(otherValue);\n\n    n._value = value.minus(otherValue).toNumber();\n    return n;\n}\n\n/**\n * Multiply N by a number or a numbro.\n *\n * @param {Numbro} n - multiplicand\n * @param {number|Numbro} other - multiplier\n * @param {numbro} numbro - numbro singleton\n * @return {Numbro} n\n */\nfunction multiply(n, other, numbro) {\n    let value = new BigNumber(n._value);\n    let otherValue = other;\n\n    if (numbro.isNumbro(other)) {\n        otherValue = other._value;\n    }\n\n    otherValue = new BigNumber(otherValue);\n\n    n._value = value.times(otherValue).toNumber();\n    return n;\n}\n\n/**\n * Divide N by a number or a numbro.\n *\n * @param {Numbro} n - dividend\n * @param {number|Numbro} other - divisor\n * @param {numbro} numbro - numbro singleton\n * @return {Numbro} n\n */\nfunction divide(n, other, numbro) {\n    let value = new BigNumber(n._value);\n    let otherValue = other;\n\n    if (numbro.isNumbro(other)) {\n        otherValue = other._value;\n    }\n\n    otherValue = new BigNumber(otherValue);\n\n    n._value = value.dividedBy(otherValue).toNumber();\n    return n;\n}\n\n/**\n * Set N to the OTHER (or the value of OTHER when it's a numbro instance).\n *\n * @param {Numbro} n - numbro instance to mutate\n * @param {number|Numbro} other - new value to assign to N\n * @param {numbro} numbro - numbro singleton\n * @return {Numbro} n\n */\nfunction set (n, other, numbro) {\n    let value = other;\n\n    if (numbro.isNumbro(other)) {\n        value = other._value;\n    }\n\n    n._value = value;\n    return n;\n}\n\n/**\n * Return the distance between N and OTHER.\n *\n * @param {Numbro} n\n * @param {number|Numbro} other\n * @param {numbro} numbro - numbro singleton\n * @return {number}\n */\nfunction difference(n, other, numbro) {\n    let clone = numbro(n._value);\n    subtract(clone, other, numbro);\n\n    return Math.abs(clone._value);\n}\n\nmodule.exports = numbro => ({\n    add: (n, other) => add(n, other, numbro),\n    subtract: (n, other) => subtract(n, other, numbro),\n    multiply: (n, other) => multiply(n, other, numbro),\n    divide: (n, other) => divide(n, other, numbro),\n    set: (n, other) => set(n, other, numbro),\n    difference: (n, other) => difference(n, other, numbro),\n    BigNumber: BigNumber\n});\n","/*!\n * Copyright (c) 2017 Benjamin Van Ryseghem<benjamin@vanryseghem.com>\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\n\nconst VERSION = \"2.4.0\";\n\nconst globalState = require(\"./globalState\");\nconst validator = require(\"./validating\");\nconst loader = require(\"./loading\")(numbro);\nconst unformatter = require(\"./unformatting\");\nlet formatter = require(\"./formatting\")(numbro);\nlet manipulate = require(\"./manipulating\")(numbro);\nconst parsing = require(\"./parsing\");\n\nclass Numbro {\n    constructor(number) {\n        this._value = number;\n    }\n\n    clone() { return numbro(this._value); }\n\n    format(format = {}) { return formatter.format(this, format); }\n\n    formatCurrency(format) {\n        if (typeof format === \"string\") {\n            format = parsing.parseFormat(format);\n        }\n        format = formatter.formatOrDefault(format, globalState.currentCurrencyDefaultFormat());\n        format.output = \"currency\";\n        return formatter.format(this, format);\n    }\n\n    formatTime(format = {}) {\n        format.output = \"time\";\n        return formatter.format(this, format);\n    }\n\n    binaryByteUnits() { return formatter.getBinaryByteUnit(this);}\n\n    decimalByteUnits() { return formatter.getDecimalByteUnit(this);}\n\n    byteUnits() { return formatter.getByteUnit(this);}\n\n    difference(other) { return manipulate.difference(this, other); }\n\n    add(other) { return manipulate.add(this, other); }\n\n    subtract(other) { return manipulate.subtract(this, other); }\n\n    multiply(other) { return manipulate.multiply(this, other); }\n\n    divide(other) { return manipulate.divide(this, other); }\n\n    set(input) { return manipulate.set(this, normalizeInput(input)); }\n\n    value() { return this._value; }\n\n    valueOf() { return this._value; }\n}\n\n/**\n * Make its best to convert input into a number.\n *\n * @param {numbro|string|number} input - Input to convert\n * @return {number}\n */\nfunction normalizeInput(input) {\n    let result = input;\n    if (numbro.isNumbro(input)) {\n        result = input._value;\n    } else if (typeof input === \"string\") {\n        result = numbro.unformat(input);\n    } else if (isNaN(input)) {\n        result = NaN;\n    }\n\n    return result;\n}\n\nfunction numbro(input) {\n    return new Numbro(normalizeInput(input));\n}\n\nnumbro.version = VERSION;\n\nnumbro.isNumbro = function(object) {\n    return object instanceof Numbro;\n};\n\n//\n// `numbro` static methods\n//\n\nnumbro.language = globalState.currentLanguage;\nnumbro.registerLanguage = globalState.registerLanguage;\nnumbro.setLanguage = globalState.setLanguage;\nnumbro.languages = globalState.languages;\nnumbro.languageData = globalState.languageData;\nnumbro.zeroFormat = globalState.setZeroFormat;\nnumbro.defaultFormat = globalState.currentDefaults;\nnumbro.setDefaults = globalState.setDefaults;\nnumbro.defaultCurrencyFormat = globalState.currentCurrencyDefaultFormat;\nnumbro.validate = validator.validate;\nnumbro.loadLanguagesInNode = loader.loadLanguagesInNode;\nnumbro.unformat = unformatter.unformat;\nnumbro.BigNumber = manipulate.BigNumber;\n\nmodule.exports = numbro;\n"],"names":["enUS","languageTag","delimiters","thousands","decimal","abbreviations","thousand","million","billion","trillion","spaceSeparated","ordinal","number","b","bytes","binarySuffixes","decimalSuffixes","currency","symbol","position","code","currencyFormat","thousandSeparated","totalLength","spaceSeparatedCurrency","formats","fourDigits","fullWithTwoDecimals","output","mantissa","fullWithTwoDecimalsNoCurrency","fullWithNoDecimals","allSuffixes","key","factor","Math","pow","escapeRegExp","s","replace","computeUnformattedValue","inputString","currencySymbol","zeroFormat","format","isNaN","stripped","newInput","i","length","suffix","RegExp","possibleOrdinalValue","parseFloat","ordinalString","inversedAbbreviations","Object","keys","forEach","abbreviationValues","sort","reverse","numberOfAbbreviations","value","unformatValue","removeFormattingSymbols","unformatting","unformat","globalState","require$$0","currentDelimiters","currentCurrency","currentOrdinal","getZeroFormat","currentAbbreviations","indexOf","segments","split","hours","minutes","seconds","matchesTime","unformatTime","undefined","unformatter","bcp47RegExp","validFormat","type","validValues","base","restriction","message","mandatory","characteristic","prefix","postfix","forceAverage","average","lowPrecision","currencyPosition","restrictions","exponential","optionalMantissa","trimMantissa","roundingFunction","optionalCharacteristic","spaceSeparatedAbbreviation","children","negative","forceSign","prefixSymbol","validLanguage","tag","match","thousandsSize","defaults","ordinalFormat","byteFormat","percentageFormat","timeDefaults","validateInput","input","validateSpec","toValidate","spec","skipMandatoryCheck","results","map","console","error","data","JSON","stringify","push","reduce","acc","current","validateFormat","validating","validate","validInput","isFormatValid","validateLanguage","language","parsing","parseFormat","string","result","parseOutput","slice","parsePostfix","parsePrefix","parseTotalLength","parseCharacteristic","parseOptionalCharacteristic","parseAverage","parseForceAverage","parseMantissa","parseOptionalMantissa","parseTrimMantissa","parseThousandSeparated","parseSpaceSeparated","parseNegative","parseForceSign","require$$1","require$$2","currentLanguageTag","state","languages","globalDefaults","chooseLanguage","currentLanguageData","assign","currentLanguage","currentBytes","currentDefaults","currentOrdinalDefaultFormat","currentByteDefaultFormat","currentPercentageDefaultFormat","currentCurrencyDefaultFormat","currentTimeDefaultFormat","timeFormat","setDefaults","setZeroFormat","hasZeroFormat","languageData","Error","registerLanguage","useLanguage","setLanguage","fallbackTag","matchingLanguageTag","find","each","loadLanguagesInNode","tags","numbro","require","e","globalObject","BigNumber","isNumeric","mathceil","ceil","mathfloor","floor","bignumberError","tooManyDigits","BASE","LOG_BASE","MAX_SAFE_INTEGER","POWS_TEN","SQRT_BASE","MAX","bitFloor","n","coeffToString","a","z","j","r","charCodeAt","compare","x","y","xc","c","yc","k","l","intCheck","min","max","name","String","isOdd","toExponential","str","charAt","toFixedPoint","len","zs","clone","configObject","div","convertBase","parseNumeric","pow2_53","random53bitInt","basePrefix","dotAfter","dotBefore","isInfinityOrNaN","whitespaceOrPlus","P","prototype","constructor","toString","valueOf","ONE","DECIMAL_PLACES","ROUNDING_MODE","TO_EXP_NEG","TO_EXP_POS","MIN_EXP","MAX_EXP","CRYPTO","MODULO_MODE","POW_PRECISION","FORMAT","groupSize","secondaryGroupSize","groupSeparator","decimalSeparator","fractionGroupSize","fractionGroupSeparator","ALPHABET","alphabetHasNormalDecimalDigits","v","alphabet","caseChanged","isNum","this","_isBigNumber","test","search","substring","round","DEBUG","toUpperCase","toLowerCase","rm","id","c0","ne","maxOrMin","args","normalise","pop","sd","d","ni","rd","pows10","out","ROUND_UP","ROUND_DOWN","ROUND_CEIL","ROUND_FLOOR","ROUND_HALF_UP","ROUND_HALF_DOWN","ROUND_HALF_EVEN","ROUND_HALF_CEIL","ROUND_HALF_FLOOR","EUCLID","config","set","obj","p","hasOwnProperty","crypto","getRandomValues","randomBytes","EXPONENTIAL_AT","RANGE","isBigNumber","call","maximum","arguments","minimum","random","dp","rand","Uint32Array","copy","splice","sum","plus","toBaseOut","baseIn","baseOut","arrL","arr","sign","callerIsToString","concat","multiply","m","temp","xlo","xhi","carry","klo","khi","aL","bL","cmp","subtract","more","prod","prodL","q","qc","rem","remL","rem0","xi","xL","yc0","yL","yz","NaN","p1","p2","absoluteValue","abs","comparedTo","decimalPlaces","dividedBy","dividedToIntegerBy","idiv","exponentiatedBy","half","isModExp","nIsBig","nIsNeg","nIsOdd","isInteger","mod","times","integerValue","isEqualTo","eq","isFinite","isGreaterThan","gt","isGreaterThanOrEqualTo","gte","isLessThan","lt","isLessThanOrEqualTo","lte","isNegative","isPositive","isZero","minus","t","xLTy","xe","ye","modulo","multipliedBy","xcL","ycL","ylo","yhi","zc","sqrtBase","negated","precision","shiftedBy","squareRoot","sqrt","rep","toFixed","toFormat","g1","g2","intPart","fractionPart","isNeg","intDigits","substr","toFraction","md","d0","d1","d2","exp","n0","n1","toNumber","toPrecision","toJSON","module","exports","self","window","require$$3","powers","defaultOptions","general","scale","suffixes","marker","binary","instance","providedFormat","clonedFormat","options","space","formatNumber","_value","formatCurrency","formatOrDefault","formatPercentage","localBinarySuffixes","localDecimalSuffixes","baseInfo","getFormatByteUnits","formatByte","formatTime","ordinalFn","formatOrdinal","formatNumbro","insertPrefix","insertPostfix","power","zeroes","toFixedLarge","characteristicPrecision","mantissaPrecision","abbreviation","characteristicLength","computeAverage","numberString","computeExponential","trim","currentCharacteristic","currentMantissa","hasTrailingZeroes","index","setMantissaPrecision","hasNegativeSign","missingZeros","setCharacteristicPrecision","thousandSeparator","indexesToInsertThousandDelimiters","counter","unshift","indexesOfGroupSpaces","replaceDelimiters","insertAbbreviation","insertSign","defaultFormat","other","otherValue","isNumbro","validator","loader","formatter","getByteUnit","getBinaryByteUnit","getDecimalByteUnit","require$$4","manipulate","add","divide","difference","require$$5","require$$6","Numbro","binaryByteUnits","decimalByteUnits","byteUnits","normalizeInput","version","object","defaultCurrencyFormat"],"mappings":";;;;;;;;;;;;;;;;;;;;;IAsBA,YAAAA,EAAiB,CACbC,YAAa,QACbC,WAAY,CACRC,UAAW,IACXC,QAAS,KAEbC,cAAe,CACXC,SAAU,IACVC,QAAS,IACTC,QAAS,IACTC,SAAU,KAEdC,gBAAgB,EAChBC,QAAS,SAASC,GACd,IAAIC,EAAID,EAAS,GACjB,OAAkC,MAAvBA,EAAS,IAAM,IAAa,KAAc,IAANC,EAAW,KAAc,IAANA,EAAW,KAAc,IAANA,EAAW,KAAO,IAC1G,EACDC,MAAO,CACHC,eAAgB,CAAC,IAAK,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,OACvEC,gBAAiB,CAAC,IAAK,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,OAErEC,SAAU,CACNC,OAAQ,IACRC,SAAU,SACVC,KAAM,OAEVC,eAAgB,CACZC,mBAAmB,EACnBC,YAAa,EACbb,gBAAgB,EAChBc,wBAAwB,GAE5BC,QAAS,CACLC,WAAY,CACRH,YAAa,EACbb,gBAAgB,GAEpBiB,oBAAqB,CACjBC,OAAQ,WACRN,mBAAmB,EACnBO,SAAU,GAEdC,8BAA+B,CAC3BR,mBAAmB,EACnBO,SAAU,GAEdE,mBAAoB,CAChBH,OAAQ,WACRN,mBAAmB,EACnBO,SAAU;;;;;;;;;;;;;;;;;;;;;mCCjDtB,MAAMG,EAAc,CAChB,CAACC,IAAK,MAAOC,OAAQC,KAAKC,IAAI,KAAM,IACpC,CAACH,IAAK,KAAMC,OAAQC,KAAKC,IAAI,IAAM,IACnC,CAACH,IAAK,MAAOC,OAAQC,KAAKC,IAAI,KAAM,IACpC,CAACH,IAAK,KAAMC,OAAQC,KAAKC,IAAI,IAAM,IACnC,CAACH,IAAK,MAAOC,OAAQC,KAAKC,IAAI,KAAM,IACpC,CAACH,IAAK,KAAMC,OAAQC,KAAKC,IAAI,IAAM,IACnC,CAACH,IAAK,MAAOC,OAAQC,KAAKC,IAAI,KAAM,IACpC,CAACH,IAAK,KAAMC,OAAQC,KAAKC,IAAI,IAAM,IACnC,CAACH,IAAK,MAAOC,OAAQC,KAAKC,IAAI,KAAM,IACpC,CAACH,IAAK,KAAMC,OAAQC,KAAKC,IAAI,IAAM,IACnC,CAACH,IAAK,MAAOC,OAAQC,KAAKC,IAAI,KAAM,IACpC,CAACH,IAAK,KAAMC,OAAQC,KAAKC,IAAI,IAAM,IACnC,CAACH,IAAK,MAAOC,OAAQC,KAAKC,IAAI,KAAM,IACpC,CAACH,IAAK,KAAMC,OAAQC,KAAKC,IAAI,IAAM,IACnC,CAACH,IAAK,MAAOC,OAAQC,KAAKC,IAAI,KAAM,IACpC,CAACH,IAAK,KAAMC,OAAQC,KAAKC,IAAI,IAAM,IACnC,CAACH,IAAK,IAAKC,OAAQ,IASvB,SAASG,EAAaC,GAClB,OAAOA,EAAEC,QAAQ,wBAAyB,OAC7C,CAcD,SAASC,EAAwBC,EAAavC,EAAYwC,EAAgB/B,EAASgC,EAAYtC,EAAeuC,GAC1G,IAAKC,OAAOJ,GACR,OAAQA,EAGZ,IAAIK,EAAW,GAGXC,EAAWN,EAAYF,QAAQ,2BAA4B,UAE/D,GAAIQ,IAAaN,EACb,OAAQ,EAAID,EAAwBO,EAAU7C,EAAYwC,EAAgB/B,EAASgC,EAAYtC,GAKnG,IAAK,IAAI2C,EAAI,EAAGA,EAAIhB,EAAYiB,OAAQD,IAAK,CACzC,IAAIE,EAASlB,EAAYgB,GAGzB,GAFAF,EAAWL,EAAYF,QAAQY,OAAO,YAAYD,EAAOjB,SAAU,MAE/Da,IAAaL,EACb,OAAOD,EAAwBM,EAAU5C,EAAYwC,EAAgB/B,EAASgC,EAAYtC,GAAyB6C,EAAOhB,MAEjI,CAMD,GAFAY,EAAWL,EAAYF,QAAQ,IAAK,IAEhCO,IAAaL,EACb,OAAOD,EAAwBM,EAAU5C,EAAYwC,EAAgB/B,EAASgC,EAAYtC,GAAyB,IAKvH,IAAI+C,EAAuBC,WAAWZ,GAEtC,GAAII,MAAMO,GACN,OAGJ,IAAIE,EAAgB3C,EAAQyC,GAC5B,GAAIE,GAAmC,MAAlBA,IACjBR,EAAWL,EAAYF,QAAQ,IAAIY,OAAO,GAAGd,EAAaiB,OAAoB,IAE1ER,IAAaL,GACb,OAAOD,EAAwBM,EAAU5C,EAAYwC,EAAgB/B,EAASgC,EAAYtC,GAMlG,IAAIkD,EAAwB,CAAA,EAC5BC,OAAOC,KAAKpD,GAAeqD,SAASzB,IAChCsB,EAAsBlD,EAAc4B,IAAQA,CAAG,IAGnD,IAAI0B,EAAqBH,OAAOC,KAAKF,GAAuBK,OAAOC,UAC/DC,EAAwBH,EAAmBV,OAE/C,IAAK,IAAID,EAAI,EAAGA,EAAIc,EAAuBd,IAAK,CAC5C,IAAIe,EAAQJ,EAAmBX,GAC3Bf,EAAMsB,EAAsBQ,GAGhC,GADAjB,EAAWL,EAAYF,QAAQwB,EAAO,IAClCjB,IAAaL,EAAa,CAC1B,IAAIP,EACJ,OAAQD,GACJ,IAAK,WACDC,EAASC,KAAKC,IAAI,GAAI,GACtB,MACJ,IAAK,UACDF,EAASC,KAAKC,IAAI,GAAI,GACtB,MACJ,IAAK,UACDF,EAASC,KAAKC,IAAI,GAAI,GACtB,MACJ,IAAK,WACDF,EAASC,KAAKC,IAAI,GAAI,IAG9B,OAAOI,EAAwBM,EAAU5C,EAAYwC,EAAgB/B,EAASgC,EAAYtC,GAAyB6B,CACtH,CACJ,CAGJ,CAsCD,SAAS8B,EAAcvB,EAAavC,EAAYwC,EAAiB,GAAI/B,EAASgC,EAAYtC,EAAeuC,GACrG,GAAoB,KAAhBH,EACA,OAKJ,GAAIA,IAAgBE,EAChB,OAAO,EAGX,IAAIoB,EAvCR,SAAiCtB,EAAavC,EAAYwC,GAGtD,IAAII,EAAWL,EAAYF,QAAQG,EAAgB,IAUnD,OANAI,EAAWA,EAASP,QAAQ,IAAIY,OAAO,UAAUd,EAAanC,EAAWC,oBAAqB,KAAM,QAIpG2C,EAAWA,EAASP,QAAQrC,EAAWE,QAAS,KAEzC0C,CACV,CAyBemB,CAAwBxB,EAAavC,EAAYwC,GAC7D,OAAOF,EAAwBuB,EAAO7D,EAAYwC,EAAgB/B,EAASgC,EAAYtC,EAC1F,QAkFD6D,EAAiB,CACbC,SAhCJ,SAAkB1B,EAAaG,GAE3B,MAAMwB,EAAcC,IAEpB,IAMIN,EANA7D,EAAakE,EAAYE,oBACzB5B,EAAiB0B,EAAYG,kBAAkBrD,OAC/CP,EAAUyD,EAAYI,iBACtB7B,EAAayB,EAAYK,gBACzBpE,EAAgB+D,EAAYM,uBAIhC,GAA2B,iBAAhBjC,EAIHsB,EA1DZ,SAAqBtB,EAAavC,GAG9B,IAFiBuC,EAAYkC,QAAQ,MAAiC,MAAzBzE,EAAWC,UAGpD,OAAO,EAGX,IAAIyE,EAAWnC,EAAYoC,MAAM,KACjC,GAAwB,IAApBD,EAAS3B,OACT,OAAO,EAGX,IAAI6B,GAASF,EAAS,GAClBG,GAAWH,EAAS,GACpBI,GAAWJ,EAAS,GAExB,OAAQ/B,MAAMiC,KAAWjC,MAAMkC,KAAalC,MAAMmC,EACrD,CAsCWC,CAAYxC,EAAavC,GA9BrC,SAAsBuC,GAClB,IAAImC,EAAWnC,EAAYoC,MAAM,KAE7BC,GAASF,EAAS,GAClBG,GAAWH,EAAS,GAGxB,OAFeA,EAAS,GAEP,GAAKG,EAAU,KAAOD,CAC1C,CAuBmBI,CAAazC,GAEbuB,EAAcvB,EAAavC,EAAYwC,EAAgB/B,EAASgC,EAAYtC,OAErF,IAA2B,iBAAhBoC,EAGd,OAFAsB,EAAQtB,CAGX,CAED,QAAc0C,IAAVpB,EAIJ,OAAOA,CACV;;;;;;;;;;;;;;;;;;;;;mCCnQD,IAAIqB,EAAcf,IAGlB,MAAMgB,EAAc,qDAoEdC,EAAc,CAChB1D,OAAQ,CACJ2D,KAAM,SACNC,YArEkB,CACtB,WACA,UACA,OACA,OACA,UACA,WAiEAC,KAAM,CACFF,KAAM,SACNC,YAbgB,CACpB,UACA,SACA,WAWIE,YAAa,CAAC9E,EAAQgC,IAA6B,SAAlBA,EAAOhB,OACxC+D,QAAS,yDACTC,UAAYhD,GAA6B,SAAlBA,EAAOhB,QAElCiE,eAAgB,CACZN,KAAM,SACNG,YAAc9E,GAAWA,GAAU,EACnC+E,QAAS,0BAEbG,OAAQ,SACRC,QAAS,SACTC,aAAc,CACVT,KAAM,SACNC,YA9EwB,CAC5B,WACA,UACA,UACA,aA4EAS,QAAS,UACTC,aAAc,CACVX,KAAM,UACNG,YAAa,CAAC9E,EAAQgC,KAA8B,IAAnBA,EAAOqD,QACxCN,QAAS,yEAEbQ,iBAAkB,CACdZ,KAAM,SACNC,YAjFsB,CAC1B,SACA,QACA,YAgFA9C,eAAgB,SAChBnB,YAAa,CACTgE,KAAM,SACNa,aAAc,CACV,CACIV,YAAc9E,GAAWA,GAAU,EACnC+E,QAAS,0BAEb,CACID,YAAa,CAAC9E,EAAQgC,KAAYA,EAAOyD,YACzCV,QAAS,sDAIrB9D,SAAU,CACN0D,KAAM,SACNG,YAAc9E,GAAWA,GAAU,EACnC+E,QAAS,0BAEbW,iBAAkB,UAClBC,aAAc,UACdC,iBAAkB,WAClBC,uBAAwB,UACxBnF,kBAAmB,UACnBZ,eAAgB,UAChBc,uBAAwB,UACxBkF,2BAA4B,UAC5BrG,cA5EuB,CACvBkF,KAAM,SACNoB,SAAU,CACNrG,SAAU,SACVC,QAAS,SACTC,QAAS,SACTC,SAAU,WAuEdmG,SAAU,CACNrB,KAAM,SACNC,YA3GoB,CACxB,OACA,gBA2GAqB,UAAW,UACXR,YAAa,CACTd,KAAM,WAEVuB,aAAc,CACVvB,KAAM,UACNG,YAAa,CAAC9E,EAAQgC,IAA6B,YAAlBA,EAAOhB,OACxC+D,QAAS,qEAIXoB,EAAgB,CAClB9G,YAAa,CACTsF,KAAM,SACNK,WAAW,EACXF,YAAcsB,GACHA,EAAIC,MAAM5B,GAErBM,QAAS,iGAEbzF,WAAY,CACRqF,KAAM,SACNoB,SAAU,CACNxG,UAAW,SACXC,QAAS,SACT8G,cAAe,UAEnBtB,WAAW,GAEfvF,cArIgC,CAChCkF,KAAM,SACNoB,SAAU,CACNrG,SAAU,CACNiF,KAAM,SACNK,WAAW,GAEfrF,QAAS,CACLgF,KAAM,SACNK,WAAW,GAEfpF,QAAS,CACL+E,KAAM,SACNK,WAAW,GAEfnF,SAAU,CACN8E,KAAM,SACNK,WAAW,IAGnBA,WAAW,GAkHXlF,eAAgB,UAChBc,uBAAwB,UACxBb,QAAS,CACL4E,KAAM,WACNK,WAAW,GAEf9E,MAAO,CACHyE,KAAM,SACNoB,SAAU,CACN5F,eAAgB,SAChBC,gBAAiB,WAGzBC,SAAU,CACNsE,KAAM,SACNoB,SAAU,CACNzF,OAAQ,SACRC,SAAU,SACVC,KAAM,UAEVwE,WAAW,GAEfuB,SAAU,SACVC,cAAe,SACfC,WAAY,SACZC,iBAAkB,SAClBjG,eAAgB,SAChBkG,aAAc,SACd9F,QAAS,CACL8D,KAAM,SACNoB,SAAU,CACNjF,WAAY,CACR6D,KAAM,SACNK,WAAW,GAEfjE,oBAAqB,CACjB4D,KAAM,SACNK,WAAW,GAEf9D,8BAA+B,CAC3ByD,KAAM,SACNK,WAAW,GAEf7D,mBAAoB,CAChBwD,KAAM,SACNK,WAAW,MA2B3B,SAAS4B,EAAcC,GAGnB,YAAiBtC,IAFLC,EAAYjB,SAASsD,EAGpC,CAWD,SAASC,EAAaC,EAAYC,EAAM9B,EAAQ+B,GAAqB,GACjE,IAAIC,EAAUtE,OAAOC,KAAKkE,GAAYI,KAAK9F,IACvC,IAAK2F,EAAK3F,GAEN,OADA+F,QAAQC,MAAM,GAAGnC,kBAAuB7D,MACjC,EAGX,IAAI8B,EAAQ4D,EAAW1F,GACnBiG,EAAON,EAAK3F,GAMhB,GAJoB,iBAATiG,IACPA,EAAO,CAAC3C,KAAM2C,IAGA,WAAdA,EAAK3C,KAAmB,CAGxB,IAFYmC,EAAa3D,EAAOuB,EAAa,aAAarD,MAAQ,GAG9D,OAAO,CAEd,MAAM,UAAW8B,IAAUmE,EAAK3C,KAE7B,OADAyC,QAAQC,MAAM,GAAGnC,KAAU7D,uBAAyBiG,EAAK3C,2BAA2BxB,gBAC7E,EAGX,GAAImE,EAAK9B,cAAgB8B,EAAK9B,aAAanD,OAAQ,CAC/C,IAAIA,EAASiF,EAAK9B,aAAanD,OAC/B,IAAK,IAAID,EAAI,EAAGA,EAAIC,EAAQD,IAAK,CAC7B,IAAI0C,YAACA,EAAWC,QAAEA,GAAWuC,EAAK9B,aAAapD,GAC/C,IAAK0C,EAAY3B,EAAO4D,GAEpB,OADAK,QAAQC,MAAM,GAAGnC,KAAU7D,oBAAsB0D,MAC1C,CAEd,CACJ,CAED,GAAIuC,EAAKxC,cAAgBwC,EAAKxC,YAAY3B,EAAO4D,GAE7C,OADAK,QAAQC,MAAM,GAAGnC,KAAU7D,oBAAsBiG,EAAKvC,YAC/C,EAGX,GAAIuC,EAAK1C,cAAoD,IAArC0C,EAAK1C,YAAYb,QAAQZ,GAE7C,OADAiE,QAAQC,MAAM,GAAGnC,KAAU7D,kCAAoCkG,KAAKC,UAAUF,EAAK1C,kBAAkBzB,gBAC9F,EAGX,GAAImE,EAAKvB,SAAU,CAGf,IAFYe,EAAa3D,EAAOmE,EAAKvB,SAAU,aAAa1E,MAGxD,OAAO,CAEd,CAED,OAAO,CAAI,IA0Bf,OAvBK4F,GACDC,EAAQO,QAAQ7E,OAAOC,KAAKmE,GAAMG,KAAK9F,IACnC,IAAIiG,EAAON,EAAK3F,GAKhB,GAJoB,iBAATiG,IACPA,EAAO,CAAC3C,KAAM2C,IAGdA,EAAKtC,UAAW,CAChB,IAAIA,EAAYsC,EAAKtC,UAKrB,GAJyB,mBAAdA,IACPA,EAAYA,EAAU+B,IAGtB/B,QAAiCT,IAApBwC,EAAW1F,GAExB,OADA+F,QAAQC,MAAM,GAAGnC,4BAAiC7D,OAC3C,CAEd,CAED,OAAO,CAAI,KAIZ6F,EAAQQ,QAAO,CAACC,EAAKC,IACjBD,GAAOC,IACf,EACN,CAQD,SAASC,EAAe7F,GACpB,OAAO8E,EAAa9E,EAAQ0C,EAAa,oBAC5C,QAYDoD,EAAiB,CACbC,SAtIJ,SAAkBlB,EAAO7E,GACrB,IAAIgG,EAAapB,EAAcC,GAC3BoB,EAAgBJ,EAAe7F,GAEnC,OAAOgG,GAAcC,CACxB,EAkIGJ,iBACAjB,gBACAsB,iBARJ,SAA0BC,GACtB,OAAOrB,EAAaqB,EAAUhC,EAAe,sBAChD;;;;;;;;;;;;;;;;;;;;;IC/DD,QAAAiC,EAAiB,CACbC,YAzBJ,SAAqBC,EAAQC,EAAS,IAClC,MAAsB,iBAAXD,EACAA,GAtOf,SAAqBA,EAAQC,GACzB,IAA6B,IAAzBD,EAAOvE,QAAQ,KAAnB,CAKA,IAA6B,IAAzBuE,EAAOvE,QAAQ,KAKnB,OAA8B,IAA1BuE,EAAOvE,QAAQ,OACfwE,EAAOvH,OAAS,YAChBuH,EAAO1D,KAAO,aAIW,IAAzByD,EAAOvE,QAAQ,MACfwE,EAAOvH,OAAS,YAChBuH,EAAO1D,KAAO,YAKW,IAAzByD,EAAOvE,QAAQ,MACfwE,EAAOvH,OAAS,YAChBuH,EAAO1D,KAAO,kBAKW,IAAzByD,EAAOvE,QAAQ,MAKU,IAAzBuE,EAAOvE,QAAQ,OACfwE,EAAOvH,OAAS,WALhBuH,EAAOvH,OAAS,QAzBhBuH,EAAOvH,OAAS,SAHnB,MAFGuH,EAAOvH,OAAS,UAqCxB,CAoMIwH,CADAF,EA3PJ,SAAsBA,EAAQC,GAC1B,IAAIlC,EAAQiC,EAAOjC,MAAM,cACzB,OAAIA,GACAkC,EAAOpD,QAAUkB,EAAM,GAEhBiC,EAAOG,MAAM,GAAIpC,EAAM,GAAGhE,SAG9BiG,CACX,CAkPaI,CADTJ,EA3QJ,SAAqBA,EAAQC,GACzB,IAAIlC,EAAQiC,EAAOjC,MAAM,cACzB,OAAIA,GACAkC,EAAOrD,OAASmB,EAAM,GACfiC,EAAOG,MAAMpC,EAAM,GAAGhE,SAG1BiG,CACX,CAmQaK,CAAYL,EAAQC,GACCA,GACVA,GA5JxB,SAA0BD,EAAQC,GAC9B,IAAIlC,EAAQiC,EAAOjC,MAAM,gBAErBA,IACAkC,EAAO5H,aAAe0F,EAAM,GAEpC,CAuJIuC,CAAiBN,EAAQC,GA9I7B,SAA6BD,EAAQC,GACjC,IACIlC,EADiBiC,EAAOrE,MAAM,KAAK,GACZoC,MAAM,MAC7BA,IACAkC,EAAOtD,eAAiBoB,EAAM,GAAGhE,OAEzC,CAyIIwG,CAAoBP,EAAQC,GAnDhC,SAAqCD,EAAQC,GACzC,IAA6B,IAAzBD,EAAOvE,QAAQ,KAAa,CAC5B,IAAIkB,EAAiBqD,EAAOrE,MAAM,KAAK,GACvCsE,EAAO1C,wBAA0D,IAAjCZ,EAAelB,QAAQ,IAC1D,CACL,CA+CI+E,CAA4BR,EAAQC,GAnGxC,SAAsBD,EAAQC,IACG,IAAzBD,EAAOvE,QAAQ,OACfwE,EAAOlD,SAAU,EAEzB,CAgGI0D,CAAaT,EAAQC,GAvFzB,SAA2BD,EAAQC,IACF,IAAzBD,EAAOvE,QAAQ,KACfwE,EAAOnD,aAAe,YACU,IAAzBkD,EAAOvE,QAAQ,KACtBwE,EAAOnD,aAAe,WACU,IAAzBkD,EAAOvE,QAAQ,KACtBwE,EAAOnD,aAAe,WACU,IAAzBkD,EAAOvE,QAAQ,OACtBwE,EAAOnD,aAAe,WAE9B,CA8EI4D,CAAkBV,EAAQC,GAnI9B,SAAuBD,EAAQC,GAC3B,IAAItH,EAAWqH,EAAOrE,MAAM,KAAK,GACjC,GAAIhD,EAAU,CACV,IAAIoF,EAAQpF,EAASoF,MAAM,MACvBA,IACAkC,EAAOtH,SAAWoF,EAAM,GAAGhE,OAElC,CACL,CA4HI4G,CAAcX,EAAQC,GAtE1B,SAA+BD,EAAQC,GAC/BD,EAAOjC,MAAM,SACbkC,EAAO7C,kBAAmB,EACnB4C,EAAOjC,MAAM,QACpBkC,EAAO7C,kBAAmB,EAElC,CAiEIwD,CAAsBZ,EAAQC,GArHlC,SAA2BD,EAAQC,GAC/B,MAAMtH,EAAWqH,EAAOrE,MAAM,KAAK,GAC/BhD,IACAsH,EAAO5C,cAA0C,IAA3B1E,EAAS8C,QAAQ,KAE/C,CAiHIoF,CAAkBb,EAAQC,GAnM9B,SAAgCD,EAAQC,IACP,IAAzBD,EAAOvE,QAAQ,OACfwE,EAAO7H,mBAAoB,EAEnC,CAgMI0I,CAAuBd,EAAQC,GAvLnC,SAA6BD,EAAQC,IACJ,IAAzBD,EAAOvE,QAAQ,OACfwE,EAAOzI,gBAAiB,EACxByI,EAAO3H,wBAAyB,GAE5B2H,EAAOlD,SAAWkD,EAAOnD,gBACzBmD,EAAOzC,4BAA6B,GAGhD,CA+KIuD,CAAoBf,EAAQC,GA7ChC,SAAuBD,EAAQC,GACvBD,EAAOjC,MAAM,oBACbkC,EAAOvC,SAAW,eAElBsC,EAAOjC,MAAM,WACbkC,EAAOvC,SAAW,OAE1B,CAuCIsD,CAAchB,EAAQC,GA/B1B,SAAwBD,EAAQC,GACxBD,EAAOjC,MAAM,SACbkC,EAAOtC,WAAY,EAE3B,CA4BIsD,CAAejB,EAAQC,GAEhBA,EACX;;;;;;;;;;;;;;;;;;;;;mCCnSA,MAAMnJ,EAAOqE,EACPqE,EAAa0B,IACbpB,EAAUqB,EAEhB,IAEIC,EAFAC,EAAQ,CAAA,EAGRC,EAAY,CAAA,EAEZ7H,EAAa,KAEb8H,EAAiB,CAAA,EAErB,SAASC,EAAe1D,GAAOsD,EAAqBtD,CAAM,CAE1D,SAAS2D,IAAwB,OAAOH,EAAUF,EAAsB,QAOxEC,EAAMC,UAAY,IAAMhH,OAAOoH,OAAO,CAAA,EAAIJ,GAW1CD,EAAMM,gBAAkB,IAAMP,EAO9BC,EAAMO,aAAe,IAAMH,IAAsB7J,OAAS,CAAA,EAO1DyJ,EAAMhG,gBAAkB,IAAMoG,IAAsB1J,SAOpDsJ,EAAM7F,qBAAuB,IAAMiG,IAAsBtK,cAOzDkK,EAAMjG,kBAAoB,IAAMqG,IAAsBzK,WAOtDqK,EAAM/F,eAAiB,IAAMmG,IAAsBhK,QAYnD4J,EAAMQ,gBAAkB,IAAMvH,OAAOoH,OAAO,CAAE,EAAED,IAAsBxD,SAAUsD,GAQhFF,EAAMS,4BAA8B,IAAMxH,OAAOoH,OAAO,CAAA,EAAIL,EAAMQ,kBAAmBJ,IAAsBvD,eAQ3GmD,EAAMU,yBAA2B,IAAMzH,OAAOoH,OAAO,CAAA,EAAIL,EAAMQ,kBAAmBJ,IAAsBtD,YAQxGkD,EAAMW,+BAAiC,IAAM1H,OAAOoH,OAAO,CAAA,EAAIL,EAAMQ,kBAAmBJ,IAAsBrD,kBAQ9GiD,EAAMY,6BAA+B,IAAM3H,OAAOoH,OAAO,CAAA,EAAIL,EAAMQ,kBAAmBJ,IAAsBtJ,gBAQ5GkJ,EAAMa,yBAA2B,IAAM5H,OAAOoH,OAAO,CAAA,EAAIL,EAAMQ,kBAAmBJ,IAAsBU,YAOxGd,EAAMe,YAAe1I,IACjBA,EAASoG,EAAQC,YAAYrG,GACzB8F,EAAWD,eAAe7F,KAC1B6H,EAAiB7H,EACpB,EAYL2H,EAAM9F,cAAgB,IAAM9B,EAO5B4H,EAAMgB,cAAiBrC,GAAWvG,EAAgC,iBAAZ,EAAuBuG,EAAS,KAOtFqB,EAAMiB,cAAgB,IAAqB,OAAf7I,EAe5B4H,EAAMkB,aAAgBzE,IAClB,GAAIA,EAAK,CACL,GAAIwD,EAAUxD,GACV,OAAOwD,EAAUxD,GAErB,MAAM,IAAI0E,MAAM,gBAAgB1E,KACnC,CAED,OAAO2D,GAAqB,EAYhCJ,EAAMoB,iBAAmB,CAACzD,EAAM0D,GAAc,KAC1C,IAAKlD,EAAWI,iBAAiBZ,GAC7B,MAAM,IAAIwD,MAAM,yBAGpBlB,EAAUtC,EAAKjI,aAAeiI,EAE1B0D,GACAlB,EAAexC,EAAKjI,YACvB,EAaLsK,EAAMsB,YAAc,CAAC7E,EAAK8E,EAAc9L,EAAKC,eACzC,IAAKuK,EAAUxD,GAAM,CACjB,IAAI9D,EAAS8D,EAAInC,MAAM,KAAK,GAExBkH,EAAsBvI,OAAOC,KAAK+G,GAAWwB,MAAKC,GAC3CA,EAAKpH,MAAM,KAAK,KAAO3B,IAGlC,OAAKsH,EAAUuB,QAKfrB,EAAeqB,QAJXrB,EAAeoB,EAMtB,CAEDpB,EAAe1D,EAAI,EAGvBuD,EAAMoB,iBAAiB3L,GACvBsK,EAAqBtK,EAAKC,YAE1BmE,EAAiBmG;;;;;;;;;;;;;;;;;;;;;;ACtOjB,SAAS2B,EAAoBC,EAAMC,GAC/BD,EAAKzI,SAASsD,IACV,IAAIkB,EACJ,IACIA,+NAAOmE,CAAQ,gBAAgBrF,IAClC,CAAC,MAAOsF,GACLtE,QAAQC,MAAM,mBAAmBjB,uCACpC,CAEGkB,GACAkE,EAAOT,iBAAiBzD,EAC3B,GAET,kCC1CC,SAAWqE,GAmDV,IAAIC,EACFC,EAAY,6CACZC,EAAWvK,KAAKwK,KAChBC,EAAYzK,KAAK0K,MAEjBC,EAAiB,qBACjBC,EAAgBD,EAAiB,yDAEjCE,EAAO,KACPC,EAAW,GACXC,EAAmB,iBAEnBC,EAAW,CAAC,EAAG,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,KAAM,KAAM,KAAM,MAC7EC,EAAY,IAKZC,EAAM,IAqpFR,SAASC,EAASC,GAChB,IAAIvK,EAAQ,EAAJuK,EACR,OAAOA,EAAI,GAAKA,IAAMvK,EAAIA,EAAIA,EAAI,CACnC,CAID,SAASwK,EAAcC,GAMrB,IALA,IAAInL,EAAGoL,EACL1K,EAAI,EACJ2K,EAAIF,EAAExK,OACN2K,EAAIH,EAAE,GAAK,GAENzK,EAAI2K,GAAI,CAGb,IAFArL,EAAImL,EAAEzK,KAAO,GACb0K,EAAIT,EAAW3K,EAAEW,OACVyK,IAAKpL,EAAI,IAAMA,GACtBsL,GAAKtL,CACN,CAGD,IAAKqL,EAAIC,EAAE3K,OAA8B,KAAtB2K,EAAEC,aAAaF,KAElC,OAAOC,EAAEvE,MAAM,EAAGsE,EAAI,GAAK,EAC5B,CAID,SAASG,EAAQC,EAAGC,GAClB,IAAIP,EAAG5M,EACLoN,EAAKF,EAAEG,EACPC,EAAKH,EAAEE,EACPlL,EAAI+K,EAAEzL,EACNqL,EAAIK,EAAE1L,EACN8L,EAAIL,EAAEzB,EACN+B,EAAIL,EAAE1B,EAGR,IAAKtJ,IAAM2K,EAAG,OAAO,KAMrB,GAJAF,EAAIQ,IAAOA,EAAG,GACdpN,EAAIsN,IAAOA,EAAG,GAGVV,GAAK5M,EAAG,OAAO4M,EAAI5M,EAAI,GAAK8M,EAAI3K,EAGpC,GAAIA,GAAK2K,EAAG,OAAO3K,EAMnB,GAJAyK,EAAIzK,EAAI,EACRnC,EAAIuN,GAAKC,GAGJJ,IAAOE,EAAI,OAAOtN,EAAI,GAAKoN,EAAKR,EAAI,GAAK,EAG9C,IAAK5M,EAAG,OAAOuN,EAAIC,EAAIZ,EAAI,GAAK,EAKhC,IAHAE,GAAKS,EAAIH,EAAGhL,SAAWoL,EAAIF,EAAGlL,QAAUmL,EAAIC,EAGvCrL,EAAI,EAAGA,EAAI2K,EAAG3K,IAAK,GAAIiL,EAAGjL,IAAMmL,EAAGnL,GAAI,OAAOiL,EAAGjL,GAAKmL,EAAGnL,GAAKyK,EAAI,GAAK,EAG5E,OAAOW,GAAKC,EAAI,EAAID,EAAIC,EAAIZ,EAAI,GAAK,CACtC,CAMD,SAASa,EAASf,EAAGgB,EAAKC,EAAKC,GAC7B,GAAIlB,EAAIgB,GAAOhB,EAAIiB,GAAOjB,IAAMX,EAAUW,GACxC,MAAM7B,MACJoB,GAAkB2B,GAAQ,aAA2B,iBAALlB,EAC7CA,EAAIgB,GAAOhB,EAAIiB,EAAM,kBAAoB,oBACzC,6BAA+BE,OAAOnB,GAE9C,CAID,SAASoB,EAAMpB,GACb,IAAIa,EAAIb,EAAEW,EAAEjL,OAAS,EACrB,OAAOqK,EAASC,EAAEjB,EAAIW,IAAamB,GAAKb,EAAEW,EAAEE,GAAK,GAAK,CACvD,CAGD,SAASQ,EAAcC,EAAKvC,GAC1B,OAAQuC,EAAI5L,OAAS,EAAI4L,EAAIC,OAAO,GAAK,IAAMD,EAAIxF,MAAM,GAAKwF,IAC5DvC,EAAI,EAAI,IAAM,MAAQA,CACzB,CAGD,SAASyC,EAAaF,EAAKvC,EAAGoB,GAC5B,IAAIsB,EAAKC,EAGT,GAAI3C,EAAI,EAAG,CAGT,IAAK2C,EAAKvB,EAAI,MAAOpB,EAAG2C,GAAMvB,GAC9BmB,EAAMI,EAAKJ,CAGjB,MAIM,KAAMvC,GAHN0C,EAAMH,EAAI5L,QAGK,CACb,IAAKgM,EAAKvB,EAAGpB,GAAK0C,IAAO1C,EAAG2C,GAAMvB,GAClCmB,GAAOI,CACf,MAAiB3C,EAAI0C,IACbH,EAAMA,EAAIxF,MAAM,EAAGiD,GAAK,IAAMuC,EAAIxF,MAAMiD,IAI5C,OAAOuC,CACR,CAMDrC,EA3wFA,SAAS0C,EAAMC,GACb,IAAIC,EAAKC,EAAaC,EA4kBhBC,EAMAC,EAoqBAC,EACFC,EACAC,EACAC,EACAC,EAzvCFC,EAAItD,EAAUuD,UAAY,CAAEC,YAAaxD,EAAWyD,SAAU,KAAMC,QAAS,MAC7EC,EAAM,IAAI3D,EAAU,GAUpB4D,EAAiB,GAajBC,EAAgB,EAMhBC,GAAc,EAIdC,EAAa,GAMbC,GAAW,IAKXC,EAAU,IAGVC,GAAS,EAkBTC,EAAc,EAIdC,EAAgB,EAGhBC,EAAS,CACP/K,OAAQ,GACRgL,UAAW,EACXC,mBAAoB,EACpBC,eAAgB,IAChBC,iBAAkB,IAClBC,kBAAmB,EACnBC,uBAAwB,IACxBjO,OAAQ,IAMVkO,EAAW,uCACXC,GAAiC,EAgBnC,SAAS7E,EAAU8E,EAAGzQ,GACpB,IAAI0Q,EAAUrD,EAAGsD,EAAalF,EAAGtJ,EAAGyO,EAAOzC,EAAKH,EAC9Cd,EAAI2D,KAGN,KAAM3D,aAAavB,GAAY,OAAO,IAAIA,EAAU8E,EAAGzQ,GAEvD,GAAS,MAALA,EAAW,CAEb,GAAIyQ,IAAwB,IAAnBA,EAAEK,aAYT,OAXA5D,EAAEzL,EAAIgP,EAAEhP,QAEHgP,EAAEpD,GAAKoD,EAAEhF,EAAImE,EAChB1C,EAAEG,EAAIH,EAAEzB,EAAI,KACHgF,EAAEhF,EAAIkE,EACfzC,EAAEG,EAAI,CAACH,EAAEzB,EAAI,IAEbyB,EAAEzB,EAAIgF,EAAEhF,EACRyB,EAAEG,EAAIoD,EAAEpD,EAAE7E,UAMd,IAAKoI,EAAoB,iBAALH,IAAsB,EAAJA,GAAS,EAAG,CAMhD,GAHAvD,EAAEzL,EAAI,EAAIgP,EAAI,GAAKA,GAAKA,GAAI,GAAK,EAG7BA,MAAQA,EAAG,CACb,IAAKhF,EAAI,EAAGtJ,EAAIsO,EAAGtO,GAAK,GAAIA,GAAK,GAAIsJ,KASrC,YAPIA,EAAImE,EACN1C,EAAEG,EAAIH,EAAEzB,EAAI,MAEZyB,EAAEzB,EAAIA,EACNyB,EAAEG,EAAI,CAACoD,IAIV,CAEDzC,EAAMH,OAAO4C,EACvB,KAAe,CAEL,IAAK7E,EAAUmF,KAAK/C,EAAMH,OAAO4C,IAAK,OAAOhC,EAAavB,EAAGc,EAAK4C,GAElE1D,EAAEzL,EAAyB,IAArBuM,EAAIhB,WAAW,IAAYgB,EAAMA,EAAIxF,MAAM,IAAK,GAAK,CAC5D,EAGIiD,EAAIuC,EAAIlK,QAAQ,OAAS,IAAGkK,EAAMA,EAAItM,QAAQ,IAAK,MAGnDS,EAAI6L,EAAIgD,OAAO,OAAS,GAGvBvF,EAAI,IAAGA,EAAItJ,GACfsJ,IAAMuC,EAAIxF,MAAMrG,EAAI,GACpB6L,EAAMA,EAAIiD,UAAU,EAAG9O,IACdsJ,EAAI,IAGbA,EAAIuC,EAAI5L,OAGlB,KAAa,CAOL,GAJAqL,EAASzN,EAAG,EAAGuQ,EAASnO,OAAQ,QAIvB,IAALpC,GAAWwQ,EAEb,OAAOU,EADPhE,EAAI,IAAIvB,EAAU8E,GACFlB,EAAiBrC,EAAEzB,EAAI,EAAG+D,GAK5C,GAFAxB,EAAMH,OAAO4C,GAETG,EAAoB,iBAALH,EAAe,CAGhC,GAAQ,EAAJA,GAAS,EAAG,OAAOhC,EAAavB,EAAGc,EAAK4C,EAAO5Q,GAKnD,GAHAkN,EAAEzL,EAAI,EAAIgP,EAAI,GAAKzC,EAAMA,EAAIxF,MAAM,IAAK,GAAK,EAGzCmD,EAAUwF,OAASnD,EAAItM,QAAQ,YAAa,IAAIU,OAAS,GAC3D,MAAMyI,MACJqB,EAAgBuE,EAE9B,MACUvD,EAAEzL,EAA0B,KAAtBuM,EAAIhB,WAAW,IAAagB,EAAMA,EAAIxF,MAAM,IAAK,GAAK,EAQ9D,IALAkI,EAAWH,EAAS/H,MAAM,EAAGxI,GAC7ByL,EAAItJ,EAAI,EAIHgM,EAAMH,EAAI5L,OAAQD,EAAIgM,EAAKhM,IAC9B,GAAIuO,EAAS5M,QAAQuJ,EAAIW,EAAIC,OAAO9L,IAAM,EAAG,CAC3C,GAAS,KAALkL,GAGF,GAAIlL,EAAIsJ,EAAG,CACTA,EAAI0C,EACJ,QACD,OACI,IAAKwC,IAGN3C,GAAOA,EAAIoD,gBAAkBpD,EAAMA,EAAIqD,gBACvCrD,GAAOA,EAAIqD,gBAAkBrD,EAAMA,EAAIoD,gBAAgB,CACzDT,GAAc,EACdxO,GAAK,EACLsJ,EAAI,EACJ,QACD,CAGH,OAAOgD,EAAavB,EAAGW,OAAO4C,GAAIG,EAAO5Q,EAC1C,CAIH4Q,GAAQ,GAIHnF,GAHLuC,EAAMQ,EAAYR,EAAKhO,EAAG,GAAIkN,EAAEzL,IAGnBqC,QAAQ,OAAS,EAAGkK,EAAMA,EAAItM,QAAQ,IAAK,IACnD+J,EAAIuC,EAAI5L,MACd,CAGD,IAAKD,EAAI,EAAyB,KAAtB6L,EAAIhB,WAAW7K,GAAWA,KAGtC,IAAKgM,EAAMH,EAAI5L,OAAkC,KAA1B4L,EAAIhB,aAAamB,KAExC,GAAIH,EAAMA,EAAIxF,MAAMrG,IAAKgM,GAAM,CAI7B,GAHAA,GAAOhM,EAGHyO,GAASjF,EAAUwF,OACrBhD,EAAM,KAAOsC,EAAIpE,GAAoBoE,IAAM1E,EAAU0E,IACnD,MAAM5F,MACJqB,EAAiBgB,EAAEzL,EAAIgP,GAI7B,IAAKhF,EAAIA,EAAItJ,EAAI,GAAKyN,EAGpB1C,EAAEG,EAAIH,EAAEzB,EAAI,UAGP,GAAIA,EAAIkE,EAGbzC,EAAEG,EAAI,CAACH,EAAEzB,EAAI,OACR,CAWL,GAVAyB,EAAEzB,EAAIA,EACNyB,EAAEG,EAAI,GAMNlL,GAAKsJ,EAAI,GAAKW,EACVX,EAAI,IAAGtJ,GAAKiK,GAEZjK,EAAIgM,EAAK,CAGX,IAFIhM,GAAG+K,EAAEG,EAAE7F,MAAMwG,EAAIxF,MAAM,EAAGrG,IAEzBgM,GAAO/B,EAAUjK,EAAIgM,GACxBjB,EAAEG,EAAE7F,MAAMwG,EAAIxF,MAAMrG,EAAGA,GAAKiK,IAG9BjK,EAAIiK,GAAY4B,EAAMA,EAAIxF,MAAMrG,IAAIC,MAChD,MACYD,GAAKgM,EAGP,KAAOhM,IAAK6L,GAAO,KACnBd,EAAEG,EAAE7F,MAAMwG,EACX,CACT,MAGQd,EAAEG,EAAI,CAACH,EAAEzB,EAAI,EAEhB,CA21BD,SAAS1J,EAAO2K,EAAGvK,EAAGmP,EAAIC,GACxB,IAAIC,EAAI/F,EAAGgG,EAAItD,EAAKH,EAKpB,GAHU,MAANsD,EAAYA,EAAK9B,EAChB/B,EAAS6D,EAAI,EAAG,IAEhB5E,EAAEW,EAAG,OAAOX,EAAE0C,WAKnB,GAHAoC,EAAK9E,EAAEW,EAAE,GACToE,EAAK/E,EAAEjB,EAEE,MAALtJ,EACF6L,EAAMrB,EAAcD,EAAEW,GACtBW,EAAY,GAANuD,GAAiB,GAANA,IAAYE,GAAMhC,GAAcgC,GAAM/B,GACpD3B,EAAcC,EAAKyD,GACnBvD,EAAaF,EAAKyD,EAAI,UAezB,GAVAhG,GAHAiB,EAAIwE,EAAM,IAAIvF,EAAUe,GAAIvK,EAAGmP,IAGzB7F,EAGN0C,GADAH,EAAMrB,EAAcD,EAAEW,IACZjL,OAOA,GAANmP,GAAiB,GAANA,IAAYpP,GAAKsJ,GAAKA,GAAKgE,GAAa,CAGrD,KAAOtB,EAAMhM,EAAG6L,GAAO,IAAKG,KAC5BH,EAAMD,EAAcC,EAAKvC,EAGnC,MAKU,GAJAtJ,GAAKsP,EACLzD,EAAME,EAAaF,EAAKvC,EAAG,KAGvBA,EAAI,EAAI0C,GACV,KAAMhM,EAAI,EAAG,IAAK6L,GAAO,IAAK7L,IAAK6L,GAAO,WAG1C,IADA7L,GAAKsJ,EAAI0C,GACD,EAEN,IADI1C,EAAI,GAAK0C,IAAKH,GAAO,KAClB7L,IAAK6L,GAAO,KAM3B,OAAOtB,EAAEjL,EAAI,GAAK+P,EAAK,IAAMxD,EAAMA,CACpC,CAKD,SAAS0D,EAASC,EAAMjF,GAKtB,IAJA,IAAIa,EAAGJ,EACLhL,EAAI,EACJ+K,EAAI,IAAIvB,EAAUgG,EAAK,IAElBxP,EAAIwP,EAAKvP,OAAQD,OACtBgL,EAAI,IAAIxB,EAAUgG,EAAKxP,KAChBV,IAAM8L,EAAIN,EAAQC,EAAGC,MAAQT,GAAW,IAANa,GAAWL,EAAEzL,IAAMiL,KAC1DQ,EAAIC,GAIR,OAAOD,CACR,CAOD,SAAS0E,EAAUlF,EAAGW,EAAG5B,GAKvB,IAJA,IAAItJ,EAAI,EACN2K,EAAIO,EAAEjL,QAGAiL,IAAIP,GAAIO,EAAEwE,OAGlB,IAAK/E,EAAIO,EAAE,GAAIP,GAAK,GAAIA,GAAK,GAAI3K,KAkBjC,OAfKsJ,EAAItJ,EAAIsJ,EAAIW,EAAW,GAAKwD,EAG/BlD,EAAEW,EAAIX,EAAEjB,EAAI,KAGHA,EAAIkE,EAGbjD,EAAEW,EAAI,CAACX,EAAEjB,EAAI,IAEbiB,EAAEjB,EAAIA,EACNiB,EAAEW,EAAIA,GAGDX,CACR,CAyDD,SAASwE,EAAMhE,EAAG4E,EAAIR,EAAIvE,GACxB,IAAIgF,EAAG5P,EAAG2K,EAAGS,EAAGb,EAAGsF,EAAIC,EACrB7E,EAAKF,EAAEG,EACP6E,EAAS5F,EAGX,GAAIc,EAAI,CAQN+E,EAAK,CAGH,IAAKJ,EAAI,EAAGxE,EAAIH,EAAG,GAAIG,GAAK,GAAIA,GAAK,GAAIwE,KAIzC,IAHA5P,EAAI2P,EAAKC,GAGD,EACN5P,GAAKiK,EACLU,EAAIgF,EACJpF,EAAIU,EAAG4E,EAAK,GAGZC,EAAKlG,EAAUW,EAAIwF,EAAOH,EAAIjF,EAAI,GAAK,SAIvC,IAFAkF,EAAKnG,GAAU1J,EAAI,GAAKiK,KAEdgB,EAAGhL,OAAQ,CAEnB,IAAI2K,EASF,MAAMoF,EANN,KAAO/E,EAAGhL,QAAU4P,EAAI5E,EAAG5F,KAAK,IAChCkF,EAAIuF,EAAK,EACTF,EAAI,EAEJjF,GADA3K,GAAKiK,GACGA,EAAW,CAInC,KAAmB,CAIL,IAHAM,EAAIa,EAAIH,EAAG4E,GAGND,EAAI,EAAGxE,GAAK,GAAIA,GAAK,GAAIwE,KAU9BE,GAHAnF,GAJA3K,GAAKiK,GAIGA,EAAW2F,GAGV,EAAI,EAAIhG,EAAUW,EAAIwF,EAAOH,EAAIjF,EAAI,GAAK,GACpD,CAkBH,GAfAC,EAAIA,GAAK+E,EAAK,GAKC,MAAd1E,EAAG4E,EAAK,KAAelF,EAAI,EAAIJ,EAAIA,EAAIwF,EAAOH,EAAIjF,EAAI,IAEvDC,EAAIuE,EAAK,GACLW,GAAMlF,KAAa,GAANuE,GAAWA,IAAOpE,EAAEzL,EAAI,EAAI,EAAI,IAC9CwQ,EAAK,GAAW,GAANA,IAAkB,GAANX,GAAWvE,GAAW,GAANuE,IAGrCnP,EAAI,EAAI2K,EAAI,EAAIJ,EAAIwF,EAAOH,EAAIjF,GAAK,EAAIM,EAAG4E,EAAK,IAAM,GAAM,GAC7DV,IAAOpE,EAAEzL,EAAI,EAAI,EAAI,IAEpBqQ,EAAK,IAAM1E,EAAG,GAiBhB,OAhBAA,EAAGhL,OAAS,EAER2K,GAGF+E,GAAM5E,EAAEzB,EAAI,EAGZ2B,EAAG,GAAK8E,GAAQ9F,EAAW0F,EAAK1F,GAAYA,GAC5Cc,EAAEzB,GAAKqG,GAAM,GAIb1E,EAAG,GAAKF,EAAEzB,EAAI,EAGTyB,EAkBT,GAdS,GAAL/K,GACFiL,EAAGhL,OAAS4P,EACZzE,EAAI,EACJyE,MAEA5E,EAAGhL,OAAS4P,EAAK,EACjBzE,EAAI2E,EAAO9F,EAAWjK,GAItBiL,EAAG4E,GAAMlF,EAAI,EAAIf,EAAUW,EAAIwF,EAAOH,EAAIjF,GAAKoF,EAAOpF,IAAMS,EAAI,GAI9DR,EAEF,OAAU,CAGR,GAAU,GAANiF,EAAS,CAGX,IAAK7P,EAAI,EAAG2K,EAAIM,EAAG,GAAIN,GAAK,GAAIA,GAAK,GAAI3K,KAEzC,IADA2K,EAAIM,EAAG,IAAMG,EACRA,EAAI,EAAGT,GAAK,GAAIA,GAAK,GAAIS,KAG1BpL,GAAKoL,IACPL,EAAEzB,IACE2B,EAAG,IAAMjB,IAAMiB,EAAG,GAAK,IAG7B,KAChB,CAEgB,GADAA,EAAG4E,IAAOzE,EACNH,EAAG4E,IAAO7F,EAAM,MACpBiB,EAAG4E,KAAQ,EACXzE,EAAI,CAEP,CAIH,IAAKpL,EAAIiL,EAAGhL,OAAoB,IAAZgL,IAAKjL,GAAUiL,EAAGyE,OACvC,CAGG3E,EAAEzB,EAAImE,EACR1C,EAAEG,EAAIH,EAAEzB,EAAI,KAGHyB,EAAEzB,EAAIkE,IACfzC,EAAEG,EAAI,CAACH,EAAEzB,EAAI,GAEhB,CAED,OAAOyB,CACR,CAGD,SAASmC,EAAQ3C,GACf,IAAIsB,EACFvC,EAAIiB,EAAEjB,EAER,OAAU,OAANA,EAAmBiB,EAAE0C,YAEzBpB,EAAMrB,EAAcD,EAAEW,GAEtBW,EAAMvC,GAAKgE,GAAchE,GAAKiE,EAC1B3B,EAAcC,EAAKvC,GACnByC,EAAaF,EAAKvC,EAAG,KAElBiB,EAAEjL,EAAI,EAAI,IAAMuM,EAAMA,EAC9B,CA+qCD,OAn1EArC,EAAU0C,MAAQA,EAElB1C,EAAUyG,SAAW,EACrBzG,EAAU0G,WAAa,EACvB1G,EAAU2G,WAAa,EACvB3G,EAAU4G,YAAc,EACxB5G,EAAU6G,cAAgB,EAC1B7G,EAAU8G,gBAAkB,EAC5B9G,EAAU+G,gBAAkB,EAC5B/G,EAAUgH,gBAAkB,EAC5BhH,EAAUiH,iBAAmB,EAC7BjH,EAAUkH,OAAS,EAqCnBlH,EAAUmH,OAASnH,EAAUoH,IAAM,SAAUC,GAC3C,IAAIC,EAAGxC,EAEP,GAAW,MAAPuC,EAAa,CAEf,GAAkB,iBAAPA,EA4HT,MAAMnI,MACJoB,EAAiB,oBAAsB+G,GAvFzC,GAlCIA,EAAIE,eAAeD,EAAI,oBAEzBxF,EADAgD,EAAIuC,EAAIC,GACI,EAAGzG,EAAKyG,GACpB1D,EAAiBkB,GAKfuC,EAAIE,eAAeD,EAAI,mBAEzBxF,EADAgD,EAAIuC,EAAIC,GACI,EAAG,EAAGA,GAClBzD,EAAgBiB,GAOduC,EAAIE,eAAeD,EAAI,qBACzBxC,EAAIuC,EAAIC,KACCxC,EAAEoB,KACTpE,EAASgD,EAAE,IAAKjE,EAAK,EAAGyG,GACxBxF,EAASgD,EAAE,GAAI,EAAGjE,EAAKyG,GACvBxD,EAAagB,EAAE,GACff,EAAae,EAAE,KAEfhD,EAASgD,GAAIjE,EAAKA,EAAKyG,GACvBxD,IAAeC,EAAae,EAAI,GAAKA,EAAIA,KAOzCuC,EAAIE,eAAeD,EAAI,SAEzB,IADAxC,EAAIuC,EAAIC,KACCxC,EAAEoB,IACTpE,EAASgD,EAAE,IAAKjE,GAAM,EAAGyG,GACzBxF,EAASgD,EAAE,GAAI,EAAGjE,EAAKyG,GACvBtD,EAAUc,EAAE,GACZb,EAAUa,EAAE,OACP,CAEL,GADAhD,EAASgD,GAAIjE,EAAKA,EAAKyG,IACnBxC,EAGF,MAAM5F,MACJoB,EAAiBgH,EAAI,oBAAsBxC,GAH7Cd,IAAYC,EAAUa,EAAI,GAAKA,EAAIA,EAKtC,CAMH,GAAIuC,EAAIE,eAAeD,EAAI,UAAW,CAEpC,IADAxC,EAAIuC,EAAIC,QACIxC,EAcV,MAAM5F,MACJoB,EAAiBgH,EAAI,uBAAyBxC,GAdhD,GAAIA,EAAG,CACL,GAAqB,oBAAV0C,SAAyBA,SAClCA,OAAOC,kBAAmBD,OAAOE,YAIjC,MADAxD,GAAUY,EACJ5F,MACJoB,EAAiB,sBAJnB4D,EAASY,CAM3B,MACgBZ,EAASY,CAMd,CAoBD,GAhBIuC,EAAIE,eAAeD,EAAI,iBAEzBxF,EADAgD,EAAIuC,EAAIC,GACI,EAAG,EAAGA,GAClBnD,EAAcW,GAKZuC,EAAIE,eAAeD,EAAI,mBAEzBxF,EADAgD,EAAIuC,EAAIC,GACI,EAAGzG,EAAKyG,GACpBlD,EAAgBU,GAKduC,EAAIE,eAAeD,EAAI,UAAW,CAEpC,GAAgB,iBADhBxC,EAAIuC,EAAIC,IAEH,MAAMpI,MACToB,EAAiBgH,EAAI,mBAAqBxC,GAFlBT,EAASS,CAGpC,CAID,GAAIuC,EAAIE,eAAeD,EAAI,YAAa,CAKtC,GAAgB,iBAJhBxC,EAAIuC,EAAIC,KAIqB,wBAAwBlC,KAAKN,GAIxD,MAAM5F,MACJoB,EAAiBgH,EAAI,aAAexC,GAJtCD,EAAmD,cAAlBC,EAAEjI,MAAM,EAAG,IAC5C+H,EAAWE,CAKd,CAQJ,CAED,MAAO,CACLlB,eAAgBA,EAChBC,cAAeA,EACf8D,eAAgB,CAAC7D,EAAYC,GAC7B6D,MAAO,CAAC5D,EAASC,GACjBC,OAAQA,EACRC,YAAaA,EACbC,cAAeA,EACfC,OAAQA,EACRO,SAAUA,EAElB,EAYI5E,EAAU6H,YAAc,SAAU/C,GAChC,IAAKA,IAAwB,IAAnBA,EAAEK,aAAuB,OAAO,EAC1C,IAAKnF,EAAUwF,MAAO,OAAO,EAE7B,IAAIhP,EAAGuK,EACLW,EAAIoD,EAAEpD,EACN5B,EAAIgF,EAAEhF,EACNhK,EAAIgP,EAAEhP,EAER0Q,EAAK,GAA2B,kBAAvB,CAAA,EAAG/C,SAASqE,KAAKpG,IAExB,IAAW,IAAN5L,IAAkB,IAAPA,IAAagK,IAAMe,GAAOf,GAAKe,GAAOf,IAAMM,EAAUN,GAAI,CAGxE,GAAa,IAAT4B,EAAE,GAAU,CACd,GAAU,IAAN5B,GAAwB,IAAb4B,EAAEjL,OAAc,OAAO,EACtC,MAAM+P,CACP,CAQD,IALAhQ,GAAKsJ,EAAI,GAAKW,GACN,IAAGjK,GAAKiK,GAIZyB,OAAOR,EAAE,IAAIjL,QAAUD,EAAG,CAE5B,IAAKA,EAAI,EAAGA,EAAIkL,EAAEjL,OAAQD,IAExB,IADAuK,EAAIW,EAAElL,IACE,GAAKuK,GAAKP,GAAQO,IAAMX,EAAUW,GAAI,MAAMyF,EAItD,GAAU,IAANzF,EAAS,OAAO,CACrB,CACF,OAGI,GAAU,OAANW,GAAoB,OAAN5B,IAAqB,OAANhK,GAAoB,IAANA,IAAkB,IAAPA,GAC/D,OAAO,EAGT,MAAMoJ,MACHoB,EAAiB,sBAAwBwE,EAClD,EAQI9E,EAAU+H,QAAU/H,EAAUgC,IAAM,WAClC,OAAO+D,EAASiC,WAAY,EAClC,EAQIhI,EAAUiI,QAAUjI,EAAU+B,IAAM,WAClC,OAAOgE,EAASiC,UAAW,EACjC,EAaIhI,EAAUkI,QACJnF,EAAU,iBAMVC,EAAkBrN,KAAKuS,SAAWnF,EAAW,QAC9C,WAAc,OAAO3C,EAAUzK,KAAKuS,SAAWnF,EAAW,EAC1D,WAAc,OAA2C,SAAlB,WAAhBpN,KAAKuS,SAAwB,IACnC,QAAhBvS,KAAKuS,SAAsB,EAAG,EAE3B,SAAUC,GACf,IAAIlH,EAAG5M,EAAGyL,EAAG8B,EAAGkD,EACdtO,EAAI,EACJkL,EAAI,GACJ0G,EAAO,IAAIpI,EAAU2D,GAOvB,GALU,MAANwE,EAAYA,EAAKvE,EAChB9B,EAASqG,EAAI,EAAGtH,GAErBe,EAAI1B,EAASiI,EAAK1H,GAEdyD,EAGF,GAAIsD,OAAOC,gBAAiB,CAI1B,IAFAxG,EAAIuG,OAAOC,gBAAgB,IAAIY,YAAYzG,GAAK,IAEzCpL,EAAIoL,IAQTkD,EAAW,OAAP7D,EAAEzK,IAAgByK,EAAEzK,EAAI,KAAO,MAM1B,MACPnC,EAAImT,OAAOC,gBAAgB,IAAIY,YAAY,IAC3CpH,EAAEzK,GAAKnC,EAAE,GACT4M,EAAEzK,EAAI,GAAKnC,EAAE,KAKbqN,EAAE7F,KAAKiJ,EAAI,MACXtO,GAAK,GAGTA,EAAIoL,EAAI,CAGpB,KAAiB,KAAI4F,OAAOE,YA2BhB,MADAxD,GAAS,EACHhF,MACJoB,EAAiB,sBAvBnB,IAFAW,EAAIuG,OAAOE,YAAY9F,GAAK,GAErBpL,EAAIoL,IAMTkD,EAAmB,iBAAN,GAAP7D,EAAEzK,IAA0C,cAAXyK,EAAEzK,EAAI,GAC9B,WAAXyK,EAAEzK,EAAI,GAAgC,SAAXyK,EAAEzK,EAAI,IACjCyK,EAAEzK,EAAI,IAAM,KAAOyK,EAAEzK,EAAI,IAAM,GAAKyK,EAAEzK,EAAI,KAErC,KACPgR,OAAOE,YAAY,GAAGY,KAAKrH,EAAGzK,IAI9BkL,EAAE7F,KAAKiJ,EAAI,MACXtO,GAAK,GAGTA,EAAIoL,EAAI,CAKT,CAIH,IAAKsC,EAEH,KAAO1N,EAAIoL,IACTkD,EAAI9B,KACI,OAAMtB,EAAElL,KAAOsO,EAAI,MAc/B,IAVAlD,EAAIF,IAAIlL,GACR2R,GAAM1H,EAGFmB,GAAKuG,IACPrD,EAAInE,EAASF,EAAW0H,GACxBzG,EAAElL,GAAK4J,EAAUwB,EAAIkD,GAAKA,GAIZ,IAATpD,EAAElL,GAAUkL,EAAEwE,MAAO1P,KAG5B,GAAIA,EAAI,EACNkL,EAAI,CAAC5B,EAAI,OACJ,CAGL,IAAKA,GAAK,EAAa,IAAT4B,EAAE,GAAUA,EAAE6G,OAAO,EAAG,GAAIzI,GAAKW,GAG/C,IAAKjK,EAAI,EAAGsO,EAAIpD,EAAE,GAAIoD,GAAK,GAAIA,GAAK,GAAItO,KAGpCA,EAAIiK,IAAUX,GAAKW,EAAWjK,EACnC,CAID,OAFA4R,EAAKtI,EAAIA,EACTsI,EAAK1G,EAAIA,EACF0G,CACf,GASIpI,EAAUwI,IAAM,WAId,IAHA,IAAIhS,EAAI,EACNwP,EAAOgC,UACPQ,EAAM,IAAIxI,EAAUgG,EAAK,IACpBxP,EAAIwP,EAAKvP,QAAS+R,EAAMA,EAAIC,KAAKzC,EAAKxP,MAC7C,OAAOgS,CACb,EAOI3F,EAAc,WACZ,IAAIjP,EAAU,aAOd,SAAS8U,EAAUrG,EAAKsG,EAAQC,EAAS7D,GAOvC,IANA,IAAI5D,EAEF0H,EADAC,EAAM,CAAC,GAEPtS,EAAI,EACJgM,EAAMH,EAAI5L,OAELD,EAAIgM,GAAM,CACf,IAAKqG,EAAOC,EAAIrS,OAAQoS,IAAQC,EAAID,IAASF,GAI7C,IAFAG,EAAI,IAAM/D,EAAS5M,QAAQkK,EAAIC,OAAO9L,MAEjC2K,EAAI,EAAGA,EAAI2H,EAAIrS,OAAQ0K,IAEtB2H,EAAI3H,GAAKyH,EAAU,IACH,MAAdE,EAAI3H,EAAI,KAAY2H,EAAI3H,EAAI,GAAK,GACrC2H,EAAI3H,EAAI,IAAM2H,EAAI3H,GAAKyH,EAAU,EACjCE,EAAI3H,IAAMyH,EAGf,CAED,OAAOE,EAAIzR,SACZ,CAKD,OAAO,SAAUgL,EAAKsG,EAAQC,EAASG,EAAMC,GAC3C,IAAIjE,EAAUqB,EAAGtG,EAAG8B,EAAGR,EAAGG,EAAGE,EAAID,EAC/BhL,EAAI6L,EAAIlK,QAAQ,KAChBgQ,EAAKvE,EACL+B,EAAK9B,EA+BP,IA5BIrN,GAAK,IACPoL,EAAIwC,EAGJA,EAAgB,EAChB/B,EAAMA,EAAItM,QAAQ,IAAK,IAEvBwL,GADAC,EAAI,IAAIxB,EAAU2I,IACZ/S,IAAIyM,EAAI5L,OAASD,GACvB4N,EAAgBxC,EAKhBJ,EAAEE,EAAIgH,EAAUnG,EAAavB,EAAcO,EAAEG,GAAIH,EAAEzB,EAAG,KACrD,GAAI8I,EAAShV,GACd4N,EAAE1B,EAAI0B,EAAEE,EAAEjL,QAUZqJ,EAAI8B,GALJH,EAAKiH,EAAUrG,EAAKsG,EAAQC,EAASI,GACjCjE,EAAWH,EAAUhR,IACrBmR,EAAWnR,EAASgR,KAGbnO,OAGO,GAAXgL,IAAKG,GAASH,EAAGyE,OAGxB,IAAKzE,EAAG,GAAI,OAAOsD,EAASzC,OAAO,GAqCnC,GAlCI9L,EAAI,IACJsJ,GAEFyB,EAAEG,EAAID,EACNF,EAAEzB,EAAIA,EAGNyB,EAAEzL,EAAIiT,EAENtH,GADAF,EAAIqB,EAAIrB,EAAGC,EAAG2G,EAAIxC,EAAIiD,IACflH,EACPN,EAAIG,EAAEH,EACNtB,EAAIyB,EAAEzB,GASRtJ,EAAIiL,EAHJ2E,EAAItG,EAAIqI,EAAK,GAObvG,EAAIgH,EAAU,EACdxH,EAAIA,GAAKgF,EAAI,GAAkB,MAAb3E,EAAG2E,EAAI,GAEzBhF,EAAIuE,EAAK,GAAU,MAALnP,GAAa4K,KAAa,GAANuE,GAAWA,IAAOpE,EAAEzL,EAAI,EAAI,EAAI,IAC1DU,EAAIoL,GAAKpL,GAAKoL,IAAW,GAAN+D,GAAWvE,GAAW,GAANuE,GAAuB,EAAZlE,EAAG2E,EAAI,IACtDT,IAAOpE,EAAEzL,EAAI,EAAI,EAAI,IAKxBsQ,EAAI,IAAM3E,EAAG,GAGfY,EAAMjB,EAAImB,EAAawC,EAASzC,OAAO,IAAK6F,EAAIpD,EAASzC,OAAO,IAAMyC,EAASzC,OAAO,OACjF,CAML,GAHAb,EAAGhL,OAAS2P,EAGRhF,EAGF,MAAOwH,IAAWnH,IAAK2E,GAAKwC,GAC1BnH,EAAG2E,GAAK,EAEHA,MACDtG,EACF2B,EAAK,CAAC,GAAGwH,OAAOxH,IAMtB,IAAKG,EAAIH,EAAGhL,QAASgL,IAAKG,KAG1B,IAAKpL,EAAI,EAAG6L,EAAM,GAAI7L,GAAKoL,EAAGS,GAAO0C,EAASzC,OAAOb,EAAGjL,OAGxD6L,EAAME,EAAaF,EAAKvC,EAAGiF,EAASzC,OAAO,GAC5C,CAGD,OAAOD,CACf,CACK,CAnJa,GAuJdO,EAAM,WAGJ,SAASsG,EAAS3H,EAAGK,EAAG3I,GACtB,IAAIkQ,EAAGC,EAAMC,EAAKC,EAChBC,EAAQ,EACR/S,EAAI+K,EAAE9K,OACN+S,EAAM5H,EAAIhB,EACV6I,EAAM7H,EAAIhB,EAAY,EAExB,IAAKW,EAAIA,EAAE1E,QAASrG,KAKlB+S,IADAH,EAAOI,GAHPH,EAAM9H,EAAE/K,GAAKoK,IAEbuI,EAAIM,EAAMJ,GADVC,EAAM/H,EAAE/K,GAAKoK,EAAY,GACH4I,GACG5I,EAAaA,EAAa2I,GACnCtQ,EAAO,IAAMkQ,EAAIvI,EAAY,GAAK6I,EAAMH,EACxD/H,EAAE/K,GAAK4S,EAAOnQ,EAKhB,OAFIsQ,IAAOhI,EAAI,CAACgI,GAAON,OAAO1H,IAEvBA,CACR,CAED,SAASD,EAAQL,EAAG5M,EAAGqV,EAAIC,GACzB,IAAInT,EAAGoT,EAEP,GAAIF,GAAMC,EACRC,EAAMF,EAAKC,EAAK,GAAK,OAGrB,IAAKnT,EAAIoT,EAAM,EAAGpT,EAAIkT,EAAIlT,IAExB,GAAIyK,EAAEzK,IAAMnC,EAAEmC,GAAI,CAChBoT,EAAM3I,EAAEzK,GAAKnC,EAAEmC,GAAK,GAAK,EACzB,KACD,CAIL,OAAOoT,CACR,CAED,SAASC,EAAS5I,EAAG5M,EAAGqV,EAAIzQ,GAI1B,IAHA,IAAIzC,EAAI,EAGDkT,KACLzI,EAAEyI,IAAOlT,EACTA,EAAIyK,EAAEyI,GAAMrV,EAAEqV,GAAM,EAAI,EACxBzI,EAAEyI,GAAMlT,EAAIyC,EAAOgI,EAAEyI,GAAMrV,EAAEqV,GAI/B,MAAQzI,EAAE,IAAMA,EAAExK,OAAS,EAAGwK,EAAEsH,OAAO,EAAG,IAC3C,CAGD,OAAO,SAAUhH,EAAGC,EAAG2G,EAAIxC,EAAI1M,GAC7B,IAAI2Q,EAAK9J,EAAGtJ,EAAGsT,EAAM/I,EAAGgJ,EAAMC,EAAOC,EAAGC,EAAIC,EAAKC,EAAMC,EAAMC,EAAIC,EAAIC,EACnEC,EAAIC,EACJ5U,EAAIyL,EAAEzL,GAAK0L,EAAE1L,EAAI,GAAK,EACtB2L,EAAKF,EAAEG,EACPC,EAAKH,EAAEE,EAGT,KAAKD,GAAOA,EAAG,IAAOE,GAAOA,EAAG,IAE9B,OAAO,IAAI3B,EAGTuB,EAAEzL,GAAM0L,EAAE1L,IAAM2L,GAAKE,GAAMF,EAAG,IAAME,EAAG,GAAMA,GAG7CF,GAAe,GAATA,EAAG,KAAYE,EAAS,EAAJ7L,EAAQA,EAAI,EAHa6U,KAoBvD,IAZAT,GADAD,EAAI,IAAIjK,EAAUlK,IACX4L,EAAI,GAEX5L,EAAIqS,GADJrI,EAAIyB,EAAEzB,EAAI0B,EAAE1B,GACC,EAER7G,IACHA,EAAOuH,EACPV,EAAIgB,EAASS,EAAEzB,EAAIW,GAAYK,EAASU,EAAE1B,EAAIW,GAC9C3K,EAAIA,EAAI2K,EAAW,GAKhBjK,EAAI,EAAGmL,EAAGnL,KAAOiL,EAAGjL,IAAM,GAAIA,KAInC,GAFImL,EAAGnL,IAAMiL,EAAGjL,IAAM,IAAIsJ,IAEtBhK,EAAI,EACNoU,EAAGrO,KAAK,GACRiO,GAAO,MACF,CAwBL,IAvBAS,EAAK9I,EAAGhL,OACRgU,EAAK9I,EAAGlL,OACRD,EAAI,EACJV,GAAK,GAILiL,EAAIX,EAAUnH,GAAQ0I,EAAG,GAAK,KAItB,IACNA,EAAKuH,EAASvH,EAAIZ,EAAG9H,GACrBwI,EAAKyH,EAASzH,EAAIV,EAAG9H,GACrBwR,EAAK9I,EAAGlL,OACR8T,EAAK9I,EAAGhL,QAGV6T,EAAKG,EAELL,GADAD,EAAM1I,EAAG5E,MAAM,EAAG4N,IACPhU,OAGJ2T,EAAOK,EAAIN,EAAIC,KAAU,GAChCM,EAAK/I,EAAG9E,QACR6N,EAAK,CAAC,GAAGzB,OAAOyB,GAChBF,EAAM7I,EAAG,GACLA,EAAG,IAAM1I,EAAO,GAAGuR,IAIvB,EAAG,CAOD,GANAzJ,EAAI,GAGJ6I,EAAMtI,EAAQK,EAAIwI,EAAKM,EAAIL,IAGjB,EAAG,CAqBX,GAjBAC,EAAOF,EAAI,GACPM,GAAML,IAAMC,EAAOA,EAAOpR,GAAQkR,EAAI,IAAM,KAGhDpJ,EAAIX,EAAUiK,EAAOG,IAab,EAcN,IAXIzJ,GAAK9H,IAAM8H,EAAI9H,EAAO,GAI1B+Q,GADAD,EAAOb,EAASvH,EAAIZ,EAAG9H,IACVxC,OACb2T,EAAOD,EAAI1T,OAM+B,GAAnC6K,EAAQyI,EAAMI,EAAKH,EAAOI,IAC/BrJ,IAGA8I,EAASE,EAAMU,EAAKT,EAAQU,EAAK/I,EAAIqI,EAAO/Q,GAC5C+Q,EAAQD,EAAKtT,OACbmT,EAAM,OAQC,GAAL7I,IAGF6I,EAAM7I,EAAI,GAKZiJ,GADAD,EAAOpI,EAAG9E,SACGpG,OAUf,GAPIuT,EAAQI,IAAML,EAAO,CAAC,GAAGd,OAAOc,IAGpCF,EAASM,EAAKJ,EAAMK,EAAMnR,GAC1BmR,EAAOD,EAAI1T,QAGC,GAARmT,EAMF,KAAOtI,EAAQK,EAAIwI,EAAKM,EAAIL,GAAQ,GAClCrJ,IAGA8I,EAASM,EAAKM,EAAKL,EAAOM,EAAK/I,EAAIyI,EAAMnR,GACzCmR,EAAOD,EAAI1T,MAG7B,MAA+B,IAARmT,IACT7I,IACAoJ,EAAM,CAAC,IAITD,EAAG1T,KAAOuK,EAGNoJ,EAAI,GACNA,EAAIC,KAAU3I,EAAG6I,IAAO,GAExBH,EAAM,CAAC1I,EAAG6I,IACVF,EAAO,EAErB,QAAoBE,IAAOC,GAAgB,MAAVJ,EAAI,KAAerU,KAE1CgU,EAAiB,MAAVK,EAAI,GAGND,EAAG,IAAIA,EAAG3B,OAAO,EAAG,EAC1B,CAED,GAAItP,GAAQuH,EAAM,CAGhB,IAAKhK,EAAI,EAAGV,EAAIoU,EAAG,GAAIpU,GAAK,GAAIA,GAAK,GAAIU,KAEzC+O,EAAM0E,EAAG9B,GAAM8B,EAAEnK,EAAItJ,EAAIsJ,EAAIW,EAAW,GAAK,EAAGkF,EAAImE,EAG9D,MACUG,EAAEnK,EAAIA,EACNmK,EAAE7I,GAAK0I,EAGT,OAAOG,CACf,CACK,CAhQK,GA4XAhH,EAAa,8BACfC,EAAW,cACXC,EAAY,cACZC,EAAkB,qBAClBC,EAAmB,6BALvBP,EAOS,SAAUvB,EAAGc,EAAK4C,EAAO5Q,GAC9B,IAAI4E,EACFnD,EAAImP,EAAQ5C,EAAMA,EAAItM,QAAQsN,EAAkB,IAGlD,GAAID,EAAgBgC,KAAKtP,GACvByL,EAAEzL,EAAIO,MAAMP,GAAK,KAAOA,EAAI,GAAK,EAAI,MAChC,CACL,IAAKmP,IAGHnP,EAAIA,EAAEC,QAAQkN,GAAY,SAAUkG,EAAGyB,EAAIC,GAEzC,OADA5R,EAAkC,MAA1B4R,EAAKA,EAAGnF,eAAwB,GAAW,KAANmF,EAAY,EAAI,EACrDxW,GAAKA,GAAK4E,EAAYkQ,EAALyB,CACvC,IAEgBvW,IACF4E,EAAO5E,EAGPyB,EAAIA,EAAEC,QAAQmN,EAAU,MAAMnN,QAAQoN,EAAW,SAG/Cd,GAAOvM,GAAG,OAAO,IAAIkK,EAAUlK,EAAGmD,GAKxC,GAAI+G,EAAUwF,MACZ,MAAMtG,MACHoB,EAAiB,SAAWjM,EAAI,SAAWA,EAAI,IAAM,YAAcgO,GAIxEd,EAAEzL,EAAI,IACP,CAEDyL,EAAEG,EAAIH,EAAEzB,EAAI,IACb,EA4LHwD,EAAEwH,cAAgBxH,EAAEyH,IAAM,WACxB,IAAIxJ,EAAI,IAAIvB,EAAUkF,MAEtB,OADI3D,EAAEzL,EAAI,IAAGyL,EAAEzL,EAAI,GACZyL,CACb,EAUI+B,EAAE0H,WAAa,SAAUxJ,EAAGnN,GAC1B,OAAOiN,EAAQ4D,KAAM,IAAIlF,EAAUwB,EAAGnN,GAC5C,EAgBIiP,EAAE2H,cAAgB3H,EAAE6E,GAAK,SAAUA,EAAIxC,GACrC,IAAIjE,EAAGX,EAAG+D,EACRvD,EAAI2D,KAEN,GAAU,MAANiD,EAKF,OAJArG,EAASqG,EAAI,EAAGtH,GACN,MAAN8E,EAAYA,EAAK9B,EAChB/B,EAAS6D,EAAI,EAAG,GAEdJ,EAAM,IAAIvF,EAAUuB,GAAI4G,EAAK5G,EAAEzB,EAAI,EAAG6F,GAG/C,KAAMjE,EAAIH,EAAEG,GAAI,OAAO,KAIvB,GAHAX,IAAM+D,EAAIpD,EAAEjL,OAAS,GAAKqK,EAASoE,KAAKpF,EAAIW,IAAaA,EAGrDqE,EAAIpD,EAAEoD,GAAI,KAAOA,EAAI,IAAM,EAAGA,GAAK,GAAI/D,KAG3C,OAFIA,EAAI,IAAGA,EAAI,GAERA,CACb,EAuBIuC,EAAE4H,UAAY5H,EAAEV,IAAM,SAAUpB,EAAGnN,GACjC,OAAOuO,EAAIsC,KAAM,IAAIlF,EAAUwB,EAAGnN,GAAIuP,EAAgBC,EAC5D,EAOIP,EAAE6H,mBAAqB7H,EAAE8H,KAAO,SAAU5J,EAAGnN,GAC3C,OAAOuO,EAAIsC,KAAM,IAAIlF,EAAUwB,EAAGnN,GAAI,EAAG,EAC/C,EAkBIiP,EAAE+H,gBAAkB/H,EAAE1N,IAAM,SAAUmL,EAAGoI,GACvC,IAAImC,EAAMC,EAAU/U,EAAGoL,EAAS4J,EAAQC,EAAQC,EAAQlK,EACtDD,EAAI2D,KAKN,IAHAnE,EAAI,IAAIf,EAAUe,IAGZW,IAAMX,EAAE4K,YACZ,MAAMzM,MACHoB,EAAiB,4BAA8BoD,EAAQ3C,IAS5D,GANS,MAALoI,IAAWA,EAAI,IAAInJ,EAAUmJ,IAGjCqC,EAASzK,EAAEjB,EAAI,IAGVyB,EAAEG,IAAMH,EAAEG,EAAE,IAAgB,GAAVH,EAAEG,EAAE,KAAYH,EAAEzB,GAAmB,GAAdyB,EAAEG,EAAEjL,SAAgBsK,EAAEW,IAAMX,EAAEW,EAAE,GAK5E,OADAF,EAAI,IAAIxB,EAAUrK,KAAKC,KAAK8N,EAAQnC,GAAIiK,EAASzK,EAAEjL,GAAK,EAAIqM,EAAMpB,KAAO2C,EAAQ3C,KAC1EoI,EAAI3H,EAAEoK,IAAIzC,GAAK3H,EAKxB,GAFAiK,EAAS1K,EAAEjL,EAAI,EAEXqT,EAAG,CAGL,GAAIA,EAAEzH,GAAKyH,EAAEzH,EAAE,IAAMyH,EAAErT,EAAG,OAAO,IAAIkK,EAAU2K,MAE/CY,GAAYE,GAAUlK,EAAEoK,aAAexC,EAAEwC,eAE3BpK,EAAIA,EAAEqK,IAAIzC,GAIzB,KAAM,IAAIpI,EAAEjB,EAAI,IAAMyB,EAAEzB,EAAI,GAAKyB,EAAEzB,GAAK,IAAa,GAAPyB,EAAEzB,EAE7CyB,EAAEG,EAAE,GAAK,GAAK8J,GAAUjK,EAAEG,EAAE,IAAM,KAElCH,EAAEG,EAAE,GAAK,MAAQ8J,GAAUjK,EAAEG,EAAE,IAAM,YASvC,OANAE,EAAIL,EAAEzL,EAAI,GAAKqM,EAAMpB,IAAM,EAAI,EAG3BQ,EAAEzB,GAAK,IAAG8B,EAAI,EAAIA,GAGf,IAAI5B,EAAUyL,EAAS,EAAI7J,EAAIA,GAE7BwC,IAKTxC,EAAI1B,EAASkE,EAAgB3D,EAAW,GACzC,CAcD,IAZI+K,GACFF,EAAO,IAAItL,EAAU,IACjByL,IAAQ1K,EAAEjL,EAAI,GAClB4V,EAASvJ,EAAMpB,IAGf2K,GADAlV,EAAIb,KAAKoV,KAAKrH,EAAQ3C,KACT,EAGfS,EAAI,IAAIxB,EAAU2D,KAGR,CAER,GAAI+H,EAAQ,CAEV,KADAlK,EAAIA,EAAEqK,MAAMtK,IACLG,EAAG,MAENE,EACEJ,EAAEE,EAAEjL,OAASmL,IAAGJ,EAAEE,EAAEjL,OAASmL,GACxB2J,IACT/J,EAAIA,EAAEoK,IAAIzC,GAEb,CAED,GAAI3S,EAAG,CAEL,GAAU,KADVA,EAAI4J,EAAU5J,EAAI,IACL,MACbkV,EAASlV,EAAI,CACvB,MAIU,GAFA+O,EADAxE,EAAIA,EAAE8K,MAAMP,GACHvK,EAAEjB,EAAI,EAAG,GAEdiB,EAAEjB,EAAI,GACR4L,EAASvJ,EAAMpB,OACV,CAEL,GAAU,KADVvK,GAAKkN,EAAQ3C,IACA,MACb2K,EAASlV,EAAI,CACd,CAGH+K,EAAIA,EAAEsK,MAAMtK,GAERK,EACEL,EAAEG,GAAKH,EAAEG,EAAEjL,OAASmL,IAAGL,EAAEG,EAAEjL,OAASmL,GAC/B2J,IACThK,EAAIA,EAAEqK,IAAIzC,GAEb,CAED,OAAIoC,EAAiB/J,GACjBiK,IAAQjK,EAAImC,EAAIf,IAAIpB,IAEjB2H,EAAI3H,EAAEoK,IAAIzC,GAAKvH,EAAI2D,EAAM/D,EAAG4C,EAAeP,EAnHxBiG,WAmH+CtI,EAC/E,EAWI8B,EAAEwI,aAAe,SAAUnG,GACzB,IAAI5E,EAAI,IAAIf,EAAUkF,MAGtB,OAFU,MAANS,EAAYA,EAAK9B,EAChB/B,EAAS6D,EAAI,EAAG,GACdJ,EAAMxE,EAAGA,EAAEjB,EAAI,EAAG6F,EAC/B,EAOIrC,EAAEyI,UAAYzI,EAAE0I,GAAK,SAAUxK,EAAGnN,GAChC,OAA8C,IAAvCiN,EAAQ4D,KAAM,IAAIlF,EAAUwB,EAAGnN,GAC5C,EAMIiP,EAAE2I,SAAW,WACX,QAAS/G,KAAKxD,CACpB,EAOI4B,EAAE4I,cAAgB5I,EAAE6I,GAAK,SAAU3K,EAAGnN,GACpC,OAAOiN,EAAQ4D,KAAM,IAAIlF,EAAUwB,EAAGnN,IAAM,CAClD,EAOIiP,EAAE8I,uBAAyB9I,EAAE+I,IAAM,SAAU7K,EAAGnN,GAC9C,OAAoD,KAA5CA,EAAIiN,EAAQ4D,KAAM,IAAIlF,EAAUwB,EAAGnN,MAAoB,IAANA,CAE/D,EAMIiP,EAAEqI,UAAY,WACZ,QAASzG,KAAKxD,GAAKZ,EAASoE,KAAKpF,EAAIW,GAAYyE,KAAKxD,EAAEjL,OAAS,CACvE,EAOI6M,EAAEgJ,WAAahJ,EAAEiJ,GAAK,SAAU/K,EAAGnN,GACjC,OAAOiN,EAAQ4D,KAAM,IAAIlF,EAAUwB,EAAGnN,IAAM,CAClD,EAOIiP,EAAEkJ,oBAAsBlJ,EAAEmJ,IAAM,SAAUjL,EAAGnN,GAC3C,OAAqD,KAA7CA,EAAIiN,EAAQ4D,KAAM,IAAIlF,EAAUwB,EAAGnN,MAAqB,IAANA,CAChE,EAMIiP,EAAEjN,MAAQ,WACR,OAAQ6O,KAAKpP,CACnB,EAMIwN,EAAEoJ,WAAa,WACb,OAAOxH,KAAKpP,EAAI,CACtB,EAMIwN,EAAEqJ,WAAa,WACb,OAAOzH,KAAKpP,EAAI,CACtB,EAMIwN,EAAEsJ,OAAS,WACT,QAAS1H,KAAKxD,GAAkB,GAAbwD,KAAKxD,EAAE,EAChC,EAuBI4B,EAAEuJ,MAAQ,SAAUrL,EAAGnN,GACrB,IAAImC,EAAG2K,EAAG2L,EAAGC,EACXxL,EAAI2D,KACJjE,EAAIM,EAAEzL,EAMR,GAHAzB,GADAmN,EAAI,IAAIxB,EAAUwB,EAAGnN,IACfyB,GAGDmL,IAAM5M,EAAG,OAAO,IAAI2L,EAAU2K,KAGnC,GAAI1J,GAAK5M,EAEP,OADAmN,EAAE1L,GAAKzB,EACAkN,EAAEkH,KAAKjH,GAGhB,IAAIwL,EAAKzL,EAAEzB,EAAIW,EACbwM,EAAKzL,EAAE1B,EAAIW,EACXgB,EAAKF,EAAEG,EACPC,EAAKH,EAAEE,EAET,IAAKsL,IAAOC,EAAI,CAGd,IAAKxL,IAAOE,EAAI,OAAOF,GAAMD,EAAE1L,GAAKzB,EAAGmN,GAAK,IAAIxB,EAAU2B,EAAKJ,EAAIoJ,KAGnE,IAAKlJ,EAAG,KAAOE,EAAG,GAGhB,OAAOA,EAAG,IAAMH,EAAE1L,GAAKzB,EAAGmN,GAAK,IAAIxB,EAAUyB,EAAG,GAAKF,EAGnC,GAAjBsC,GAAsB,EAAI,EAE9B,CAOD,GALAmJ,EAAKlM,EAASkM,GACdC,EAAKnM,EAASmM,GACdxL,EAAKA,EAAG5E,QAGJoE,EAAI+L,EAAKC,EAAI,CAaf,KAXIF,EAAO9L,EAAI,IACbA,GAAKA,EACL6L,EAAIrL,IAEJwL,EAAKD,EACLF,EAAInL,GAGNmL,EAAEzV,UAGGhD,EAAI4M,EAAG5M,IAAKyY,EAAEjR,KAAK,IACxBiR,EAAEzV,SACV,MAKQ,IAFA8J,GAAK4L,GAAQ9L,EAAIQ,EAAGhL,SAAWpC,EAAIsN,EAAGlL,SAAWwK,EAAI5M,EAEhD4M,EAAI5M,EAAI,EAAGA,EAAI8M,EAAG9M,IAErB,GAAIoN,EAAGpN,IAAMsN,EAAGtN,GAAI,CAClB0Y,EAAOtL,EAAGpN,GAAKsN,EAAGtN,GAClB,KACD,CAgBL,GAXI0Y,IACFD,EAAIrL,EACJA,EAAKE,EACLA,EAAKmL,EACLtL,EAAE1L,GAAK0L,EAAE1L,IAGXzB,GAAK8M,EAAIQ,EAAGlL,SAAWD,EAAIiL,EAAGhL,SAItB,EAAG,KAAOpC,IAAKoN,EAAGjL,KAAO,GAIjC,IAHAnC,EAAImM,EAAO,EAGJW,EAAIF,GAAI,CAEb,GAAIQ,IAAKN,GAAKQ,EAAGR,GAAI,CACnB,IAAK3K,EAAI2K,EAAG3K,IAAMiL,IAAKjL,GAAIiL,EAAGjL,GAAKnC,KACjCoN,EAAGjL,GACLiL,EAAGN,IAAMX,CACV,CAEDiB,EAAGN,IAAMQ,EAAGR,EACb,CAGD,KAAgB,GAATM,EAAG,GAASA,EAAG8G,OAAO,EAAG,KAAM0E,GAGtC,OAAKxL,EAAG,GAWDwE,EAAUzE,EAAGC,EAAIwL,IAPtBzL,EAAE1L,EAAqB,GAAjB+N,GAAsB,EAAI,EAChCrC,EAAEE,EAAI,CAACF,EAAE1B,EAAI,GACN0B,EAMf,EAwBI8B,EAAE4J,OAAS5J,EAAEsI,IAAM,SAAUpK,EAAGnN,GAC9B,IAAI4V,EAAGnU,EACLyL,EAAI2D,KAKN,OAHA1D,EAAI,IAAIxB,EAAUwB,EAAGnN,IAGhBkN,EAAEG,IAAMF,EAAE1L,GAAK0L,EAAEE,IAAMF,EAAEE,EAAE,GACvB,IAAI1B,EAAU2K,MAGXnJ,EAAEE,GAAKH,EAAEG,IAAMH,EAAEG,EAAE,GACtB,IAAI1B,EAAUuB,IAGJ,GAAf4C,GAIFrO,EAAI0L,EAAE1L,EACN0L,EAAE1L,EAAI,EACNmU,EAAIrH,EAAIrB,EAAGC,EAAG,EAAG,GACjBA,EAAE1L,EAAIA,EACNmU,EAAEnU,GAAKA,GAEPmU,EAAIrH,EAAIrB,EAAGC,EAAG,EAAG2C,IAGnB3C,EAAID,EAAEsL,MAAM5C,EAAE4B,MAAMrK,KAGbE,EAAE,IAAqB,GAAfyC,IAAkB3C,EAAE1L,EAAIyL,EAAEzL,GAElC0L,EACb,EAuBI8B,EAAE6J,aAAe7J,EAAEuI,MAAQ,SAAUrK,EAAGnN,GACtC,IAAIqN,EAAG5B,EAAGtJ,EAAG2K,EAAGS,EAAGuH,EAAGiE,EAAK/D,EAAKC,EAAK+D,EAAKC,EAAKC,EAAKC,EAClDvU,EAAMwU,EACNlM,EAAI2D,KACJzD,EAAKF,EAAEG,EACPC,GAAMH,EAAI,IAAIxB,EAAUwB,EAAGnN,IAAIqN,EAGjC,KAAKD,GAAOE,GAAOF,EAAG,IAAOE,EAAG,IAmB9B,OAhBKJ,EAAEzL,IAAM0L,EAAE1L,GAAK2L,IAAOA,EAAG,KAAOE,GAAMA,IAAOA,EAAG,KAAOF,EAC1DD,EAAEE,EAAIF,EAAE1B,EAAI0B,EAAE1L,EAAI,MAElB0L,EAAE1L,GAAKyL,EAAEzL,EAGJ2L,GAAOE,GAKVH,EAAEE,EAAI,CAAC,GACPF,EAAE1B,EAAI,GALN0B,EAAEE,EAAIF,EAAE1B,EAAI,MAST0B,EAmBT,IAhBA1B,EAAIgB,EAASS,EAAEzB,EAAIW,GAAYK,EAASU,EAAE1B,EAAIW,GAC9Ce,EAAE1L,GAAKyL,EAAEzL,GACTsX,EAAM3L,EAAGhL,SACT4W,EAAM1L,EAAGlL,UAIP+W,EAAK/L,EACLA,EAAKE,EACLA,EAAK6L,EACLhX,EAAI4W,EACJA,EAAMC,EACNA,EAAM7W,GAIHA,EAAI4W,EAAMC,EAAKG,EAAK,GAAIhX,IAAKgX,EAAG3R,KAAK,IAK1C,IAHA5C,EAAOuH,EACPiN,EAAW7M,EAENpK,EAAI6W,IAAO7W,GAAK,GAAI,CAKvB,IAJAkL,EAAI,EACJ4L,EAAM3L,EAAGnL,GAAKiX,EACdF,EAAM5L,EAAGnL,GAAKiX,EAAW,EAEXtM,EAAI3K,GAAboL,EAAIwL,GAAgBjM,EAAI3K,GAK3BkL,IADA2H,EAAMiE,GAHNjE,EAAM5H,IAAKG,GAAK6L,IAEhBtE,EAAIoE,EAAMlE,GADVC,EAAM7H,EAAGG,GAAK6L,EAAW,GACHH,GACEG,EAAYA,EAAYD,EAAGrM,GAAKO,GAC7CzI,EAAO,IAAMkQ,EAAIsE,EAAW,GAAKF,EAAMjE,EAClDkE,EAAGrM,KAAOkI,EAAMpQ,EAGlBuU,EAAGrM,GAAKO,CACT,CAQD,OANIA,IACA5B,EAEF0N,EAAGjF,OAAO,EAAG,GAGRtC,EAAUzE,EAAGgM,EAAI1N,EAC9B,EAOIwD,EAAEoK,QAAU,WACV,IAAInM,EAAI,IAAIvB,EAAUkF,MAEtB,OADA3D,EAAEzL,GAAKyL,EAAEzL,GAAK,KACPyL,CACb,EAuBI+B,EAAEmF,KAAO,SAAUjH,EAAGnN,GACpB,IAAIyY,EACFvL,EAAI2D,KACJjE,EAAIM,EAAEzL,EAMR,GAHAzB,GADAmN,EAAI,IAAIxB,EAAUwB,EAAGnN,IACfyB,GAGDmL,IAAM5M,EAAG,OAAO,IAAI2L,EAAU2K,KAGlC,GAAI1J,GAAK5M,EAER,OADAmN,EAAE1L,GAAKzB,EACAkN,EAAEsL,MAAMrL,GAGjB,IAAIwL,EAAKzL,EAAEzB,EAAIW,EACbwM,EAAKzL,EAAE1B,EAAIW,EACXgB,EAAKF,EAAEG,EACPC,EAAKH,EAAEE,EAET,IAAKsL,IAAOC,EAAI,CAGd,IAAKxL,IAAOE,EAAI,OAAO,IAAI3B,EAAUiB,EAAI,GAIzC,IAAKQ,EAAG,KAAOE,EAAG,GAAI,OAAOA,EAAG,GAAKH,EAAI,IAAIxB,EAAUyB,EAAG,GAAKF,EAAQ,EAAJN,EACpE,CAOD,GALA+L,EAAKlM,EAASkM,GACdC,EAAKnM,EAASmM,GACdxL,EAAKA,EAAG5E,QAGJoE,EAAI+L,EAAKC,EAAI,CAUf,IATIhM,EAAI,GACNgM,EAAKD,EACLF,EAAInL,IAEJV,GAAKA,EACL6L,EAAIrL,GAGNqL,EAAEzV,UACK4J,IAAK6L,EAAEjR,KAAK,IACnBiR,EAAEzV,SACH,CAcD,KAZA4J,EAAIQ,EAAGhL,SACPpC,EAAIsN,EAAGlL,QAGK,IACVqW,EAAInL,EACJA,EAAKF,EACLA,EAAKqL,EACLzY,EAAI4M,GAIDA,EAAI,EAAG5M,GACV4M,GAAKQ,IAAKpN,GAAKoN,EAAGpN,GAAKsN,EAAGtN,GAAK4M,GAAKT,EAAO,EAC3CiB,EAAGpN,GAAKmM,IAASiB,EAAGpN,GAAK,EAAIoN,EAAGpN,GAAKmM,EAUvC,OAPIS,IACFQ,EAAK,CAACR,GAAGgI,OAAOxH,KACdwL,GAKGhH,EAAUzE,EAAGC,EAAIwL,EAC9B,EAkBI3J,EAAEqK,UAAYrK,EAAE6C,GAAK,SAAUA,EAAIR,GACjC,IAAIjE,EAAGX,EAAG+D,EACRvD,EAAI2D,KAEN,GAAU,MAANiB,GAAcA,MAASA,EAKzB,OAJArE,EAASqE,EAAI,EAAGtF,GACN,MAAN8E,EAAYA,EAAK9B,EAChB/B,EAAS6D,EAAI,EAAG,GAEdJ,EAAM,IAAIvF,EAAUuB,GAAI4E,EAAIR,GAGrC,KAAMjE,EAAIH,EAAEG,GAAI,OAAO,KAIvB,GAFAX,GADA+D,EAAIpD,EAAEjL,OAAS,GACPgK,EAAW,EAEfqE,EAAIpD,EAAEoD,GAAI,CAGZ,KAAOA,EAAI,IAAM,EAAGA,GAAK,GAAI/D,KAG7B,IAAK+D,EAAIpD,EAAE,GAAIoD,GAAK,GAAIA,GAAK,GAAI/D,KAClC,CAID,OAFIoF,GAAM5E,EAAEzB,EAAI,EAAIiB,IAAGA,EAAIQ,EAAEzB,EAAI,GAE1BiB,CACb,EAWIuC,EAAEsK,UAAY,SAAUhM,GAEtB,OADAE,EAASF,GAAG,iBAAmBlB,GACxBwE,KAAK2G,MAAM,KAAOjK,EAC/B,EAcI0B,EAAEuK,WAAavK,EAAEwK,KAAO,WACtB,IAAI3E,EAAGpI,EAAGK,EAAG2M,EAAKjB,EAChBvL,EAAI2D,KACJxD,EAAIH,EAAEG,EACN5L,EAAIyL,EAAEzL,EACNgK,EAAIyB,EAAEzB,EACNqI,EAAKvE,EAAiB,EACtB0H,EAAO,IAAItL,EAAU,OAGvB,GAAU,IAANlK,IAAY4L,IAAMA,EAAE,GACtB,OAAO,IAAI1B,GAAWlK,GAAKA,EAAI,KAAO4L,GAAKA,EAAE,IAAMiJ,IAAMjJ,EAAIH,EAAI,KA8BnE,GAtBS,IAJTzL,EAAIH,KAAKmY,MAAMpK,EAAQnC,MAITzL,GAAK,OACjBiL,EAAIC,EAAcU,IACXjL,OAASqJ,GAAK,GAAK,IAAGiB,GAAK,KAClCjL,EAAIH,KAAKmY,MAAM/M,GACfjB,EAAIgB,GAAUhB,EAAI,GAAK,IAAMA,EAAI,GAAKA,EAAI,GAS1CsB,EAAI,IAAIpB,EANNe,EADEjL,GAAK,IACH,KAAOgK,GAEXiB,EAAIjL,EAAEsM,iBACAvF,MAAM,EAAGkE,EAAE5I,QAAQ,KAAO,GAAK2H,IAKvCsB,EAAI,IAAIpB,EAAUlK,EAAI,IAOpBsL,EAAEM,EAAE,GAMN,KAJA5L,GADAgK,EAAIsB,EAAEtB,GACEqI,GACA,IAAGrS,EAAI,KAOb,GAHAgX,EAAI1L,EACJA,EAAIkK,EAAKO,MAAMiB,EAAErE,KAAK7F,EAAIrB,EAAGuL,EAAG3E,EAAI,KAEhCnH,EAAc8L,EAAEpL,GAAG7E,MAAM,EAAG/G,MAAQiL,EAAIC,EAAcI,EAAEM,IAAI7E,MAAM,EAAG/G,GAAI,CAW3E,GANIsL,EAAEtB,EAAIA,KAAKhK,EAMN,SALTiL,EAAIA,EAAElE,MAAM/G,EAAI,EAAGA,EAAI,MAKHiY,GAAY,QAALhN,GAgBpB,EAICA,KAAOA,EAAElE,MAAM,IAAqB,KAAfkE,EAAEuB,OAAO,MAGlCiD,EAAMnE,EAAGA,EAAEtB,EAAI8D,EAAiB,EAAG,GACnCuF,GAAK/H,EAAEyK,MAAMzK,GAAG4K,GAAGzK,IAGrB,KACD,CAxBC,IAAKwM,IACHxI,EAAMuH,EAAGA,EAAEhN,EAAI8D,EAAiB,EAAG,GAE/BkJ,EAAEjB,MAAMiB,GAAGd,GAAGzK,IAAI,CACpBH,EAAI0L,EACJ,KACD,CAGH3E,GAAM,EACNrS,GAAK,EACLiY,EAAM,CAcT,CAIL,OAAOxI,EAAMnE,EAAGA,EAAEtB,EAAI8D,EAAiB,EAAGC,EAAesF,EAC/D,EAYI7F,EAAElB,cAAgB,SAAU+F,EAAIxC,GAK9B,OAJU,MAANwC,IACFrG,EAASqG,EAAI,EAAGtH,GAChBsH,KAEK/R,EAAO8O,KAAMiD,EAAIxC,EAAI,EAClC,EAeIrC,EAAE0K,QAAU,SAAU7F,EAAIxC,GAKxB,OAJU,MAANwC,IACFrG,EAASqG,EAAI,EAAGtH,GAChBsH,EAAKA,EAAKjD,KAAKpF,EAAI,GAEd1J,EAAO8O,KAAMiD,EAAIxC,EAC9B,EA4BIrC,EAAE2K,SAAW,SAAU9F,EAAIxC,EAAIvP,GAC7B,IAAIiM,EACFd,EAAI2D,KAEN,GAAc,MAAV9O,EACQ,MAAN+R,GAAcxC,GAAmB,iBAANA,GAC7BvP,EAASuP,EACTA,EAAK,MACIwC,GAAmB,iBAANA,GACtB/R,EAAS+R,EACTA,EAAKxC,EAAK,MAEVvP,EAASiO,OAEN,GAAqB,iBAAVjO,EAChB,MAAM8I,MACHoB,EAAiB,2BAA6BlK,GAKnD,GAFAiM,EAAMd,EAAEyM,QAAQ7F,EAAIxC,GAEhBpE,EAAEG,EAAG,CACP,IAAIlL,EACFsS,EAAMzG,EAAIhK,MAAM,KAChB6V,GAAM9X,EAAOkO,UACb6J,GAAM/X,EAAOmO,mBACbC,EAAiBpO,EAAOoO,gBAAkB,GAC1C4J,EAAUtF,EAAI,GACduF,EAAevF,EAAI,GACnBwF,EAAQ/M,EAAEzL,EAAI,EACdyY,EAAYD,EAAQF,EAAQvR,MAAM,GAAKuR,EACvC5L,EAAM+L,EAAU9X,OASlB,GAPI0X,IACF3X,EAAI0X,EACJA,EAAKC,EACLA,EAAK3X,EACLgM,GAAOhM,GAGL0X,EAAK,GAAK1L,EAAM,EAAG,CAGrB,IAFAhM,EAAIgM,EAAM0L,GAAMA,EAChBE,EAAUG,EAAUC,OAAO,EAAGhY,GACvBA,EAAIgM,EAAKhM,GAAK0X,EAAIE,GAAW5J,EAAiB+J,EAAUC,OAAOhY,EAAG0X,GACrEC,EAAK,IAAGC,GAAW5J,EAAiB+J,EAAU1R,MAAMrG,IACpD8X,IAAOF,EAAU,IAAMA,EAC5B,CAED/L,EAAMgM,EACHD,GAAWhY,EAAOqO,kBAAoB,MAAQ0J,GAAM/X,EAAOsO,mBAC1D2J,EAAatY,QAAQ,IAAIY,OAAO,OAASwX,EAAK,OAAQ,KACvD,MAAQ/X,EAAOuO,wBAA0B,KACxC0J,GACDD,CACJ,CAED,OAAQhY,EAAOkD,QAAU,IAAM+I,GAAOjM,EAAOM,QAAU,GAC7D,EAcI4M,EAAEmL,WAAa,SAAUC,GACvB,IAAItI,EAAGuI,EAAIC,EAAIC,EAAI/O,EAAGgP,EAAK/N,EAAGgO,EAAIC,EAAI/E,EAAG7I,EAAGtL,EAC1CyL,EAAI2D,KACJzD,EAAKF,EAAEG,EAET,GAAU,MAANgN,MACF3N,EAAI,IAAIf,EAAU0O,IAGX/C,cAAgB5K,EAAEW,GAAa,IAARX,EAAEjL,IAAYiL,EAAEwL,GAAG5I,IAC/C,MAAMzE,MACHoB,EAAiB,aACfS,EAAE4K,YAAc,iBAAmB,oBAAsBjI,EAAQ3C,IAI1E,IAAKU,EAAI,OAAO,IAAIzB,EAAUuB,GAoB9B,IAlBA6E,EAAI,IAAIpG,EAAU2D,GAClBqL,EAAKL,EAAK,IAAI3O,EAAU2D,GACxBiL,EAAKG,EAAK,IAAI/O,EAAU2D,GACxB7N,EAAIkL,EAAcS,GAIlB3B,EAAIsG,EAAEtG,EAAIhK,EAAEW,OAAS8K,EAAEzB,EAAI,EAC3BsG,EAAE1E,EAAE,GAAKf,GAAUmO,EAAMhP,EAAIW,GAAY,EAAIA,EAAWqO,EAAMA,GAC9DJ,GAAMA,GAAM3N,EAAEiK,WAAW5E,GAAK,EAAKtG,EAAI,EAAIsG,EAAI4I,EAAMjO,EAErD+N,EAAM7K,EACNA,EAAU,IACVlD,EAAI,IAAIf,EAAUlK,GAGlBiZ,EAAGrN,EAAE,GAAK,EAGRuI,EAAIrH,EAAI7B,EAAGqF,EAAG,EAAG,GAEQ,IADzByI,EAAKF,EAAGlG,KAAKwB,EAAE4B,MAAM+C,KACd5D,WAAW0D,IAClBC,EAAKC,EACLA,EAAKC,EACLG,EAAKD,EAAGtG,KAAKwB,EAAE4B,MAAMgD,EAAKG,IAC1BD,EAAKF,EACLzI,EAAIrF,EAAE8L,MAAM5C,EAAE4B,MAAMgD,EAAKzI,IACzBrF,EAAI8N,EAeN,OAZAA,EAAKjM,EAAI8L,EAAG7B,MAAM8B,GAAKC,EAAI,EAAG,GAC9BG,EAAKA,EAAGtG,KAAKoG,EAAGhD,MAAMmD,IACtBL,EAAKA,EAAGlG,KAAKoG,EAAGhD,MAAM+C,IACtBG,EAAGjZ,EAAIkZ,EAAGlZ,EAAIyL,EAAEzL,EAIhBsL,EAAIwB,EAAIoM,EAAIJ,EAHZ9O,GAAQ,EAGW+D,GAAegJ,MAAMtL,GAAGwJ,MAAMC,WAC7CpI,EAAImM,EAAIJ,EAAI7O,EAAG+D,GAAegJ,MAAMtL,GAAGwJ,OAAS,EAAI,CAACiE,EAAIJ,GAAM,CAACG,EAAIJ,GAExE1K,EAAU6K,EAEH1N,CACb,EAMIkC,EAAE2L,SAAW,WACX,OAAQvL,EAAQwB,KACtB,EAcI5B,EAAE4L,YAAc,SAAU/I,EAAIR,GAE5B,OADU,MAANQ,GAAYrE,EAASqE,EAAI,EAAGtF,GACzBzK,EAAO8O,KAAMiB,EAAIR,EAAI,EAClC,EAcIrC,EAAEG,SAAW,SAAUpP,GACrB,IAAIgO,EACFtB,EAAImE,KACJpP,EAAIiL,EAAEjL,EACNgK,EAAIiB,EAAEjB,EA0BR,OAvBU,OAANA,EACEhK,GACFuM,EAAM,WACFvM,EAAI,IAAGuM,EAAM,IAAMA,IAEvBA,EAAM,OAGC,MAALhO,EACFgO,EAAMvC,GAAKgE,GAAchE,GAAKiE,EAC3B3B,EAAcpB,EAAcD,EAAEW,GAAI5B,GAClCyC,EAAavB,EAAcD,EAAEW,GAAI5B,EAAG,KACxB,KAANzL,GAAYwQ,EAErBxC,EAAME,EAAavB,GADnBD,EAAIwE,EAAM,IAAIvF,EAAUe,GAAI6C,EAAiB9D,EAAI,EAAG+D,IACjBnC,GAAIX,EAAEjB,EAAG,MAE5CgC,EAASzN,EAAG,EAAGuQ,EAASnO,OAAQ,QAChC4L,EAAMQ,EAAYN,EAAavB,EAAcD,EAAEW,GAAI5B,EAAG,KAAM,GAAIzL,EAAGyB,GAAG,IAGpEA,EAAI,GAAKiL,EAAEW,EAAE,KAAIW,EAAM,IAAMA,IAG5BA,CACb,EAOIiB,EAAEI,QAAUJ,EAAE6L,OAAS,WACrB,OAAOzL,EAAQwB,KACrB,EAGI5B,EAAE6B,cAAe,EAEG,MAAhBxC,GAAsB3C,EAAUoH,IAAIzE,GAEjC3C,CACR,CAqIW0C,GACZ1C,EAAmB,QAAIA,EAAUA,UAAYA,EAOFoP,EAAOC,QAChDD,EAAAC,QAAiBrP,GAIZD,IACHA,EAA8B,oBAARuP,MAAuBA,KAAOA,KAAOC,QAG7DxP,EAAaC,UAAYA,EAE5B,CAz2FA,CAy2FEkF;;;;;;;;;;;;;;;;;;;;;ICn1FH,MAAMtN,EAAcC,IACdqE,EAAa0B,IACbpB,EAAUqB,EACVmC,EAAYwP,EAEZC,EAAS,CACXxb,SAAU0B,KAAKC,IAAI,GAAI,IACvB5B,QAAS2B,KAAKC,IAAI,GAAI,GACtB7B,QAAS4B,KAAKC,IAAI,GAAI,GACtB9B,SAAU6B,KAAKC,IAAI,GAAI,IAGrB8Z,EAAiB,CACnB3a,YAAa,EACbsE,eAAgB,EAChBG,cAAc,EACdC,SAAS,EACTpE,UAAW,EACXyE,kBAAkB,EAClBhF,mBAAmB,EACnBZ,gBAAgB,EAChBkG,SAAU,OACVC,WAAW,EACXL,iBAAkBrE,KAAK4P,MACvBrL,4BAA4B,IAG1B3F,eAAEA,EAAcC,gBAAEA,GAAoBoD,EAAY0G,eAElDhK,EAAQ,CACVqb,QAAS,CAAEC,MAAO,KAAMC,SAAUrb,EAAiBsb,OAAQ,MAC3DC,OAAQ,CAAEH,MAAO,KAAMC,SAAUtb,EAAgBub,OAAQ,KACzDlc,QAAS,CAAEgc,MAAO,IAAMC,SAAUrb,EAAiBsb,OAAQ,MAY/D,SAAS1Z,EAAO4Z,EAAUC,EAAiB,CAAA,EAAIrQ,GAO3C,GAN8B,iBAAnBqQ,IACPA,EAAiBzT,EAAQC,YAAYwT,KAG7B/T,EAAWD,eAAegU,GAGlC,MAAO,wBAGX,IAAI3W,EAAS2W,EAAe3W,QAAU,GAClCC,EAAU0W,EAAe1W,SAAW,GAEpCnE,EAcR,SAAsB4a,EAAUC,EAAgBrQ,GAC5C,OAAQqQ,EAAe7a,QACnB,IAAK,WAED,OA0MZ,SAAwB4a,EAAUC,EAAgBlS,GAC9C,MAAMhG,EAAkBgG,EAAMhG,kBAC9B,IAEI0M,EAFAyL,EAAelZ,OAAOoH,OAAO,CAAE,EAAE6R,GACjCE,EAAUnZ,OAAOoH,OAAO,CAAA,EAAIsR,EAAgBQ,GAE5CE,EAAQ,GACR3W,IAAY0W,EAAQpb,eAAiBob,EAAQ3W,cAAgB2W,EAAQ1W,QACrE9E,EAAWub,EAAavW,kBAAoB5B,EAAgBpD,SAC5DD,EAASwb,EAAaha,gBAAkB6B,EAAgBrD,OAC5D,MAAMM,OAA4D,IAAnCmb,EAAQnb,uBACjCmb,EAAQnb,uBAAyBmb,EAAQjc,oBAEbyE,IAA9BuX,EAAaxW,eACbwW,EAAaxW,cAAe,GAG5B1E,IACAob,EAAQ,KAGK,UAAbzb,IACA8P,EAAmB2L,EAAQ1b,EAAS0b,GAGxC,IAAIhb,EAASib,EAAa,CACtBL,WACAC,eAAgBC,EAChBnS,QACA0G,qBAGa,WAAb9P,IAEIS,EADA4a,EAASM,OAAS,GAA0B,SAArBH,EAAQ/V,SACtB,IAAIgW,IAAQ1b,IAASU,EAAOyH,MAAM,KACpCmT,EAASM,OAAS,GAAKH,EAAQ9V,UAC7B,IAAI+V,IAAQ1b,IAASU,EAAOyH,MAAM,KAElCnI,EAAS0b,EAAQhb,GAI7BT,GAAyB,YAAbA,IACbyb,GAASD,EAAQjW,4BAA8BT,EAAU,GAAK2W,EAC9Dhb,EAASA,EAASgb,EAAQ1b,GAG9B,OAAOU,CACX,CAzPmBmb,CAAeP,EADtBC,EAAiBO,EAAgBP,EAAgBrY,EAAY+G,gCACb/G,GAEpD,IAAK,UAED,OA4KZ,SAA0BoY,EAAUC,EAAgBlS,EAAO6B,GACvD,IAAItF,EAAe2V,EAAe3V,aAE9BlF,EAASib,EAAa,CACtBL,SAAUpQ,EAAyB,IAAlBoQ,EAASM,QAC1BL,iBACAlS,UAEAoS,EAAUnZ,OAAOoH,OAAO,CAAA,EAAIsR,EAAgBO,GAEhD,GAAI3V,EACA,MAAO,IAAI6V,EAAQjc,eAAiB,IAAM,KAAKkB,IAGnD,MAAO,GAAGA,IAAS+a,EAAQjc,eAAiB,IAAM,KACtD,CA3LmBuc,CAAiBT,EADxBC,EAAiBO,EAAgBP,EAAgBrY,EAAY8G,kCACX9G,EAAagI,GAEnE,IAAK,OAED,OAiGZ,SAAoBoQ,EAAUC,EAAgBlS,EAAO6B,GACjD,IAAI3G,EAAOgX,EAAehX,MAAQ,SAC9BkX,EAAUnZ,OAAOoH,OAAO,CAAA,EAAIsR,EAAgBO,GAEhD,MAAQ1b,eAAgBmc,EAAqBlc,gBAAiBmc,GAAyB5S,EAAMO,eAO7F,IAAIsS,EALe,CACfjB,QAAS,CAAEC,MAAO,KAAMC,SAAUc,GAAwBnc,EAAiBsb,OAAQ,MACnFC,OAAQ,CAAEH,MAAO,KAAMC,SAAUa,GAAuBnc,EAAgBub,OAAQ,KAChFlc,QAAS,CAAEgc,MAAO,IAAMC,SAAUc,GAAwBnc,EAAiBsb,OAAQ,MAE7D7W,IAEtB1B,MAAEA,EAAKb,OAAEA,GAAWma,EAAmBb,EAASM,OAAQM,EAASf,SAAUe,EAAShB,OAEpFxa,EAASib,EAAa,CACtBL,SAAUpQ,EAAOrI,GACjB0Y,iBACAlS,QACApD,SAAUoD,EAAMU,6BAGpB,MAAO,GAAGrJ,IAAS+a,EAAQjc,eAAiB,IAAM,KAAKwC,GAC3D,CAxHmBoa,CAAWd,EADlBC,EAAiBO,EAAgBP,EAAgBrY,EAAY6G,4BACjB7G,EAAagI,GAC7D,IAAK,OAED,OADAqQ,EAAiBO,EAAgBP,EAAgBrY,EAAYgH,4BAqJzE,SAAoBoR,GAChB,IAAI1X,EAAQ3C,KAAK0K,MAAM2P,EAASM,OAAS,GAAK,IAC1C/X,EAAU5C,KAAK0K,OAAO2P,EAASM,OAAkB,GAARhY,EAAa,IAAO,IAC7DE,EAAU7C,KAAK4P,MAAMyK,EAASM,OAAkB,GAARhY,EAAa,GAAiB,GAAVC,GAChE,MAAO,GAAGD,KAAUC,EAAU,GAAM,IAAM,KAAKA,KAAYC,EAAU,GAAM,IAAM,KAAKA,GAC1F,CAzJmBuY,CAAWf,GACtB,IAAK,UAED,OA6HZ,SAAuBA,EAAUC,EAAgBlS,GAC7C,IAAIiT,EAAYjT,EAAM/F,iBAClBmY,EAAUnZ,OAAOoH,OAAO,CAAA,EAAIsR,EAAgBO,GAE5C7a,EAASib,EAAa,CACtBL,WACAC,iBACAlS,UAEA5J,EAAU6c,EAAUhB,EAASM,QAEjC,MAAO,GAAGlb,IAAS+a,EAAQjc,eAAiB,IAAM,KAAKC,GAC3D,CAzImB8c,CAAcjB,EADrBC,EAAiBO,EAAgBP,EAAgBrY,EAAY4G,+BACd5G,GAEnD,QACI,OAAOyY,EAAa,CAChBL,WACAC,iBACArQ,WAGhB,CAzCiBsR,CAAalB,EAAUC,EAAgBrQ,GAGpD,OAFAxK,EA8mBJ,SAAsBA,EAAQkE,GAC1B,OAAOA,EAASlE,CACpB,CAhnBa+b,CAAa/b,EAAQkE,GAC9BlE,EAwnBJ,SAAuBA,EAAQmE,GAC3B,OAAOnE,EAASmE,CACpB,CA1nBa6X,CAAchc,EAAQmE,GACxBnE,CACX,CAoFA,SAASyb,EAAmBtZ,EAAOsY,EAAUD,GACzC,IAAIlZ,EAASmZ,EAAS,GAClB9E,EAAMpV,KAAKoV,IAAIxT,GAEnB,GAAIwT,GAAO6E,EAAO,CACd,IAAK,IAAIyB,EAAQ,EAAGA,EAAQxB,EAASpZ,SAAU4a,EAAO,CAClD,IAAItP,EAAMpM,KAAKC,IAAIga,EAAOyB,GACtBrP,EAAMrM,KAAKC,IAAIga,EAAOyB,EAAQ,GAElC,GAAItG,GAAOhJ,GAAOgJ,EAAM/I,EAAK,CACzBtL,EAASmZ,EAASwB,GAClB9Z,GAAgBwK,EAChB,KACH,CACJ,CAGGrL,IAAWmZ,EAAS,KACpBtY,GAAgB5B,KAAKC,IAAIga,EAAOC,EAASpZ,OAAS,GAClDC,EAASmZ,EAASA,EAASpZ,OAAS,GAE3C,CAED,MAAO,CAAEc,QAAOb,SACpB,CAgQA,SAAS4a,EAAOld,GACZ,IAAIuI,EAAS,GACb,IAAK,IAAInG,EAAI,EAAGA,EAAIpC,EAAQoC,IACxBmG,GAAU,IAGd,OAAOA,CACX,CAkDA,SAASqR,EAAQzW,EAAOoW,EAAW3T,EAAmBrE,KAAK4P,OACvD,IAAuC,IAAnChO,EAAMkM,WAAWtL,QAAQ,KACzB,OA1CR,SAAsBZ,EAAOoW,GACzB,IAAIhR,EAASpF,EAAMkM,YAEdxK,EAAM6V,GAAOnS,EAAOtE,MAAM,MAE1BgB,EAAgBhE,EAAW,IAAM4D,EAAKZ,MAAM,KAEjD,IAAKyW,EAAM,EACPnS,EAAStD,EAAiBhE,EAAWic,EAAOxC,EAAMzZ,EAASoB,YACxD,CACH,IAAI6C,EAAS,IAGTA,GADCD,EAAiB,EACT,KAAKC,IAEL,IAAIA,IAGjB,IAAI5C,GAAU4a,GAAQxC,EAAM,GAAKnZ,KAAKoV,IAAI1R,GAAkBhE,GAAUmZ,OAAO,EAAGb,GAC5EjX,EAAOD,OAASkX,IAChBjX,GAAU4a,EAAO3D,EAAYjX,EAAOD,SAExCkG,EAASrD,EAAS5C,CACrB,CAMD,OAJKoY,EAAM,GAAKnB,EAAY,IACxBhR,GAAU,IAAI2U,EAAO3D,MAGlBhR,CACX,CAYe4U,CAAaha,EAAOoW,GAI/B,OADU,IAAI3N,EAAUhG,GAAkB,GAAGzC,MAAUoW,KAAgBhY,KAAKC,IAAI,GAAI+X,IAC3EK,QAAQL,EACrB,CA0NA,SAAS0C,GAAaL,SAAEA,EAAQC,eAAEA,EAAclS,MAAEA,EAAQnG,EAAW6M,iBAAEA,EAAgB9J,SAAEA,EAAWoD,EAAMQ,oBACtG,IAAIhH,EAAQyY,EAASM,OAErB,GAAc,IAAV/Y,GAAewG,EAAMiB,gBACrB,OAAOjB,EAAM9F,gBAGjB,IAAKgU,SAAS1U,GACV,OAAOA,EAAMkM,WAGjB,IAAI0M,EAAUnZ,OAAOoH,OAAO,CAAE,EAAEsR,EAAgB/U,EAAUsV,GAEtDlb,EAAcob,EAAQpb,YACtByc,EAA0Bzc,EAAc,EAAIob,EAAQ9W,eACpDY,EAAyBkW,EAAQlW,uBACjCT,EAAe2W,EAAQ3W,aACvBE,EAAeyW,EAAQzW,aACvBD,IAAY1E,KAAiByE,GAAgB2W,EAAQ1W,QAGrDgY,EAAoB1c,GAAe,EAAK0E,QAAuCd,IAA5BsX,EAAe5a,SAAyB,EAAI8a,EAAQ9a,SACvGyE,GAAmB/E,SAA2D4D,IAApCsX,EAAenW,kBAAwD,IAAvB2X,EAA2BtB,EAAQrW,kBAC7HC,EAAeoW,EAAQpW,aACvBjF,EAAoBqb,EAAQrb,kBAC5BZ,EAAiBic,EAAQjc,eACzBkG,EAAW+V,EAAQ/V,SACnBC,EAAY8V,EAAQ9V,UACpBR,EAAcsW,EAAQtW,YACtBG,EAAmBmW,EAAQnW,iBAE3B0X,EAAe,GACnB,GAAIjY,EAAS,CACT,IAAIiC,EAjZZ,UAAwBnE,MAAEA,EAAKiC,aAAEA,EAAYE,aAAEA,GAAe,EAAI7F,cAAEA,EAAaK,eAAEA,GAAiB,EAAKa,YAAEA,EAAc,EAACiF,iBAAEA,EAAmBrE,KAAK4P,QAChJ,IAAImM,EAAe,GACf3G,EAAMpV,KAAKoV,IAAIxT,GACfka,GAAqB,EA+BzB,GA7BIjY,GAAgB3F,EAAc2F,IAAiBiW,EAAOjW,IACtDkY,EAAe7d,EAAc2F,GAC7BjC,GAAgBkY,EAAOjW,IAEnBuR,GAAO0E,EAAOxb,UAAayF,GAA4D,IAA5CM,EAAiB+Q,EAAM0E,EAAOxb,WAEzEyd,EAAe7d,EAAcI,SAC7BsD,GAAgBkY,EAAOxb,UAChB8W,EAAM0E,EAAOxb,UAAY8W,GAAO0E,EAAOzb,SAAY0F,GAA2D,IAA3CM,EAAiB+Q,EAAM0E,EAAOzb,UAExG0d,EAAe7d,EAAcG,QAC7BuD,GAAgBkY,EAAOzb,SAChB+W,EAAM0E,EAAOzb,SAAW+W,GAAO0E,EAAO1b,SAAY2F,GAA2D,IAA3CM,EAAiB+Q,EAAM0E,EAAO1b,UAEvG2d,EAAe7d,EAAcE,QAC7BwD,GAAgBkY,EAAO1b,UAChBgX,EAAM0E,EAAO1b,SAAWgX,GAAO0E,EAAO3b,UAAa4F,GAA4D,IAA5CM,EAAiB+Q,EAAM0E,EAAO3b,aAExG4d,EAAe7d,EAAcC,SAC7ByD,GAAgBkY,EAAO3b,UAM3B4d,IACAA,GAHgBxd,EAAiB,IAAM,IAGRwd,GAG/B3c,EAAa,CACb,IAAI2X,EAAanV,EAAQ,EACrB8B,EAAiB9B,EAAMkM,WAAWpL,MAAM,KAAK,GAE7CsZ,EAAuBjF,EACrBrT,EAAe5C,OAAS,EACxB4C,EAAe5C,OAErBgb,EAAoB9b,KAAKqM,IAAIjN,EAAc4c,EAAsB,EACpE,CAED,MAAO,CAAEpa,QAAOma,eAAcD,oBAClC,CAmWmBG,CAAe,CACtBra,QACAiC,eACAE,eACA7F,cAAekK,EAAM7F,uBACrBhE,iBACA8F,mBACAjF,gBAGJwC,EAAQmE,EAAKnE,MACbma,GAAgBhW,EAAKgW,aAEjB3c,IACA0c,EAAoB/V,EAAK+V,kBAEhC,CAED,GAAI5X,EAAa,CACb,IAAI6B,EA7WZ,UAA4BnE,MAAEA,EAAKia,wBAAEA,IACjC,IAAKK,EAAchY,GAAetC,EAAM6K,gBAAgB/J,MAAM,KAC1DjE,GAAUyd,EAEd,OAAKL,GAOsB,EAEAA,IACvBpd,GAAkBuB,KAAKC,IAAI,GAAI4b,EAHR,GAIvB3X,GAAeA,GAAe2X,EAJP,GAKvB3X,EAAcA,GAAe,EAAI,IAAIA,IAAgBA,GAGlD,CACHtC,MAAOnD,EACPsd,aAAc,IAAI7X,MAhBX,CACHtC,MAAOnD,EACPsd,aAAc,IAAI7X,IAgB9B,CAsVmBiY,CAAmB,CAC1Bva,QACAia,4BAGJja,EAAQmE,EAAKnE,MACbma,EAAehW,EAAKgW,aAAeA,CACtC,CAED,IAAItc,EA3QR,SAA8BA,EAAQmC,EAAOuC,EAAkB6T,EAAWoE,EAAM/X,GAC5E,IAAmB,IAAf2T,EACA,OAAOvY,EAGX,IAAIuH,EAASqR,EAAQzW,EAAOoW,EAAW3T,IAClCgY,EAAuBC,EAAkB,IAAMtV,EAAO8G,WAAWpL,MAAM,KAE5E,GAAI4Z,EAAgBxX,MAAM,UAAYX,GAAoBiY,GACtD,OAAOC,EAGX,IAAIE,EAAoBD,EAAgBxX,MAAM,OAC9C,OAAIsX,GAAQG,EACD,GAAGF,KAAyBC,EAAgBxO,WAAW5G,MAAM,EAAGqV,EAAkBC,SAGtFxV,EAAO8G,UAClB,CAyPiB2O,CAAqB7a,EAAMkM,WAAYlM,EAAOuC,EAAkB2X,EAAmB1X,EAAcC,GAY9G,OAXA5E,EA/OJ,SAAoCA,EAAQmC,EAAO0C,EAAwB0T,GACvE,IAAIhR,EAASvH,GACR4c,EAAuBC,GAAmBtV,EAAO8G,WAAWpL,MAAM,KAEvE,GAAI2Z,EAAsBvX,MAAM,UAAYR,EACxC,OAAKgY,EAIE,GAAGD,EAAsBjc,QAAQ,IAAK,OAAOkc,IAHzCD,EAAsBjc,QAAQ,IAAK,IAMlD,MAAMsc,EAAkB9a,EAAQ,GAA4C,IAAvCya,EAAsB7Z,QAAQ,KAOnE,GANIka,IAEIL,EAAwBA,EAAsBnV,MAAM,GACpDF,EAASA,EAAOE,MAAM,IAG1BmV,EAAsBvb,OAASkX,EAAW,CAC1C,IAAI2E,EAAe3E,EAAYqE,EAAsBvb,OACrD,IAAK,IAAID,EAAI,EAAGA,EAAI8b,EAAc9b,IAC9BmG,EAAS,IAAIA,GAEpB,CAMD,OAJI0V,IAEA1V,EAAS,IAAIA,KAEVA,EAAO8G,UAClB,CAgNa8O,CAA2Bnd,EAAQmC,EAAO0C,EAAwBuX,GAC3Epc,EA7KJ,SAA2BA,EAAQmC,EAAOzC,EAAmBiJ,EAAO0G,GAChE,IAAI/Q,EAAaqK,EAAMjG,oBACnB0a,EAAoB9e,EAAWC,UACnC8Q,EAAmBA,GAAoB/Q,EAAWE,QAClD,IAAI8G,EAAgBhH,EAAWgH,eAAiB,EAE5CiC,EAASvH,EAAOqO,WAChBpK,EAAiBsD,EAAOtE,MAAM,KAAK,GACnChD,EAAWsH,EAAOtE,MAAM,KAAK,GACjC,MAAMga,EAAkB9a,EAAQ,GAAqC,IAAhC8B,EAAelB,QAAQ,KAE5D,GAAIrD,EAAmB,CACfud,IAEAhZ,EAAiBA,EAAewD,MAAM,IAG1C,IAAI4V,EA1CZ,SAA8B1d,EAAauP,GACvC,IAAI3H,EAAS,GACT+V,EAAU,EACd,IAAK,IAAIlc,EAAIzB,EAAayB,EAAI,EAAGA,IACzBkc,IAAYpO,IACZ3H,EAAOgW,QAAQnc,GACfkc,EAAU,GAEdA,IAGJ,OAAO/V,CACX,CA8BgDiW,CAAqBvZ,EAAe5C,OAAQiE,GACpF+X,EAAkCvb,SAAQ,CAACvC,EAAUwd,KACjD9Y,EAAiBA,EAAewD,MAAM,EAAGlI,EAAWwd,GAASK,EAAoBnZ,EAAewD,MAAMlI,EAAWwd,EAAM,IAGvHE,IAEAhZ,EAAiB,IAAIA,IAE5B,CAOD,OAFIsD,EAHCtH,EAGQgE,EAAiBoL,EAAmBpP,EAFpCgE,EAINsD,CACX,CA2IakW,CAAkBzd,EAAQmC,EAAOzC,EAAmBiJ,EAAO0G,IAEhEhL,GAAWI,KACXzE,EArIR,SAA4BA,EAAQsc,GAChC,OAAOtc,EAASsc,CACpB,CAmIiBoB,CAAmB1d,EAAQsc,KAGpCrX,GAAa9C,EAAQ,KACrBnC,EA5HR,SAAoBA,EAAQmC,EAAO6C,GAC/B,OAAc,IAAV7C,EACOnC,EAGK,IAAXA,EACMA,EAAOW,QAAQ,IAAK,IAG3BwB,EAAQ,EACD,IAAInC,IAGE,SAAbgF,EACOhF,EAGJ,IAAIA,EAAOW,QAAQ,IAAK,MACnC,CA0GiBgd,CAAW3d,EAAQmC,EAAO6C,IAGhChF,CACX,CASA,SAASob,EAAgBP,EAAgB+C,GACrC,IAAK/C,EACD,OAAO+C,EAGX,IAAI/b,EAAOD,OAAOC,KAAKgZ,GACvB,OAAoB,IAAhBhZ,EAAKR,QAA4B,WAAZQ,EAAK,GACnB+b,EAGJ/C,CACX;;;;;;;;;;;;;;;;;;;;;;AClyBA,MAAMjQ,EAAYnI,EAgClB,SAASgS,EAAS9I,EAAGkS,EAAOrT,GACxB,IAAIrI,EAAQ,IAAIyI,EAAUe,EAAEuP,QACxB4C,EAAaD,EASjB,OAPIrT,EAAOuT,SAASF,KAChBC,EAAaD,EAAM3C,QAGvB4C,EAAa,IAAIlT,EAAUkT,GAE3BnS,EAAEuP,OAAS/Y,EAAMsV,MAAMqG,GAAYjE,WAC5BlO,CACX;;;;;;;;;;;;;;;;;;;;;;AC5CA,MAEMnJ,EAAcC,IACdub,EAAYxV,IACZyV,EJkBW,CAACzT,IAAY,CAC1BF,oBAAsBC,GAASD,EAAoBC,EAAMC,KInB9C/B,CAAqB+B,GAC9BhH,EAAc4W,IACpB,IAAI8D,EF8xBa,CAAC1T,IAAY,CAC1BxJ,OAAQ,IAAI4P,IAAS5P,KAAU4P,EAAMpG,GACrC2T,YAAa,IAAIvN,IAlqBrB,SAAqBgK,GACjB,IAAItU,EAAOpH,EAAMqb,QACjB,OAAOkB,EAAmBb,EAASM,OAAQ5U,EAAKmU,SAAUnU,EAAKkU,OAAOlZ,MAC1E,CA+pB8B6c,IAAevN,EAAMpG,GAC/C4T,kBAAmB,IAAIxN,IA/qB3B,SAA2BgK,GACvB,IAAItU,EAAOpH,EAAMyb,OACjB,OAAOc,EAAmBb,EAASM,OAAQ5U,EAAKmU,SAAUnU,EAAKkU,OAAOlZ,MAC1E,CA4qBoC8c,IAAqBxN,EAAMpG,GAC3D6T,mBAAoB,IAAIzN,IA5rB5B,SAA4BgK,GACxB,IAAItU,EAAOpH,EAAMV,QACjB,OAAOid,EAAmBb,EAASM,OAAQ5U,EAAKmU,SAAUnU,EAAKkU,OAAOlZ,MAC1E,CAyrBqC+c,IAAsBzN,EAAMpG,GAC7D4Q,oBEnyBYkD,CAAwB9T,GACpC+T,EDqHa/T,KAAW,CACxBgU,IAAK,CAAC7S,EAAGkS,IAnHb,SAAalS,EAAGkS,EAAOrT,GACnB,IAAIrI,EAAQ,IAAIyI,EAAUe,EAAEuP,QACxB4C,EAAaD,EASjB,OAPIrT,EAAOuT,SAASF,KAChBC,EAAaD,EAAM3C,QAGvB4C,EAAa,IAAIlT,EAAUkT,GAE3BnS,EAAEuP,OAAS/Y,EAAMkR,KAAKyK,GAAYjE,WAC3BlO,CACX,CAuGuB6S,CAAI7S,EAAGkS,EAAOrT,GACjCiK,SAAU,CAAC9I,EAAGkS,IAAUpJ,EAAS9I,EAAGkS,EAAOrT,GAC3CsJ,SAAU,CAACnI,EAAGkS,IAzElB,SAAkBlS,EAAGkS,EAAOrT,GACxB,IAAIrI,EAAQ,IAAIyI,EAAUe,EAAEuP,QACxB4C,EAAaD,EASjB,OAPIrT,EAAOuT,SAASF,KAChBC,EAAaD,EAAM3C,QAGvB4C,EAAa,IAAIlT,EAAUkT,GAE3BnS,EAAEuP,OAAS/Y,EAAMsU,MAAMqH,GAAYjE,WAC5BlO,CACX,CA6D4BmI,CAASnI,EAAGkS,EAAOrT,GAC3CiU,OAAQ,CAAC9S,EAAGkS,IApDhB,SAAgBlS,EAAGkS,EAAOrT,GACtB,IAAIrI,EAAQ,IAAIyI,EAAUe,EAAEuP,QACxB4C,EAAaD,EASjB,OAPIrT,EAAOuT,SAASF,KAChBC,EAAaD,EAAM3C,QAGvB4C,EAAa,IAAIlT,EAAUkT,GAE3BnS,EAAEuP,OAAS/Y,EAAM2T,UAAUgI,GAAYjE,WAChClO,CACX,CAwC0B8S,CAAO9S,EAAGkS,EAAOrT,GACvCwH,IAAK,CAACrG,EAAGkS,IA/Bb,SAAclS,EAAGkS,EAAOrT,GACpB,IAAIrI,EAAQ0b,EAOZ,OALIrT,EAAOuT,SAASF,KAChB1b,EAAQ0b,EAAM3C,QAGlBvP,EAAEuP,OAAS/Y,EACJwJ,CACX,CAsBuBqG,CAAIrG,EAAGkS,EAAOrT,GACjCkU,WAAY,CAAC/S,EAAGkS,IAbpB,SAAoBlS,EAAGkS,EAAOrT,GAC1B,IAAI8C,EAAQ9C,EAAOmB,EAAEuP,QAGrB,OAFAzG,EAASnH,EAAOuQ,EAAOrT,GAEhBjK,KAAKoV,IAAIrI,EAAM4N,OAC1B,CAQ8BwD,CAAW/S,EAAGkS,EAAOrT,GAC/CI,UAAWA,IC5HE+T,CAA0BnU,GAC3C,MAAMpD,EAAUwX,EAEhB,MAAMC,EACF,WAAAzQ,CAAYpP,GACR8Q,KAAKoL,OAASlc,CACjB,CAED,KAAAsO,GAAU,OAAO9C,EAAOsF,KAAKoL,OAAU,CAEvC,MAAAla,CAAOA,EAAS,CAAA,GAAM,OAAOkd,EAAUld,OAAO8O,KAAM9O,EAAU,CAE9D,cAAAma,CAAena,GAMX,MALsB,iBAAXA,IACPA,EAASoG,EAAQC,YAAYrG,KAEjCA,EAASkd,EAAU9C,gBAAgBpa,EAAQwB,EAAY+G,iCAChDvJ,OAAS,WACTke,EAAUld,OAAO8O,KAAM9O,EACjC,CAED,UAAA2a,CAAW3a,EAAS,IAEhB,OADAA,EAAOhB,OAAS,OACTke,EAAUld,OAAO8O,KAAM9O,EACjC,CAED,eAAA8d,GAAoB,OAAOZ,EAAUE,kBAAkBtO,KAAM,CAE7D,gBAAAiP,GAAqB,OAAOb,EAAUG,mBAAmBvO,KAAM,CAE/D,SAAAkP,GAAc,OAAOd,EAAUC,YAAYrO,KAAM,CAEjD,UAAA4O,CAAWb,GAAS,OAAOU,EAAWG,WAAW5O,KAAM+N,EAAS,CAEhE,GAAAW,CAAIX,GAAS,OAAOU,EAAWC,IAAI1O,KAAM+N,EAAS,CAElD,QAAApJ,CAASoJ,GAAS,OAAOU,EAAW9J,SAAS3E,KAAM+N,EAAS,CAE5D,QAAA/J,CAAS+J,GAAS,OAAOU,EAAWzK,SAAShE,KAAM+N,EAAS,CAE5D,MAAAY,CAAOZ,GAAS,OAAOU,EAAWE,OAAO3O,KAAM+N,EAAS,CAExD,GAAA7L,CAAInM,GAAS,OAAO0Y,EAAWvM,IAAIlC,KAAMmP,EAAepZ,GAAU,CAElE,KAAA1D,GAAU,OAAO2N,KAAKoL,MAAS,CAE/B,OAAA5M,GAAY,OAAOwB,KAAKoL,MAAS,EASrC,SAAS+D,EAAepZ,GACpB,IAAI0B,EAAS1B,EASb,OARI2E,EAAOuT,SAASlY,GAChB0B,EAAS1B,EAAMqV,OACS,iBAAVrV,EACd0B,EAASiD,EAAOjI,SAASsD,GAClB5E,MAAM4E,KACb0B,EAASgO,KAGNhO,CACX,CAEA,SAASiD,EAAO3E,GACZ,OAAO,IAAIgZ,EAAOI,EAAepZ,GACrC,QAEA2E,EAAO0U,QA/ES,QAiFhB1U,EAAOuT,SAAW,SAASoB,GACvB,OAAOA,aAAkBN,CAC7B,EAMArU,EAAOrD,SAAW3E,EAAYyG,gBAC9BuB,EAAOT,iBAAmBvH,EAAYuH,iBACtCS,EAAOP,YAAczH,EAAYyH,YACjCO,EAAO5B,UAAYpG,EAAYoG,UAC/B4B,EAAOX,aAAerH,EAAYqH,aAClCW,EAAOzJ,WAAayB,EAAYmH,cAChCa,EAAOoT,cAAgBpb,EAAY2G,gBACnCqB,EAAOd,YAAclH,EAAYkH,YACjCc,EAAO4U,sBAAwB5c,EAAY+G,6BAC3CiB,EAAOzD,SAAWiX,EAAUjX,SAC5ByD,EAAOF,oBAAsB2T,EAAO3T,oBACpCE,EAAOjI,SAAWiB,EAAYjB,SAC9BiI,EAAOI,UAAY2T,EAAW3T,YAEbJ","x_google_ignoreList":[6]}