{"version":3,"sources":["node_modules/browser-pack/_prelude.js","node_modules/bignumber.js/bignumber.js","src/en-US.js","src/formatting.js","src/globalState.js","src/loading.js","src/manipulating.js","src/numbro.js","src/parsing.js","src/unformatting.js","src/validating.js"],"names":["f","exports","module","define","amd","window","global","self","this","numbro","r","e","n","t","o","i","c","require","u","a","Error","code","p","call","length","1","globalObject","BigNumber","isNumeric","hasSymbol","Symbol","iterator","mathceil","Math","ceil","mathfloor","floor","bignumberError","tooManyDigits","BASE","LOG_BASE","MAX_SAFE_INTEGER","POWS_TEN","SQRT_BASE","MAX","bitFloor","coeffToString","s","z","j","charCodeAt","slice","compare","x","y","b","xc","yc","k","l","intCheck","min","max","name","String","isOdd","toExponential","str","charAt","toFixedPoint","len","zs","clone","configObject","div","convertBase","parseNumeric","pow2_53","random53bitInt","decimal","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","prefix","groupSize","secondaryGroupSize","groupSeparator","decimalSeparator","fractionGroupSize","fractionGroupSeparator","suffix","ALPHABET","v","alphabet","caseChanged","isNum","_isBigNumber","test","indexOf","replace","search","substring","round","DEBUG","toUpperCase","toLowerCase","push","toBaseOut","baseIn","baseOut","arrL","arr","reverse","multiply","base","m","temp","xlo","xhi","carry","klo","khi","concat","aL","bL","cmp","subtract","splice","format","rm","id","c0","ne","maxOrMin","args","method","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","hasOwnProperty","crypto","getRandomValues","randomBytes","EXPONENTIAL_AT","RANGE","isBigNumber","maximum","arguments","lt","minimum","gt","random","dp","rand","Uint32Array","copy","sum","plus","sign","callerIsToString","pow","more","prod","prodL","q","qc","rem","remL","rem0","xi","xL","yc0","yL","yz","NaN","isNaN","p1","p2","absoluteValue","abs","comparedTo","decimalPlaces","dividedBy","dividedToIntegerBy","idiv","exponentiatedBy","half","isModExp","nIsBig","nIsNeg","nIsOdd","isInteger","mod","times","integerValue","isEqualTo","eq","isFinite","isGreaterThan","isGreaterThanOrEqualTo","gte","isLessThan","isLessThanOrEqualTo","lte","isNegative","isPositive","isZero","minus","xLTy","xe","ye","modulo","multipliedBy","xcL","ycL","ylo","yhi","zc","sqrtBase","negated","precision","shiftedBy","squareRoot","sqrt","rep","toFixed","toFormat","split","g1","g2","intPart","fractionPart","isNeg","intDigits","substr","RegExp","toFraction","md","d0","d1","d2","exp","n0","n1","toNumber","toPrecision","toJSON","toStringTag","for","languageTag","delimiters","thousands","abbreviations","thousand","million","billion","trillion","spaceSeparated","ordinal","number","bytes","binarySuffixes","decimalSuffixes","currency","symbol","position","currencyFormat","thousandSeparated","totalLength","spaceSeparatedCurrency","formats","fourDigits","fullWithTwoDecimals","output","mantissa","fullWithTwoDecimalsNoCurrency","fullWithNoDecimals","globalState","validating","parsing","powers","defaultOptions","characteristic","forceAverage","average","optionalMantissa","negative","forceSign","roundingFunction","spaceSeparatedAbbreviation","currentBytes","general","scale","suffixes","marker","binary","_format","instance","providedFormat","undefined","parseFormat","validateFormat","postfix","formatOrDefault","currentCurrencyDefaultFormat","state","currentCurrency","clonedFormat","Object","assign","options","space","currencyPosition","currencySymbol","lowPrecision","formatNumber","_value","formatCurrency","currentPercentageDefaultFormat","prefixSymbol","formatPercentage","currentByteDefaultFormat","_state$currentBytes","localBinarySuffixes","localDecimalSuffixes","baseInfo","_getFormatByteUnits","getFormatByteUnits","value","defaults","formatByte","currentTimeDefaultFormat","hours","minutes","seconds","formatTime","currentOrdinalDefaultFormat","ordinalFn","currentOrdinal","formatOrdinal","formatNumbro","power","zeroes","result","_result$split2","_slicedToArray","_base$split2","_base$split2$","toFixedLarge","replaceDelimiters","currentDelimiters","thousandSeparator","thousandsSize","hasNegativeSign","counter","unshift","indexesOfGroupSpaces","forEach","index","_ref3","_ref3$state","_ref3$defaults","currentDefaults","hasZeroFormat","getZeroFormat","_ref2","_ref2$characteristicP","characteristicPrecision","_value$toExponential$2","numberString","exponential","optionalCharacteristic","mantissaPrecision","trimMantissa","abbreviation","data","_ref","_ref$lowPrecision","_ref$spaceSeparated","_ref$totalLength","_ref$roundingFunction","characteristicLength","computeAverage","currentAbbreviations","_data","trim","_result$toString$spli2","currentCharacteristic","_result$toString$spli3","currentMantissa","match","hasTrailingZeroes","setMantissaPrecision","_result$toString$spli5","missingZeros","setCharacteristicPrecision","defaultFormat","keys","_len","Array","_key","apply","getByteUnit","_len2","_key2","getBinaryByteUnit","_len3","_key3","getDecimalByteUnit","_len4","_key4","enUS","currentLanguageTag","languages","zeroFormat","globalDefaults","chooseLanguage","tag","currentLanguageData","currentLanguage","ordinalFormat","byteFormat","percentageFormat","timeFormat","setDefaults","setZeroFormat","string","languageData","registerLanguage","useLanguage","validateLanguage","setLanguage","fallbackTag","matchingLanguageTag","find","each","loadLanguagesInNode","tags","console","error","_subtract","other","otherValue","isNumbro","add","divide","difference","validator","loader","unformatter","formatter","manipulate","Numbro","_classCallCheck","input","normalizeInput","unformat","version","object","language","defaultCurrencyFormat","validate","parseOutput","parseOptionalCharacteristic","parseMantissa","allSuffixes","key","factor","escapeRegExp","unformatValue","inputString","computeUnformattedValue","stripped","newInput","possibleOrdinalValue","parseFloat","ordinalString","inversedAbbreviations","abbreviationValues","sort","numberOfAbbreviations","_i","removeFormattingSymbols","segments","matchesTime","bcp47RegExp","validFormat","type","validValues","restriction","message","mandatory","restrictions","children","validLanguage","timeDefaults","validateInput","validateSpec","toValidate","spec","skipMandatoryCheck","results","map","_typeof","_data$restrictions$i","JSON","stringify","_toConsumableArray","reduce","acc","current","validInput","isFormatValid"],"mappings":"CAAA,SAAAA,GAAA,GAAA,iBAAAC,SAAA,oBAAAC,OAAAA,OAAAD,QAAAD,SAAA,GAAA,mBAAAG,QAAAA,OAAAC,IAAAD,OAAA,GAAAH,OAAA,EAAA,oBAAAK,OAAAA,OAAA,oBAAAC,OAAAA,OAAA,oBAAAC,KAAAA,KAAAC,MAAAC,OAAAT,KAAA,CAAA,WAAA,OAAA,SAAAU,EAAAC,EAAAC,EAAAC,GAAA,SAAAC,EAAAC,EAAAf,GAAA,IAAAY,EAAAG,GAAA,CAAA,IAAAJ,EAAAI,GAAA,CAAA,IAAAC,EAAA,mBAAAC,SAAAA,QAAA,IAAAjB,GAAAgB,EAAA,OAAAA,EAAAD,GAAA,GAAA,GAAAG,EAAA,OAAAA,EAAAH,GAAA,GAAA,IAAAI,EAAA,IAAAC,MAAA,uBAAAL,EAAA,KAAA,MAAAI,EAAAE,KAAA,mBAAAF,EAAA,IAAAG,EAAAV,EAAAG,GAAA,CAAAd,QAAA,IAAAU,EAAAI,GAAA,GAAAQ,KAAAD,EAAArB,QAAA,SAAAS,GAAA,OAAAI,EAAAH,EAAAI,GAAA,GAAAL,IAAAA,IAAAY,EAAAA,EAAArB,QAAAS,EAAAC,EAAAC,EAAAC,GAAA,OAAAD,EAAAG,GAAAd,QAAA,IAAA,IAAAiB,EAAA,mBAAAD,SAAAA,QAAAF,EAAA,EAAAA,EAAAF,EAAAW,OAAAT,IAAAD,EAAAD,EAAAE,IAAA,OAAAD,EAAA,CAAA,CAAAW,EAAA,CAAA,SAAAR,EAAAf,EAAAD,ICAA,SAAAyB,GACA,aAkDA,IAAAC,EACAC,EAAA,6CACAC,EAAA,mBAAAC,QAAA,iBAAAA,OAAAC,SAEAC,EAAAC,KAAAC,KACAC,EAAAF,KAAAG,MAEAC,EAAA,qBACAC,EAAAD,EAAA,yDAEAE,EAAA,KACAC,EAAA,GACAC,EAAA,iBAEAC,EAAA,CAAA,EAAA,GAAA,IAAA,IAAA,IAAA,IAAA,IAAA,IAAA,IAAA,IAAA,KAAA,KAAA,KAAA,MACAC,EAAA,IAKAC,EAAA,IAwoFA,SAAAC,EAAAjC,GACA,IAAAG,EAAA,EAAAH,EACA,OAAA,EAAAA,GAAAA,IAAAG,EAAAA,EAAAA,EAAA,EAKA,SAAA+B,EAAA3B,GAMA,IALA,IAAA4B,EAAAC,EACAjC,EAAA,EACAkC,EAAA9B,EAAAK,OACAd,EAAAS,EAAA,GAAA,GAEAJ,EAAAkC,GAAA,CAGA,IAFAF,EAAA5B,EAAAJ,KAAA,GACAiC,EAAAR,EAAAO,EAAAvB,OACAwB,IAAAD,EAAA,IAAAA,GACArC,GAAAqC,EAIA,IAAAE,EAAAvC,EAAAc,OAAA,KAAAd,EAAAwC,aAAAD,KAEA,OAAAvC,EAAAyC,MAAA,EAAAF,EAAA,GAAA,GAKA,SAAAG,EAAAC,EAAAC,GACA,IAAAnC,EAAAoC,EACAC,EAAAH,EAAArC,EACAyC,EAAAH,EAAAtC,EACAD,EAAAsC,EAAAN,EACAE,EAAAK,EAAAP,EACAW,EAAAL,EAAA1C,EACAgD,EAAAL,EAAA3C,EAGA,IAAAI,IAAAkC,EAAA,OAAA,KAMA,GAJA9B,EAAAqC,IAAAA,EAAA,GACAD,EAAAE,IAAAA,EAAA,GAGAtC,GAAAoC,EAAA,OAAApC,EAAAoC,EAAA,GAAAN,EAAAlC,EAGA,GAAAA,GAAAkC,EAAA,OAAAlC,EAMA,GAJAI,EAAAJ,EAAA,EACAwC,EAAAG,GAAAC,GAGAH,IAAAC,EAAA,OAAAF,EAAA,GAAAC,EAAArC,EAAA,GAAA,EAGA,IAAAoC,EAAA,OAAAI,EAAAD,EAAAvC,EAAA,GAAA,EAKA,IAHA8B,GAAAS,EAAAF,EAAAhC,SAAAmC,EAAAF,EAAAjC,QAAAkC,EAAAC,EAGA5C,EAAA,EAAAA,EAAAkC,EAAAlC,IAAA,GAAAyC,EAAAzC,IAAA0C,EAAA1C,GAAA,OAAAyC,EAAAzC,GAAA0C,EAAA1C,GAAAI,EAAA,GAAA,EAGA,OAAAuC,GAAAC,EAAA,EAAAA,EAAAD,EAAAvC,EAAA,GAAA,EAOA,SAAAyC,EAAAhD,EAAAiD,EAAAC,EAAAC,GACA,GAAAnD,EAAAiD,GAAAC,EAAAlD,GAAAA,IAAAuB,EAAAvB,GACA,MAAAQ,MACAiB,GAAA0B,GAAA,aAAA,iBAAAnD,EACAA,EAAAiD,GAAAC,EAAAlD,EAAA,kBAAA,oBACA,6BAAAoD,OAAApD,IAMA,SAAAqD,EAAArD,GACA,IAAA8C,EAAA9C,EAAAI,EAAAQ,OAAA,EACA,OAAAqB,EAAAjC,EAAAD,EAAA6B,IAAAkB,GAAA9C,EAAAI,EAAA0C,GAAA,GAAA,EAIA,SAAAQ,EAAAC,EAAAxD,GACA,OAAA,EAAAwD,EAAA3C,OAAA2C,EAAAC,OAAA,GAAA,IAAAD,EAAAhB,MAAA,GAAAgB,IACAxD,EAAA,EAAA,IAAA,MAAAA,EAIA,SAAA0D,GAAAF,EAAAxD,EAAAqC,GACA,IAAAsB,EAAAC,EAGA,GAAA5D,EAAA,EAAA,CAGA,IAAA4D,EAAAvB,EAAA,MAAArC,EAAA4D,GAAAvB,GACAmB,EAAAI,EAAAJ,OAOA,KAAAxD,GAHA2D,EAAAH,EAAA3C,QAGA,CACA,IAAA+C,EAAAvB,EAAArC,GAAA2D,IAAA3D,EAAA4D,GAAAvB,GACAmB,GAAAI,OACA5D,EAAA2D,IACAH,EAAAA,EAAAhB,MAAA,EAAAxC,GAAA,IAAAwD,EAAAhB,MAAAxC,IAIA,OAAAwD,GAOAxC,EA9vFA,SAAA6C,EAAAC,GACA,IAAAC,EAAAC,EAAAC,EA0kBAC,EAMAC,EAkJAC,EAshBAC,EACAC,EACAC,EACAC,EACAC,EA3vCAC,EAAA1D,EAAA2D,UAAA,CAAAC,YAAA5D,EAAA6D,SAAA,KAAAC,QAAA,MACAC,EAAA,IAAA/D,EAAA,GAUAgE,EAAA,GAaAC,EAAA,EAMAC,GAAA,EAIAC,EAAA,GAMAC,GAAA,IAKAC,EAAA,IAGAC,GAAA,EAkBAC,EAAA,EAIAC,EAAA,EAGAC,EAAA,CACAC,OAAA,GACAC,UAAA,EACAC,mBAAA,EACAC,eAAA,IACAC,iBAAA,IACAC,kBAAA,EACAC,uBAAA,IACAC,OAAA,IAMAC,EAAA,uCAgBA,SAAAlF,EAAAmF,EAAAvD,GACA,IAAAwD,EAAA/F,EAAAgG,EAAArG,EAAAI,EAAAkG,EAAA3C,EAAAH,EACAd,EAAA7C,KAGA,KAAA6C,aAAA1B,GAAA,OAAA,IAAAA,EAAAmF,EAAAvD,GAEA,GAAA,MAAAA,EAAA,CAEA,GAAAuD,IAAA,IAAAA,EAAAI,aAYA,OAXA7D,EAAAN,EAAA+D,EAAA/D,QAEA+D,EAAA9F,GAAA8F,EAAAnG,EAAAqF,EACA3C,EAAArC,EAAAqC,EAAA1C,EAAA,KACAmG,EAAAnG,EAAAoF,EACA1C,EAAArC,EAAA,CAAAqC,EAAA1C,EAAA,IAEA0C,EAAA1C,EAAAmG,EAAAnG,EACA0C,EAAArC,EAAA8F,EAAA9F,EAAAmC,UAMA,IAAA8D,EAAA,iBAAAH,IAAA,EAAAA,GAAA,EAAA,CAMA,GAHAzD,EAAAN,EAAA,EAAA+D,EAAA,GAAAA,GAAAA,GAAA,GAAA,EAGAA,MAAAA,EAAA,CACA,IAAAnG,EAAA,EAAAI,EAAA+F,EAAA,IAAA/F,EAAAA,GAAA,GAAAJ,KASA,YAPAqF,EAAArF,EACA0C,EAAArC,EAAAqC,EAAA1C,EAAA,MAEA0C,EAAA1C,EAAAA,EACA0C,EAAArC,EAAA,CAAA8F,KAMA3C,EAAAH,OAAA8C,OACA,CAEA,IAAAlF,EAAAuF,KAAAhD,EAAAH,OAAA8C,IAAA,OAAAlC,EAAAvB,EAAAc,EAAA8C,GAEA5D,EAAAN,EAAA,IAAAoB,EAAAjB,WAAA,IAAAiB,EAAAA,EAAAhB,MAAA,IAAA,GAAA,GAIA,GAAAxC,EAAAwD,EAAAiD,QAAA,QAAAjD,EAAAA,EAAAkD,QAAA,IAAA,KAGA,GAAAtG,EAAAoD,EAAAmD,OAAA,QAGA3G,EAAA,IAAAA,EAAAI,GACAJ,IAAAwD,EAAAhB,MAAApC,EAAA,GACAoD,EAAAA,EAAAoD,UAAA,EAAAxG,IACAJ,EAAA,IAGAA,EAAAwD,EAAA3C,YAGA,CAOA,GAJAoC,EAAAL,EAAA,EAAAsD,EAAArF,OAAA,QAIA,IAAA+B,EAEA,OAAAiE,EADAnE,EAAA,IAAA1B,EAAAmF,GACAnB,EAAAtC,EAAA1C,EAAA,EAAAiF,GAKA,GAFAzB,EAAAH,OAAA8C,GAEAG,EAAA,iBAAAH,EAAA,CAGA,GAAA,EAAAA,GAAA,EAAA,OAAAlC,EAAAvB,EAAAc,EAAA8C,EAAA1D,GAKA,GAHAF,EAAAN,EAAA,EAAA+D,EAAA,GAAA3C,EAAAA,EAAAhB,MAAA,IAAA,GAAA,EAGAxB,EAAA8F,OAAA,GAAAtD,EAAAkD,QAAA,YAAA,IAAA7F,OACA,MAAAJ,MACAkB,EAAAwE,QAGAzD,EAAAN,EAAA,KAAAoB,EAAAjB,WAAA,IAAAiB,EAAAA,EAAAhB,MAAA,IAAA,GAAA,EAQA,IALA4D,EAAAF,EAAA1D,MAAA,EAAAI,GACA5C,EAAAI,EAAA,EAIAuD,EAAAH,EAAA3C,OAAAT,EAAAuD,EAAAvD,IACA,GAAAgG,EAAAK,QAAApG,EAAAmD,EAAAC,OAAArD,IAAA,EAAA,CACA,GAAA,KAAAC,GAGA,GAAAL,EAAAI,EAAA,CACAJ,EAAA2D,EACA,eAEA,IAAA0C,IAGA7C,GAAAA,EAAAuD,gBAAAvD,EAAAA,EAAAwD,gBACAxD,GAAAA,EAAAwD,gBAAAxD,EAAAA,EAAAuD,gBAAA,CACAV,GAAA,EACAjG,GAAA,EACAJ,EAAA,EACA,SAIA,OAAAiE,EAAAvB,EAAAW,OAAA8C,GAAAG,EAAA1D,GAKA0D,GAAA,GAIA,GAAAtG,GAHAwD,EAAAQ,EAAAR,EAAAZ,EAAA,GAAAF,EAAAN,IAGAqE,QAAA,MAAAjD,EAAAA,EAAAkD,QAAA,IAAA,IACA1G,EAAAwD,EAAA3C,OAIA,IAAAT,EAAA,EAAA,KAAAoD,EAAAjB,WAAAnC,GAAAA,KAGA,IAAAuD,EAAAH,EAAA3C,OAAA,KAAA2C,EAAAjB,aAAAoB,KAEA,GAAAH,EAAAA,EAAAhB,MAAApC,IAAAuD,GAAA,CAIA,GAHAA,GAAAvD,EAGAkG,GAAAtF,EAAA8F,OACA,GAAAnD,IAAA7B,EAAAqE,GAAAA,IAAA3E,EAAA2E,IACA,MAAA1F,MACAkB,EAAAe,EAAAN,EAAA+D,GAIA,IAAAnG,EAAAA,EAAAI,EAAA,GAAAiF,EAGA3C,EAAArC,EAAAqC,EAAA1C,EAAA,UAGA,GAAAA,EAAAoF,EAGA1C,EAAArC,EAAA,CAAAqC,EAAA1C,EAAA,OACA,CAWA,GAVA0C,EAAA1C,EAAAA,EACA0C,EAAArC,EAAA,GAMAD,GAAAJ,EAAA,GAAA6B,EACA7B,EAAA,IAAAI,GAAAyB,GAEAzB,EAAAuD,EAAA,CAGA,IAFAvD,GAAAsC,EAAArC,EAAA4G,MAAAzD,EAAAhB,MAAA,EAAApC,IAEAuD,GAAA9B,EAAAzB,EAAAuD,GACAjB,EAAArC,EAAA4G,MAAAzD,EAAAhB,MAAApC,EAAAA,GAAAyB,IAGAzB,EAAAyB,GAAA2B,EAAAA,EAAAhB,MAAApC,IAAAS,YAEAT,GAAAuD,EAGA,KAAAvD,IAAAoD,GAAA,KACAd,EAAArC,EAAA4G,MAAAzD,SAKAd,EAAArC,EAAA,CAAAqC,EAAA1C,EAAA,GAicA,SAAAkH,EAAA1D,EAAA2D,EAAAC,EAAAhB,GAOA,IANA,IAAA9D,EAEA+E,EADAC,EAAA,CAAA,GAEAlH,EAAA,EACAuD,EAAAH,EAAA3C,OAEAT,EAAAuD,GAAA,CACA,IAAA0D,EAAAC,EAAAzG,OAAAwG,IAAAC,EAAAD,IAAAF,GAIA,IAFAG,EAAA,IAAAlB,EAAAK,QAAAjD,EAAAC,OAAArD,MAEAkC,EAAA,EAAAA,EAAAgF,EAAAzG,OAAAyB,IAEAgF,EAAAhF,GAAA8E,EAAA,IACA,MAAAE,EAAAhF,EAAA,KAAAgF,EAAAhF,EAAA,GAAA,GACAgF,EAAAhF,EAAA,IAAAgF,EAAAhF,GAAA8E,EAAA,EACAE,EAAAhF,IAAA8E,GAKA,OAAAE,EAAAC,UA4HA,SAAAC,EAAA9E,EAAAK,EAAA0E,GACA,IAAAC,EAAAC,EAAAC,EAAAC,EACAC,EAAA,EACA1H,EAAAsC,EAAA7B,OACAkH,EAAAhF,EAAAf,EACAgG,EAAAjF,EAAAf,EAAA,EAEA,IAAAU,EAAAA,EAAAF,QAAApC,KAKA0H,IADAH,EAAAI,GAHAH,EAAAlF,EAAAtC,GAAA4B,IAEA0F,EAAAM,EAAAJ,GADAC,EAAAnF,EAAAtC,GAAA4B,EAAA,GACA+F,GACA/F,EAAAA,EAAA8F,GACAL,EAAA,IAAAC,EAAA1F,EAAA,GAAAgG,EAAAH,EACAnF,EAAAtC,GAAAuH,EAAAF,EAKA,OAFAK,IAAApF,EAAA,CAAAoF,GAAAG,OAAAvF,IAEAA,EAGA,SAAAD,EAAAjC,EAAAoC,EAAAsF,EAAAC,GACA,IAAA/H,EAAAgI,EAEA,GAAAF,GAAAC,EACAC,EAAAD,EAAAD,EAAA,GAAA,OAGA,IAAA9H,EAAAgI,EAAA,EAAAhI,EAAA8H,EAAA9H,IAEA,GAAAI,EAAAJ,IAAAwC,EAAAxC,GAAA,CACAgI,EAAA5H,EAAAJ,GAAAwC,EAAAxC,GAAA,GAAA,EACA,MAKA,OAAAgI,EAGA,SAAAC,EAAA7H,EAAAoC,EAAAsF,EAAAT,GAIA,IAHA,IAAArH,EAAA,EAGA8H,KACA1H,EAAA0H,IAAA9H,EACAA,EAAAI,EAAA0H,GAAAtF,EAAAsF,GAAA,EAAA,EACA1H,EAAA0H,GAAA9H,EAAAqH,EAAAjH,EAAA0H,GAAAtF,EAAAsF,GAIA,MAAA1H,EAAA,IAAA,EAAAA,EAAAK,OAAAL,EAAA8H,OAAA,EAAA,KAsNA,SAAAC,EAAAtI,EAAAG,EAAAoI,EAAAC,GACA,IAAAC,EAAA1I,EAAA2I,EAAAhF,EAAAH,EAKA,GAHA,MAAAgF,EAAAA,EAAAvD,EACAhC,EAAAuF,EAAA,EAAA,IAEAvI,EAAAI,EAAA,OAAAJ,EAAA4E,WAKA,GAHA6D,EAAAzI,EAAAI,EAAA,GACAsI,EAAA1I,EAAAD,EAEA,MAAAI,EACAoD,EAAArB,EAAAlC,EAAAI,GACAmD,EAAA,GAAAiF,GAAA,GAAAA,IAAAE,GAAAzD,GAAAC,GAAAwD,GACApF,EAAAC,EAAAmF,GACAjF,GAAAF,EAAAmF,EAAA,UAeA,GAVA3I,GAHAC,EAAA4G,EAAA,IAAA7F,EAAAf,GAAAG,EAAAoI,IAGAxI,EAGA2D,GADAH,EAAArB,EAAAlC,EAAAI,IACAQ,OAOA,GAAA4H,GAAA,GAAAA,IAAArI,GAAAJ,GAAAA,GAAAkF,GAAA,CAGA,KAAAvB,EAAAvD,EAAAoD,GAAA,IAAAG,KACAH,EAAAD,EAAAC,EAAAxD,QAQA,GAJAI,GAAAuI,EACAnF,EAAAE,GAAAF,EAAAxD,EAAA,KAGA2D,EAAA3D,EAAA,GACA,GAAA,IAAAI,EAAA,IAAAoD,GAAA,IAAApD,IAAAoD,GAAA,WAGA,GAAA,GADApD,GAAAJ,EAAA2D,GAGA,IADA3D,EAAA,GAAA2D,IAAAH,GAAA,KACApD,IAAAoD,GAAA,KAMA,OAAAvD,EAAAmC,EAAA,GAAAsG,EAAA,IAAAlF,EAAAA,EAKA,SAAAoF,EAAAC,EAAAC,GAKA,IAJA,IAAA7I,EACAG,EAAA,EACAsH,EAAA,IAAA1G,EAAA6H,EAAA,IAEAzI,EAAAyI,EAAAhI,OAAAT,IAAA,CAIA,KAHAH,EAAA,IAAAe,EAAA6H,EAAAzI,KAGAgC,EAAA,CACAsF,EAAAzH,EACA,MACA6I,EAAAlI,KAAA8G,EAAAzH,KACAyH,EAAAzH,GAIA,OAAAyH,EAQA,SAAAqB,EAAA9I,EAAAI,EAAAL,GAKA,IAJA,IAAAI,EAAA,EACAkC,EAAAjC,EAAAQ,QAGAR,IAAAiC,GAAAjC,EAAA2I,OAGA,IAAA1G,EAAAjC,EAAA,GAAA,IAAAiC,EAAAA,GAAA,GAAAlC,KAkBA,OAfAJ,EAAAI,EAAAJ,EAAA6B,EAAA,GAAAwD,EAGApF,EAAAI,EAAAJ,EAAAD,EAAA,KAGAA,EAAAoF,EAGAnF,EAAAI,EAAA,CAAAJ,EAAAD,EAAA,IAEAC,EAAAD,EAAAA,EACAC,EAAAI,EAAAA,GAGAJ,EA0DA,SAAA4G,EAAAnE,EAAAuG,EAAAT,EAAAzI,GACA,IAAAmJ,EAAA9I,EAAAkC,EAAAS,EAAA9C,EAAAkJ,EAAAC,EACAvG,EAAAH,EAAArC,EACAgJ,EAAAtH,EAGA,GAAAc,EAAA,CAQAyG,EAAA,CAGA,IAAAJ,EAAA,EAAAnG,EAAAF,EAAA,GAAA,IAAAE,EAAAA,GAAA,GAAAmG,KAIA,IAHA9I,EAAA6I,EAAAC,GAGA,EACA9I,GAAAyB,EACAS,EAAA2G,EAIAG,GAHAnJ,EAAA4C,EAAAsG,EAAA,IAGAE,EAAAH,EAAA5G,EAAA,GAAA,GAAA,OAIA,IAFA6G,EAAA9H,GAAAjB,EAAA,GAAAyB,KAEAgB,EAAAhC,OAAA,CAEA,IAAAd,EASA,MAAAuJ,EANA,KAAAzG,EAAAhC,QAAAsI,EAAAtG,EAAAoE,KAAA,IACAhH,EAAAmJ,EAAA,EAGA9G,GADAlC,GAAAyB,GACAA,GAFAqH,EAAA,OAMA,CAIA,IAHAjJ,EAAA8C,EAAAF,EAAAsG,GAGAD,EAAA,EAAA,IAAAnG,EAAAA,GAAA,GAAAmG,KAUAE,GAHA9G,GAJAlC,GAAAyB,GAIAA,EAAAqH,GAGA,EAAA,EAAAjJ,EAAAoJ,EAAAH,EAAA5G,EAAA,GAAA,GAAA,EAmBA,GAfAvC,EAAAA,GAAAkJ,EAAA,GAKA,MAAApG,EAAAsG,EAAA,KAAA7G,EAAA,EAAArC,EAAAA,EAAAoJ,EAAAH,EAAA5G,EAAA,IAEAvC,EAAAyI,EAAA,GACAY,GAAArJ,KAAA,GAAAyI,GAAAA,IAAA9F,EAAAN,EAAA,EAAA,EAAA,IACA,EAAAgH,GAAA,GAAAA,IAAA,GAAAZ,GAAAzI,GAAA,GAAAyI,IAGA,EAAApI,EAAA,EAAAkC,EAAArC,EAAAoJ,EAAAH,EAAA5G,GAAA,EAAAO,EAAAsG,EAAA,IAAA,GAAA,GACAX,IAAA9F,EAAAN,EAAA,EAAA,EAAA,IAEA6G,EAAA,IAAApG,EAAA,GAiBA,OAhBAA,EAAAhC,OAAA,EAEAd,GAGAkJ,GAAAvG,EAAA1C,EAAA,EAGA6C,EAAA,GAAAwG,GAAAxH,EAAAoH,EAAApH,GAAAA,GACAa,EAAA1C,GAAAiJ,GAAA,GAIApG,EAAA,GAAAH,EAAA1C,EAAA,EAGA0C,EAkBA,GAdA,GAAAtC,GACAyC,EAAAhC,OAAAsI,EACApG,EAAA,EACAoG,MAEAtG,EAAAhC,OAAAsI,EAAA,EACApG,EAAAsG,EAAAxH,EAAAzB,GAIAyC,EAAAsG,GAAA,EAAA7G,EAAAd,EAAAvB,EAAAoJ,EAAAH,EAAA5G,GAAA+G,EAAA/G,IAAAS,EAAA,GAIAhD,EAEA,OAAA,CAGA,GAAA,GAAAoJ,EAAA,CAGA,IAAA/I,EAAA,EAAAkC,EAAAO,EAAA,GAAA,IAAAP,EAAAA,GAAA,GAAAlC,KAEA,IADAkC,EAAAO,EAAA,IAAAE,EACAA,EAAA,EAAA,IAAAT,EAAAA,GAAA,GAAAS,KAGA3C,GAAA2C,IACAL,EAAA1C,IACA6C,EAAA,IAAAjB,IAAAiB,EAAA,GAAA,IAGA,MAGA,GADAA,EAAAsG,IAAApG,EACAF,EAAAsG,IAAAvH,EAAA,MACAiB,EAAAsG,KAAA,EACApG,EAAA,EAMA,IAAA3C,EAAAyC,EAAAhC,OAAA,IAAAgC,IAAAzC,GAAAyC,EAAAmG,QAIAtG,EAAA1C,EAAAqF,EACA3C,EAAArC,EAAAqC,EAAA1C,EAAA,KAGA0C,EAAA1C,EAAAoF,IACA1C,EAAArC,EAAA,CAAAqC,EAAA1C,EAAA,IAIA,OAAA0C,EAIA,SAAAoC,EAAA7E,GACA,IAAAuD,EACAxD,EAAAC,EAAAD,EAEA,OAAA,OAAAA,EAAAC,EAAA4E,YAEArB,EAAArB,EAAAlC,EAAAI,GAEAmD,EAAAxD,GAAAkF,GAAAC,GAAAnF,EACAuD,EAAAC,EAAAxD,GACA0D,GAAAF,EAAAxD,EAAA,KAEAC,EAAAmC,EAAA,EAAA,IAAAoB,EAAAA,GAiqCA,OAv0EAxC,EAAA6C,MAAAA,EAEA7C,EAAAuI,SAAA,EACAvI,EAAAwI,WAAA,EACAxI,EAAAyI,WAAA,EACAzI,EAAA0I,YAAA,EACA1I,EAAA2I,cAAA,EACA3I,EAAA4I,gBAAA,EACA5I,EAAA6I,gBAAA,EACA7I,EAAA8I,gBAAA,EACA9I,EAAA+I,iBAAA,EACA/I,EAAAgJ,OAAA,EAqCAhJ,EAAAiJ,OAAAjJ,EAAAkJ,IAAA,SAAAC,GACA,IAAAxJ,EAAAwF,EAEA,GAAA,MAAAgE,EAAA,CAEA,GAAA,iBAAAA,EA2HA,MAAA1J,MACAiB,EAAA,oBAAAyI,GAtFA,GAlCAA,EAAAC,eAAAzJ,EAAA,oBAEAsC,EADAkD,EAAAgE,EAAAxJ,GACA,EAAAsB,EAAAtB,GACAqE,EAAAmB,GAKAgE,EAAAC,eAAAzJ,EAAA,mBAEAsC,EADAkD,EAAAgE,EAAAxJ,GACA,EAAA,EAAAA,GACAsE,EAAAkB,GAOAgE,EAAAC,eAAAzJ,EAAA,qBACAwF,EAAAgE,EAAAxJ,KACAwF,EAAA6C,KACA/F,EAAAkD,EAAA,IAAAlE,EAAA,EAAAtB,GACAsC,EAAAkD,EAAA,GAAA,EAAAlE,EAAAtB,GACAuE,EAAAiB,EAAA,GACAhB,EAAAgB,EAAA,KAEAlD,EAAAkD,GAAAlE,EAAAA,EAAAtB,GACAuE,IAAAC,EAAAgB,EAAA,GAAAA,EAAAA,KAOAgE,EAAAC,eAAAzJ,EAAA,SAEA,IADAwF,EAAAgE,EAAAxJ,KACAwF,EAAA6C,IACA/F,EAAAkD,EAAA,IAAAlE,GAAA,EAAAtB,GACAsC,EAAAkD,EAAA,GAAA,EAAAlE,EAAAtB,GACAyE,EAAAe,EAAA,GACAd,EAAAc,EAAA,OACA,CAEA,GADAlD,EAAAkD,GAAAlE,EAAAA,EAAAtB,IACAwF,EAGA,MAAA1F,MACAiB,EAAAf,EAAA,oBAAAwF,GAHAf,IAAAC,EAAAc,EAAA,GAAAA,EAAAA,GAWA,GAAAgE,EAAAC,eAAAzJ,EAAA,UAAA,CAEA,IADAwF,EAAAgE,EAAAxJ,QACAwF,EAcA,MAAA1F,MACAiB,EAAAf,EAAA,uBAAAwF,GAdA,GAAAA,EAAA,CACA,GAAA,oBAAAkE,SAAAA,SACAA,OAAAC,kBAAAD,OAAAE,YAIA,MADAjF,GAAAa,EACA1F,MACAiB,EAAA,sBAJA4D,EAAAa,OAOAb,EAAAa,EA0BA,GAhBAgE,EAAAC,eAAAzJ,EAAA,iBAEAsC,EADAkD,EAAAgE,EAAAxJ,GACA,EAAA,EAAAA,GACA4E,EAAAY,GAKAgE,EAAAC,eAAAzJ,EAAA,mBAEAsC,EADAkD,EAAAgE,EAAAxJ,GACA,EAAAsB,EAAAtB,GACA6E,EAAAW,GAKAgE,EAAAC,eAAAzJ,EAAA,UAAA,CAEA,GAAA,iBADAwF,EAAAgE,EAAAxJ,IAEA,MAAAF,MACAiB,EAAAf,EAAA,mBAAAwF,GAFAV,EAAAU,EAOA,GAAAgE,EAAAC,eAAAzJ,EAAA,YAAA,CAKA,GAAA,iBAJAwF,EAAAgE,EAAAxJ,KAIA,sBAAA6F,KAAAL,GAGA,MAAA1F,MACAiB,EAAAf,EAAA,aAAAwF,GAHAD,EAAAC,GAeA,MAAA,CACAnB,eAAAA,EACAC,cAAAA,EACAuF,eAAA,CAAAtF,EAAAC,GACAsF,MAAA,CAAArF,EAAAC,GACAC,OAAAA,EACAC,YAAAA,EACAC,cAAAA,EACAC,OAAAA,EACAS,SAAAA,IAcAlF,EAAA0J,YAAA,SAAAvE,GACA,IAAAA,IAAA,IAAAA,EAAAI,aAAA,OAAA,EACA,IAAAvF,EAAA8F,MAAA,OAAA,EAEA,IAAA1G,EAAAH,EACAI,EAAA8F,EAAA9F,EACAL,EAAAmG,EAAAnG,EACAoC,EAAA+D,EAAA/D,EAEAkH,EAAA,GAAA,kBAAA,GAAAzE,SAAAjE,KAAAP,IAEA,IAAA,IAAA+B,IAAA,IAAAA,KAAAH,GAAAjC,GAAAA,GAAAiC,GAAAjC,IAAAwB,EAAAxB,GAAA,CAGA,GAAA,IAAAK,EAAA,GAAA,CACA,GAAA,IAAAL,GAAA,IAAAK,EAAAQ,OAAA,OAAA,EACA,MAAAyI,EASA,IALAlJ,GAAAJ,EAAA,GAAA6B,GACA,IAAAzB,GAAAyB,GAIAwB,OAAAhD,EAAA,IAAAQ,QAAAT,EAAA,CAEA,IAAAA,EAAA,EAAAA,EAAAC,EAAAQ,OAAAT,IAEA,IADAH,EAAAI,EAAAD,IACA,GAAAwB,GAAA3B,GAAAA,IAAAuB,EAAAvB,GAAA,MAAAqJ,EAIA,GAAA,IAAArJ,EAAA,OAAA,SAKA,GAAA,OAAAI,GAAA,OAAAL,IAAA,OAAAoC,GAAA,IAAAA,IAAA,IAAAA,GACA,OAAA,EAGA,MAAA3B,MACAiB,EAAA,sBAAAyE,IASAnF,EAAA2J,QAAA3J,EAAAmC,IAAA,WACA,OAAAyF,EAAAgC,UAAAlG,EAAAmG,KASA7J,EAAA8J,QAAA9J,EAAAkC,IAAA,WACA,OAAA0F,EAAAgC,UAAAlG,EAAAqG,KAcA/J,EAAAgK,QACA9G,EAAA,iBAMAC,EAAA7C,KAAA0J,SAAA9G,EAAA,QACA,WAAA,OAAA1C,EAAAF,KAAA0J,SAAA9G,IACA,WAAA,OAAA,SAAA,WAAA5C,KAAA0J,SAAA,IACA,QAAA1J,KAAA0J,SAAA,IAEA,SAAAC,GACA,IAAAzK,EAAAoC,EAAA5C,EAAA+C,EAAAoD,EACA/F,EAAA,EACAC,EAAA,GACA6K,EAAA,IAAAlK,EAAA+D,GAOA,GALA,MAAAkG,EAAAA,EAAAjG,EACA/B,EAAAgI,EAAA,EAAAhJ,GAEAc,EAAA1B,EAAA4J,EAAApJ,GAEAyD,EAGA,GAAA+E,OAAAC,gBAAA,CAIA,IAFA9J,EAAA6J,OAAAC,gBAAA,IAAAa,YAAApI,GAAA,IAEA3C,EAAA2C,GAcA,OANAoD,EAAA,OAAA3F,EAAAJ,IAAAI,EAAAJ,EAAA,KAAA,MAOAwC,EAAAyH,OAAAC,gBAAA,IAAAa,YAAA,IACA3K,EAAAJ,GAAAwC,EAAA,GACApC,EAAAJ,EAAA,GAAAwC,EAAA,KAKAvC,EAAA4G,KAAAd,EAAA,MACA/F,GAAA,GAGAA,EAAA2C,EAAA,MAGA,CAAA,IAAAsH,OAAAE,YA2BA,MADAjF,GAAA,EACA7E,MACAiB,EAAA,sBAvBA,IAFAlB,EAAA6J,OAAAE,YAAAxH,GAAA,GAEA3C,EAAA2C,GAUA,OAJAoD,EAAA,iBAAA,GAAA3F,EAAAJ,IAAA,cAAAI,EAAAJ,EAAA,GACA,WAAAI,EAAAJ,EAAA,GAAA,SAAAI,EAAAJ,EAAA,IACAI,EAAAJ,EAAA,IAAA,KAAAI,EAAAJ,EAAA,IAAA,GAAAI,EAAAJ,EAAA,IAGAiK,OAAAE,YAAA,GAAAa,KAAA5K,EAAAJ,IAIAC,EAAA4G,KAAAd,EAAA,MACA/F,GAAA,GAGAA,EAAA2C,EAAA,EASA,IAAAuC,EAEA,KAAAlF,EAAA2C,IACAoD,EAAAhC,KACA,OAAA9D,EAAAD,KAAA+F,EAAA,MAcA,IAVApD,EAAA1C,IAAAD,GACA6K,GAAApJ,EAGAkB,GAAAkI,IACA9E,EAAApE,EAAAF,EAAAoJ,GACA5K,EAAAD,GAAAoB,EAAAuB,EAAAoD,GAAAA,GAIA,IAAA9F,EAAAD,GAAAC,EAAA2I,MAAA5I,KAGA,GAAAA,EAAA,EACAC,EAAA,CAAAL,EAAA,OACA,CAGA,IAAAA,GAAA,EAAA,IAAAK,EAAA,GAAAA,EAAAiI,OAAA,EAAA,GAAAtI,GAAA6B,GAGA,IAAAzB,EAAA,EAAA+F,EAAA9F,EAAA,GAAA,IAAA8F,EAAAA,GAAA,GAAA/F,KAGAA,EAAAyB,IAAA7B,GAAA6B,EAAAzB,GAKA,OAFA8K,EAAAlL,EAAAA,EACAkL,EAAA7K,EAAAA,EACA6K,IAUAlK,EAAAqK,IAAA,WAIA,IAHA,IAAAjL,EAAA,EACAyI,EAAA+B,UACAS,EAAA,IAAArK,EAAA6H,EAAA,IACAzI,EAAAyI,EAAAhI,QAAAwK,EAAAA,EAAAC,KAAAzC,EAAAzI,MACA,OAAAiL,GASAjH,EAAA,aADAJ,EAoCA,SAAAR,EAAA2D,EAAAC,EAAAmE,EAAAC,GACA,IAAApF,EAAA8C,EAAAlJ,EAAA+C,EAAAhD,EAAA2C,EAAAG,EAAAF,EACAvC,EAAAoD,EAAAiD,QAAA,KACAwE,EAAAjG,EACAwD,EAAAvD,EA+BA,IA5BA,GAAA7E,IACA2C,EAAAyC,EAGAA,EAAA,EACAhC,EAAAA,EAAAkD,QAAA,IAAA,IAEAhE,GADAC,EAAA,IAAA3B,EAAAmG,IACAsE,IAAAjI,EAAA3C,OAAAT,GACAoF,EAAAzC,EAKAJ,EAAAtC,EAAA6G,EAAAxD,GAAAvB,EAAAO,EAAArC,GAAAqC,EAAA1C,EAAA,KACA,GAAAoH,EAAAhD,GACAzB,EAAA3C,EAAA2C,EAAAtC,EAAAQ,QAUAb,EAAA+C,GALAF,EAAAqE,EAAA1D,EAAA2D,EAAAC,EAAAoE,GACApF,EAAAF,EAAA9B,IACAgC,EAAAhC,EAAA8B,KAGArF,OAGA,GAAAgC,IAAAE,GAAAF,EAAAmG,OAGA,IAAAnG,EAAA,GAAA,OAAAuD,EAAA3C,OAAA,GAqCA,GAlCArD,EAAA,IACAJ,GAEA0C,EAAArC,EAAAwC,EACAH,EAAA1C,EAAAA,EAGA0C,EAAAN,EAAAmJ,EAEA1I,GADAH,EAAAqB,EAAArB,EAAAC,EAAAsI,EAAAzC,EAAApB,IACA/G,EACAN,EAAA2C,EAAA3C,EACAC,EAAA0C,EAAA1C,GASAI,EAAAyC,EAHAqG,EAAAlJ,EAAAiL,EAAA,GAOAlI,EAAAqE,EAAA,EACArH,EAAAA,GAAAmJ,EAAA,GAAA,MAAArG,EAAAqG,EAAA,GAEAnJ,EAAAyI,EAAA,GAAA,MAAApI,GAAAL,KAAA,GAAAyI,GAAAA,IAAA9F,EAAAN,EAAA,EAAA,EAAA,IACAW,EAAA3C,GAAAA,GAAA2C,IAAA,GAAAyF,GAAAzI,GAAA,GAAAyI,GAAA,EAAA3F,EAAAqG,EAAA,IACAV,IAAA9F,EAAAN,EAAA,EAAA,EAAA,IAKA8G,EAAA,IAAArG,EAAA,GAGAW,EAAAzD,EAAA2D,GAAA0C,EAAA3C,OAAA,IAAAwH,EAAA7E,EAAA3C,OAAA,IAAA2C,EAAA3C,OAAA,OACA,CAMA,GAHAZ,EAAAhC,OAAAqI,EAGAnJ,EAGA,MAAAqH,IAAAvE,IAAAqG,GAAA9B,GACAvE,EAAAqG,GAAA,EAEAA,MACAlJ,EACA6C,EAAA,CAAA,GAAAoF,OAAApF,IAMA,IAAAE,EAAAF,EAAAhC,QAAAgC,IAAAE,KAGA,IAAA3C,EAAA,EAAAoD,EAAA,GAAApD,GAAA2C,EAAAS,GAAA4C,EAAA3C,OAAAZ,EAAAzC,OAGAoD,EAAAE,GAAAF,EAAAxD,EAAAoG,EAAA3C,OAAA,IAIA,OAAAD,GAMAO,EA0DA,SAAArB,EAAAC,EAAAsI,EAAAzC,EAAAf,GACA,IAAAW,EAAApI,EAAAI,EAAAsL,EAAAzL,EAAA0L,EAAAC,EAAAC,EAAAC,EAAAC,EAAAC,EAAAC,EAAAC,EAAAC,EAAAC,EACAC,EAAAC,EACAlK,EAAAM,EAAAN,GAAAO,EAAAP,EAAA,GAAA,EACAS,EAAAH,EAAArC,EACAyC,EAAAH,EAAAtC,EAGA,KAAAwC,GAAAA,EAAA,IAAAC,GAAAA,EAAA,IAEA,OAAA,IAAA9B,EAGA0B,EAAAN,GAAAO,EAAAP,IAAAS,GAAAC,GAAAD,EAAA,IAAAC,EAAA,GAAAA,GAGAD,GAAA,GAAAA,EAAA,KAAAC,EAAA,EAAAV,EAAAA,EAAA,EAHAmK,KAoBA,IAZAT,GADAD,EAAA,IAAA7K,EAAAoB,IACA/B,EAAA,GAEA+B,EAAA6I,GADAjL,EAAA0C,EAAA1C,EAAA2C,EAAA3C,GACA,EAEAyH,IACAA,EAAA7F,EACA5B,EAAAkC,EAAAQ,EAAA1C,EAAA6B,GAAAK,EAAAS,EAAA3C,EAAA6B,GACAO,EAAAA,EAAAP,EAAA,GAKAzB,EAAA,EAAA0C,EAAA1C,KAAAyC,EAAAzC,IAAA,GAAAA,KAIA,GAFA0C,EAAA1C,IAAAyC,EAAAzC,IAAA,IAAAJ,IAEAoC,EAAA,EACA0J,EAAA7E,KAAA,GACAyE,GAAA,MACA,CAwBA,IAvBAS,EAAAtJ,EAAAhC,OACAwL,EAAAvJ,EAAAjC,OAEAuB,GAAA,EAQA,GAJAnC,EAAAuB,EAAAiG,GAAA3E,EALA1C,EAAA,GAKA,OAKA0C,EAAA0E,EAAA1E,EAAA7C,EAAAwH,GACA5E,EAAA2E,EAAA3E,EAAA5C,EAAAwH,GACA4E,EAAAvJ,EAAAjC,OACAsL,EAAAtJ,EAAAhC,QAGAqL,EAAAG,EAEAL,GADAD,EAAAlJ,EAAAL,MAAA,EAAA6J,IACAxL,OAGAmL,EAAAK,EAAAN,EAAAC,KAAA,GACAM,EAAAxJ,EAAAN,QACA8J,EAAA,CAAA,GAAArE,OAAAqE,GACAF,EAAAtJ,EAAA,GACAA,EAAA,IAAA2E,EAAA,GAAA2E,IAIA,EAAA,CAOA,GANAnM,EAAA,GAGAmI,EAAA3F,EAAAK,EAAAiJ,EAAAM,EAAAL,IAGA,EAAA,CAqBA,GAjBAC,EAAAF,EAAA,GACAM,GAAAL,IAAAC,EAAAA,EAAAxE,GAAAsE,EAAA,IAAA,IAgBA,GAbA9L,EAAAuB,EAAAyK,EAAAG,IA2BA,IAXA3E,GAAAxH,IAAAA,EAAAwH,EAAA,GAIAmE,GADAD,EAAAnE,EAAA1E,EAAA7C,EAAAwH,IACA5G,OACAmL,EAAAD,EAAAlL,OAMA,GAAA4B,EAAAkJ,EAAAI,EAAAH,EAAAI,IACA/L,IAGAoI,EAAAsD,EAAAU,EAAAT,EAAAU,EAAAxJ,EAAA8I,EAAAnE,GACAmE,EAAAD,EAAA9K,OACAuH,EAAA,OAQA,GAAAnI,IAGAmI,EAAAnI,EAAA,GAKA2L,GADAD,EAAA7I,EAAAN,SACA3B,OAUA,GAPA+K,EAAAI,IAAAL,EAAA,CAAA,GAAA1D,OAAA0D,IAGAtD,EAAA0D,EAAAJ,EAAAK,EAAAvE,GACAuE,EAAAD,EAAAlL,QAGA,GAAAuH,EAMA,KAAA3F,EAAAK,EAAAiJ,EAAAM,EAAAL,GAAA,GACA/L,IAGAoI,EAAA0D,EAAAM,EAAAL,EAAAM,EAAAxJ,EAAAkJ,EAAAvE,GACAuE,EAAAD,EAAAlL,YAGA,IAAAuH,IACAnI,IACA8L,EAAA,CAAA,IAIAD,EAAA1L,KAAAH,EAGA8L,EAAA,GACAA,EAAAC,KAAAnJ,EAAAqJ,IAAA,GAEAH,EAAA,CAAAlJ,EAAAqJ,IACAF,EAAA,UAEAE,IAAAC,GAAA,MAAAJ,EAAA,KAAA3J,KAEAsJ,EAAA,MAAAK,EAAA,GAGAD,EAAA,IAAAA,EAAAxD,OAAA,EAAA,GAGA,GAAAb,GAAA7F,EAAA,CAGA,IAAAxB,EAAA,EAAAgC,EAAA0J,EAAA,GAAA,IAAA1J,EAAAA,GAAA,GAAAhC,KAEAyG,EAAAgF,EAAAZ,GAAAY,EAAA7L,EAAAI,EAAAJ,EAAA6B,EAAA,GAAA,EAAA2G,EAAAkD,QAIAG,EAAA7L,EAAAA,EACA6L,EAAA9L,GAAA2L,EAGA,OAAAG,GAkIAxH,EAAA,8BACAC,EAAA,cACAC,EAAA,cACAC,EAAA,qBACAC,EAAA,6BALAR,EAOA,SAAAvB,EAAAc,EAAA8C,EAAA1D,GACA,IAAA6E,EACArF,EAAAkE,EAAA9C,EAAAA,EAAAkD,QAAAjC,EAAA,IAGA,GAAAD,EAAAgC,KAAApE,GACAM,EAAAN,EAAAoK,MAAApK,GAAA,KAAAA,EAAA,GAAA,EAAA,MACA,CACA,IAAAkE,IAGAlE,EAAAA,EAAAsE,QAAArC,EAAA,SAAAqD,EAAA+E,EAAAC,GAEA,OADAjF,EAAA,MAAAiF,EAAAA,EAAA1F,eAAA,GAAA,KAAA0F,EAAA,EAAA,EACA9J,GAAAA,GAAA6E,EAAAC,EAAA+E,IAGA7J,IACA6E,EAAA7E,EAGAR,EAAAA,EAAAsE,QAAApC,EAAA,MAAAoC,QAAAnC,EAAA,SAGAf,GAAApB,GAAA,OAAA,IAAApB,EAAAoB,EAAAqF,GAKA,GAAAzG,EAAA8F,MACA,MAAArG,MACAiB,EAAA,SAAAkB,EAAA,SAAAA,EAAA,IAAA,YAAAY,GAIAd,EAAAN,EAAA,KAGAM,EAAArC,EAAAqC,EAAA1C,EAAA,MA6LA0E,EAAAiI,cAAAjI,EAAAkI,IAAA,WACA,IAAAlK,EAAA,IAAA1B,EAAAnB,MAEA,OADA6C,EAAAN,EAAA,IAAAM,EAAAN,EAAA,GACAM,GAWAgC,EAAAmI,WAAA,SAAAlK,EAAAC,GACA,OAAAH,EAAA5C,KAAA,IAAAmB,EAAA2B,EAAAC,KAiBA8B,EAAAoI,cAAApI,EAAAuG,GAAA,SAAAA,EAAAzC,GACA,IAAAnI,EAAAJ,EAAAkG,EAGA,GAAA,MAAA8E,EAKA,OAJAhI,EAAAgI,EAAA,EAAAhJ,GACA,MAAAuG,EAAAA,EAAAvD,EACAhC,EAAAuF,EAAA,EAAA,GAEA3B,EAAA,IAAA7F,EAPAnB,MAOAoL,EAPApL,KAOAG,EAAA,EAAAwI,GAGA,KAAAnI,EAVAR,KAUAQ,GAAA,OAAA,KAIA,GAHAJ,IAAAkG,EAAA9F,EAAAQ,OAAA,GAAAqB,EAAArC,KAAAG,EAAA6B,IAAAA,EAGAsE,EAAA9F,EAAA8F,GAAA,KAAAA,EAAA,IAAA,EAAAA,GAAA,GAAAlG,KAGA,OAFAA,EAAA,IAAAA,EAAA,GAEAA,GAwBAyE,EAAAqI,UAAArI,EAAAX,IAAA,SAAApB,EAAAC,GACA,OAAAmB,EAAAlE,KAAA,IAAAmB,EAAA2B,EAAAC,GAAAoC,EAAAC,IAQAP,EAAAsI,mBAAAtI,EAAAuI,KAAA,SAAAtK,EAAAC,GACA,OAAAmB,EAAAlE,KAAA,IAAAmB,EAAA2B,EAAAC,GAAA,EAAA,IAmBA8B,EAAAwI,gBAAAxI,EAAA+G,IAAA,SAAAxL,EAAAyH,GACA,IAAAyF,EAAAC,EAAAhN,EAAA2C,EAAAsK,EAAAC,EAAAC,EAAA5K,EACAD,EAAA7C,KAKA,IAHAI,EAAA,IAAAe,EAAAf,IAGAI,IAAAJ,EAAAuN,YACA,MAAA/M,MACAiB,EAAA,4BAAAoD,EAAA7E,IASA,GANA,MAAAyH,IAAAA,EAAA,IAAA1G,EAAA0G,IAGA2F,EAAA,GAAApN,EAAAD,GAGA0C,EAAArC,IAAAqC,EAAArC,EAAA,IAAA,GAAAqC,EAAArC,EAAA,KAAAqC,EAAA1C,GAAA,GAAA0C,EAAArC,EAAAQ,SAAAZ,EAAAI,IAAAJ,EAAAI,EAAA,GAKA,OADAsC,EAAA,IAAA3B,EAAAM,KAAAmK,KAAA3G,EAAApC,GAAA2K,EAAA,EAAA/J,EAAArD,IAAA6E,EAAA7E,KACAyH,EAAA/E,EAAA8K,IAAA/F,GAAA/E,EAKA,GAFA2K,EAAArN,EAAAmC,EAAA,EAEAsF,EAAA,CAGA,GAAAA,EAAArH,GAAAqH,EAAArH,EAAA,IAAAqH,EAAAtF,EAAA,OAAA,IAAApB,EAAAuL,MAEAa,GAAAE,GAAA5K,EAAA8K,aAAA9F,EAAA8F,eAEA9K,EAAAA,EAAA+K,IAAA/F,QAIA,CAAA,GAAA,EAAAzH,EAAAD,IAAA,EAAA0C,EAAA1C,GAAA0C,EAAA1C,GAAA,IAAA,GAAA0C,EAAA1C,EAEA,EAAA0C,EAAArC,EAAA,IAAAgN,GAAA,MAAA3K,EAAArC,EAAA,GAEAqC,EAAArC,EAAA,GAAA,MAAAgN,GAAA3K,EAAArC,EAAA,IAAA,YASA,OANA0C,EAAAL,EAAAN,EAAA,GAAAkB,EAAArD,IAAA,EAAA,GAGA,EAAAyC,EAAA1C,IAAA+C,EAAA,EAAAA,GAGA,IAAA/B,EAAAsM,EAAA,EAAAvK,EAAAA,GAEAyC,IAKAzC,EAAA1B,EAAAmE,EAAA3D,EAAA,IAeA,IATA0L,EAHAF,GACAF,EAAA,IAAAnM,EAAA,IACAsM,IAAArN,EAAAmC,EAAA,GACAkB,EAAArD,KAEAG,EAAAkB,KAAAsL,KAAA9H,EAAA7E,KACA,EAGA0C,EAAA,IAAA3B,EAAA+D,KAGA,CAEA,GAAAwI,EAAA,CAEA,KADA5K,EAAAA,EAAA+K,MAAAhL,IACArC,EAAA,MAEA0C,EACAJ,EAAAtC,EAAAQ,OAAAkC,IAAAJ,EAAAtC,EAAAQ,OAAAkC,GACAqK,IACAzK,EAAAA,EAAA8K,IAAA/F,IAIA,GAAAtH,EAAA,CAEA,GAAA,KADAA,EAAAoB,EAAApB,EAAA,IACA,MACAmN,EAAAnN,EAAA,OAKA,GAFAyG,EADA5G,EAAAA,EAAAyN,MAAAP,GACAlN,EAAAD,EAAA,EAAA,GAEA,GAAAC,EAAAD,EACAuN,EAAAjK,EAAArD,OACA,CAEA,GAAA,IADAG,GAAA0E,EAAA7E,IACA,MACAsN,EAAAnN,EAAA,EAIAsC,EAAAA,EAAAgL,MAAAhL,GAEAK,EACAL,EAAArC,GAAAqC,EAAArC,EAAAQ,OAAAkC,IAAAL,EAAArC,EAAAQ,OAAAkC,GACAqK,IACA1K,EAAAA,EAAA+K,IAAA/F,IAIA,OAAA0F,EAAAzK,GACA2K,IAAA3K,EAAAoC,EAAAhB,IAAApB,IAEA+E,EAAA/E,EAAA8K,IAAA/F,GAAA3E,EAAA8D,EAAAlE,EAAA6C,EAAAP,OAnHAyG,GAmHA/I,IAYA+B,EAAAiJ,aAAA,SAAAnF,GACA,IAAAvI,EAAA,IAAAe,EAAAnB,MAGA,OAFA,MAAA2I,EAAAA,EAAAvD,EACAhC,EAAAuF,EAAA,EAAA,GACA3B,EAAA5G,EAAAA,EAAAD,EAAA,EAAAwI,IAQA9D,EAAAkJ,UAAAlJ,EAAAmJ,GAAA,SAAAlL,EAAAC,GACA,OAAA,IAAAH,EAAA5C,KAAA,IAAAmB,EAAA2B,EAAAC,KAOA8B,EAAAoJ,SAAA,WACA,QAAAjO,KAAAQ,GAQAqE,EAAAqJ,cAAArJ,EAAAqG,GAAA,SAAApI,EAAAC,GACA,OAAA,EAAAH,EAAA5C,KAAA,IAAAmB,EAAA2B,EAAAC,KAQA8B,EAAAsJ,uBAAAtJ,EAAAuJ,IAAA,SAAAtL,EAAAC,GACA,OAAA,KAAAA,EAAAH,EAAA5C,KAAA,IAAAmB,EAAA2B,EAAAC,MAAA,IAAAA,GAQA8B,EAAA8I,UAAA,WACA,QAAA3N,KAAAQ,GAAA6B,EAAArC,KAAAG,EAAA6B,GAAAhC,KAAAQ,EAAAQ,OAAA,GAQA6D,EAAAwJ,WAAAxJ,EAAAmG,GAAA,SAAAlI,EAAAC,GACA,OAAAH,EAAA5C,KAAA,IAAAmB,EAAA2B,EAAAC,IAAA,GAQA8B,EAAAyJ,oBAAAzJ,EAAA0J,IAAA,SAAAzL,EAAAC,GACA,OAAA,KAAAA,EAAAH,EAAA5C,KAAA,IAAAmB,EAAA2B,EAAAC,MAAA,IAAAA,GAOA8B,EAAA8H,MAAA,WACA,OAAA3M,KAAAuC,GAOAsC,EAAA2J,WAAA,WACA,OAAAxO,KAAAuC,EAAA,GAOAsC,EAAA4J,WAAA,WACA,OAAA,EAAAzO,KAAAuC,GAOAsC,EAAA6J,OAAA,WACA,QAAA1O,KAAAQ,GAAA,GAAAR,KAAAQ,EAAA,IAwBAqE,EAAA8J,MAAA,SAAA7L,EAAAC,GACA,IAAAxC,EAAAkC,EAAApC,EAAAuO,EACA/L,EAAA7C,KACAW,EAAAkC,EAAAN,EAMA,GAHAQ,GADAD,EAAA,IAAA3B,EAAA2B,EAAAC,IACAR,GAGA5B,IAAAoC,EAAA,OAAA,IAAA5B,EAAAuL,KAGA,GAAA/L,GAAAoC,EAEA,OADAD,EAAAP,GAAAQ,EACAF,EAAA4I,KAAA3I,GAGA,IAAA+L,EAAAhM,EAAA1C,EAAA6B,EACA8M,EAAAhM,EAAA3C,EAAA6B,EACAgB,EAAAH,EAAArC,EACAyC,EAAAH,EAAAtC,EAEA,IAAAqO,IAAAC,EAAA,CAGA,IAAA9L,IAAAC,EAAA,OAAAD,GAAAF,EAAAP,GAAAQ,EAAAD,GAAA,IAAA3B,EAAA8B,EAAAJ,EAAA6J,KAGA,IAAA1J,EAAA,KAAAC,EAAA,GAGA,OAAAA,EAAA,IAAAH,EAAAP,GAAAQ,EAAAD,GAAA,IAAA3B,EAAA6B,EAAA,GAAAH,EAGA,GAAAuC,GAAA,EAAA,GASA,GALAyJ,EAAAxM,EAAAwM,GACAC,EAAAzM,EAAAyM,GACA9L,EAAAA,EAAAL,QAGAhC,EAAAkO,EAAAC,EAAA,CAaA,KATAzO,GAFAuO,EAAAjO,EAAA,IACAA,GAAAA,EACAqC,IAEA8L,EAAAD,EACA5L,IAGAyE,UAGA3E,EAAApC,EAAAoC,IAAA1C,EAAA+G,KAAA,IACA/G,EAAAqH,eAMA,IAFAjF,GAAAmM,GAAAjO,EAAAqC,EAAAhC,SAAA+B,EAAAE,EAAAjC,SAAAL,EAAAoC,EAEApC,EAAAoC,EAAA,EAAAA,EAAAN,EAAAM,IAEA,GAAAC,EAAAD,IAAAE,EAAAF,GAAA,CACA6L,EAAA5L,EAAAD,GAAAE,EAAAF,GACA,MAYA,GANA6L,IAAAvO,EAAA2C,EAAAA,EAAAC,EAAAA,EAAA5C,EAAAyC,EAAAP,GAAAO,EAAAP,GAMA,GAJAQ,GAAAN,EAAAQ,EAAAjC,SAAAT,EAAAyC,EAAAhC,SAIA,KAAA+B,IAAAC,EAAAzC,KAAA,GAIA,IAHAwC,EAAAhB,EAAA,EAGApB,EAAA8B,GAAA,CAEA,GAAAO,IAAAP,GAAAQ,EAAAR,GAAA,CACA,IAAAlC,EAAAkC,EAAAlC,IAAAyC,IAAAzC,GAAAyC,EAAAzC,GAAAwC,KACAC,EAAAzC,GACAyC,EAAAP,IAAAV,EAGAiB,EAAAP,IAAAQ,EAAAR,GAIA,KAAA,GAAAO,EAAA,GAAAA,EAAAyF,OAAA,EAAA,KAAAqG,GAGA,OAAA9L,EAAA,GAWAkG,EAAApG,EAAAE,EAAA8L,IAPAhM,EAAAP,EAAA,GAAA6C,GAAA,EAAA,EACAtC,EAAAtC,EAAA,CAAAsC,EAAA3C,EAAA,GACA2C,IA8BA+B,EAAAkK,OAAAlK,EAAA+I,IAAA,SAAA9K,EAAAC,GACA,IAAAiJ,EAAAzJ,EACAM,EAAA7C,KAKA,OAHA8C,EAAA,IAAA3B,EAAA2B,EAAAC,IAGAF,EAAArC,IAAAsC,EAAAP,GAAAO,EAAAtC,IAAAsC,EAAAtC,EAAA,GACA,IAAAW,EAAAuL,MAGA5J,EAAAtC,GAAAqC,EAAArC,IAAAqC,EAAArC,EAAA,GACA,IAAAW,EAAA0B,IAGA,GAAA6C,GAIAnD,EAAAO,EAAAP,EACAO,EAAAP,EAAA,EACAyJ,EAAA9H,EAAArB,EAAAC,EAAA,EAAA,GACAA,EAAAP,EAAAA,EACAyJ,EAAAzJ,GAAAA,GAEAyJ,EAAA9H,EAAArB,EAAAC,EAAA,EAAA4C,IAGA5C,EAAAD,EAAA8L,MAAA3C,EAAA6B,MAAA/K,KAGAtC,EAAA,IAAA,GAAAkF,IAAA5C,EAAAP,EAAAM,EAAAN,GAEAO,IAwBA+B,EAAAmK,aAAAnK,EAAAgJ,MAAA,SAAA/K,EAAAC,GACA,IAAAvC,EAAAL,EAAAI,EAAAkC,EAAAS,EAAA2E,EAAAoH,EAAAlH,EAAAC,EAAAkH,EAAAC,EAAAC,EAAAC,EACAzH,EAAA0H,EACAzM,EAAA7C,KACAgD,EAAAH,EAAArC,EACAyC,GAAAH,EAAA,IAAA3B,EAAA2B,EAAAC,IAAAvC,EAGA,KAAAwC,GAAAC,GAAAD,EAAA,IAAAC,EAAA,IAmBA,OAhBAJ,EAAAN,IAAAO,EAAAP,GAAAS,IAAAA,EAAA,KAAAC,GAAAA,IAAAA,EAAA,KAAAD,EACAF,EAAAtC,EAAAsC,EAAA3C,EAAA2C,EAAAP,EAAA,MAEAO,EAAAP,GAAAM,EAAAN,EAGAS,GAAAC,GAKAH,EAAAtC,EAAA,CAAA,GACAsC,EAAA3C,EAAA,GALA2C,EAAAtC,EAAAsC,EAAA3C,EAAA,MASA2C,EAYA,IATA3C,EAAAkC,EAAAQ,EAAA1C,EAAA6B,GAAAK,EAAAS,EAAA3C,EAAA6B,GACAc,EAAAP,GAAAM,EAAAN,GACA0M,EAAAjM,EAAAhC,SACAkO,EAAAjM,EAAAjC,UAGAqO,EAAArM,EAAAA,EAAAC,EAAAA,EAAAoM,EAAA9O,EAAA0O,EAAAA,EAAAC,EAAAA,EAAA3O,GAGAA,EAAA0O,EAAAC,EAAAG,EAAA,GAAA9O,IAAA8O,EAAAjI,KAAA,IAKA,IAHAQ,EAAA7F,EACAuN,EAAAnN,EAEA5B,EAAA2O,EAAA,KAAA3O,GAAA,CAKA,IAJAC,EAAA,EACA2O,EAAAlM,EAAA1C,GAAA+O,EACAF,EAAAnM,EAAA1C,GAAA+O,EAAA,EAEA7M,EAAAlC,GAAA2C,EAAA+L,GAAA1O,EAAAkC,GAKAjC,IADAuH,EAAAoH,GAHApH,EAAA/E,IAAAE,GAAAoM,IAEAzH,EAAAuH,EAAArH,GADAC,EAAAhF,EAAAE,GAAAoM,EAAA,GACAH,GACAG,EAAAA,EAAAD,EAAA5M,GAAAjC,GACAoH,EAAA,IAAAC,EAAAyH,EAAA,GAAAF,EAAApH,EACAqH,EAAA5M,KAAAsF,EAAAH,EAGAyH,EAAA5M,GAAAjC,EASA,OANAA,IACAL,EAEAkP,EAAA5G,OAAA,EAAA,GAGAS,EAAApG,EAAAuM,EAAAlP,IAQA0E,EAAA0K,QAAA,WACA,IAAA1M,EAAA,IAAA1B,EAAAnB,MAEA,OADA6C,EAAAN,GAAAM,EAAAN,GAAA,KACAM,GAwBAgC,EAAA4G,KAAA,SAAA3I,EAAAC,GACA,IAAA1C,EACAwC,EAAA7C,KACAW,EAAAkC,EAAAN,EAMA,GAHAQ,GADAD,EAAA,IAAA3B,EAAA2B,EAAAC,IACAR,GAGA5B,IAAAoC,EAAA,OAAA,IAAA5B,EAAAuL,KAGA,GAAA/L,GAAAoC,EAEA,OADAD,EAAAP,GAAAQ,EACAF,EAAA8L,MAAA7L,GAGA,IAAA+L,EAAAhM,EAAA1C,EAAA6B,EACA8M,EAAAhM,EAAA3C,EAAA6B,EACAgB,EAAAH,EAAArC,EACAyC,EAAAH,EAAAtC,EAEA,IAAAqO,IAAAC,EAAA,CAGA,IAAA9L,IAAAC,EAAA,OAAA,IAAA9B,EAAAR,EAAA,GAIA,IAAAqC,EAAA,KAAAC,EAAA,GAAA,OAAAA,EAAA,GAAAH,EAAA,IAAA3B,EAAA6B,EAAA,GAAAH,EAAA,EAAAlC,GAQA,GALAkO,EAAAxM,EAAAwM,GACAC,EAAAzM,EAAAyM,GACA9L,EAAAA,EAAAL,QAGAhC,EAAAkO,EAAAC,EAAA,CAUA,KAPAzO,EAFA,EAAAM,GACAmO,EAAAD,EACA5L,IAEAtC,GAAAA,EACAqC,IAGA0E,UACA/G,IAAAN,EAAA+G,KAAA,IACA/G,EAAAqH,UAUA,KAPA/G,EAAAqC,EAAAhC,SACA+B,EAAAE,EAAAjC,QAGA,IAAAX,EAAA4C,EAAAA,EAAAD,EAAAA,EAAA3C,EAAA0C,EAAApC,GAGAA,EAAA,EAAAoC,GACApC,GAAAqC,IAAAD,GAAAC,EAAAD,GAAAE,EAAAF,GAAApC,GAAAoB,EAAA,EACAiB,EAAAD,GAAAhB,IAAAiB,EAAAD,GAAA,EAAAC,EAAAD,GAAAhB,EAUA,OAPApB,IACAqC,EAAA,CAAArC,GAAAyH,OAAApF,KACA8L,GAKA5F,EAAApG,EAAAE,EAAA8L,IAmBAjK,EAAA2K,UAAA3K,EAAAuE,GAAA,SAAAA,EAAAT,GACA,IAAAnI,EAAAJ,EAAAkG,EAGA,GAAA,MAAA8C,GAAAA,MAAAA,EAKA,OAJAhG,EAAAgG,EAAA,EAAAhH,GACA,MAAAuG,EAAAA,EAAAvD,EACAhC,EAAAuF,EAAA,EAAA,GAEA3B,EAAA,IAAA7F,EAPAnB,MAOAoJ,EAAAT,GAGA,KAAAnI,EAVAR,KAUAQ,GAAA,OAAA,KAIA,GAFAJ,GADAkG,EAAA9F,EAAAQ,OAAA,GACAgB,EAAA,EAEAsE,EAAA9F,EAAA8F,GAAA,CAGA,KAAAA,EAAA,IAAA,EAAAA,GAAA,GAAAlG,KAGA,IAAAkG,EAAA9F,EAAA,GAAA,IAAA8F,EAAAA,GAAA,GAAAlG,MAKA,OAFAgJ,GAvBApJ,KAuBAG,EAAA,EAAAC,IAAAA,EAvBAJ,KAuBAG,EAAA,GAEAC,GAYAyE,EAAA4K,UAAA,SAAAvM,GAEA,OADAE,EAAAF,GAAAjB,EAAAA,GACAjC,KAAA6N,MAAA,KAAA3K,IAeA2B,EAAA6K,WAAA7K,EAAA8K,KAAA,WACA,IAAA9H,EAAAzH,EAAAF,EAAA0P,EAAAvP,EACAwC,EAAA7C,KACAQ,EAAAqC,EAAArC,EACA+B,EAAAM,EAAAN,EACApC,EAAA0C,EAAA1C,EACAiL,EAAAjG,EAAA,EACAmI,EAAA,IAAAnM,EAAA,OAGA,GAAA,IAAAoB,IAAA/B,IAAAA,EAAA,GACA,OAAA,IAAAW,GAAAoB,GAAAA,EAAA,KAAA/B,GAAAA,EAAA,IAAAkM,IAAAlM,EAAAqC,EAAA,EAAA,GA8BA,IATA3C,EAbA,IAJAqC,EAAAd,KAAAkO,MAAA1K,EAAApC,MAIAN,GAAA,EAAA,KACAnC,EAAAkC,EAAA9B,IACAQ,OAAAb,GAAA,GAAA,IAAAC,GAAA,KACAmC,EAAAd,KAAAkO,MAAAvP,GACAD,EAAAkC,GAAAlC,EAAA,GAAA,IAAAA,EAAA,GAAAA,EAAA,GASA,IAAAgB,EANAf,EADAmC,GAAA,EAAA,EACA,KAAApC,GAEAC,EAAAmC,EAAAmB,iBACAf,MAAA,EAAAvC,EAAAwG,QAAA,KAAA,GAAAzG,IAKA,IAAAgB,EAAAoB,EAAA,KAOA/B,EAAA,GAMA,KAJA+B,GADApC,EAAAD,EAAAC,GACAiL,GACA,IAAA7I,EAAA,KAOA,GAHAlC,EAAAH,EACAA,EAAAoN,EAAAO,MAAAxN,EAAAoL,KAAAvH,EAAArB,EAAAxC,EAAA+K,EAAA,KAEA9I,EAAAjC,EAAAG,GAAAmC,MAAA,EAAAJ,MAAAnC,EAAAkC,EAAApC,EAAAM,IAAAmC,MAAA,EAAAJ,GAAA,CAWA,GANArC,EAAAC,EAAAA,KAAAoC,EAMA,SALAnC,EAAAA,EAAAuC,MAAAJ,EAAA,EAAAA,EAAA,MAKAqN,GAAA,QAAAxP,GAgBA,EAIAA,KAAAA,EAAAuC,MAAA,IAAA,KAAAvC,EAAAwD,OAAA,MAGAoD,EAAA9G,EAAAA,EAAAC,EAAAgF,EAAA,EAAA,GACA0C,GAAA3H,EAAA2N,MAAA3N,GAAA8N,GAAAnL,IAGA,MAvBA,IAAA+M,IACA5I,EAAA3G,EAAAA,EAAAF,EAAAgF,EAAA,EAAA,GAEA9E,EAAAwN,MAAAxN,GAAA2N,GAAAnL,IAAA,CACA3C,EAAAG,EACA,MAIA+K,GAAA,EACA7I,GAAA,EACAqN,EAAA,EAkBA,OAAA5I,EAAA9G,EAAAA,EAAAC,EAAAgF,EAAA,EAAAC,EAAAyC,IAaAhD,EAAAnB,cAAA,SAAA0H,EAAAzC,GAKA,OAJA,MAAAyC,IACAhI,EAAAgI,EAAA,EAAAhJ,GACAgJ,KAEA1C,EAAA1I,KAAAoL,EAAAzC,EAAA,IAgBA9D,EAAAgL,QAAA,SAAAzE,EAAAzC,GAKA,OAJA,MAAAyC,IACAhI,EAAAgI,EAAA,EAAAhJ,GACAgJ,EAAAA,EAAApL,KAAAG,EAAA,GAEAuI,EAAA1I,KAAAoL,EAAAzC,IA6BA9D,EAAAiL,SAAA,SAAA1E,EAAAzC,EAAAD,GACA,IAAA/E,EAGA,GAAA,MAAA+E,EACA,MAAA0C,GAAAzC,GAAA,iBAAAA,GACAD,EAAAC,EACAA,EAAA,MACAyC,GAAA,iBAAAA,GACA1C,EAAA0C,EACAA,EAAAzC,EAAA,MAEAD,EAAA9C,OAEA,GAAA,iBAAA8C,EACA,MAAA9H,MACAiB,EAAA,2BAAA6G,GAKA,GAFA/E,EAjBA3D,KAiBA6P,QAAAzE,EAAAzC,GAjBA3I,KAmBAQ,EAAA,CACA,IAAAD,EACAkH,EAAA9D,EAAAoM,MAAA,KACAC,GAAAtH,EAAA5C,UACAmK,GAAAvH,EAAA3C,mBACAC,EAAA0C,EAAA1C,gBAAA,GACAkK,EAAAzI,EAAA,GACA0I,EAAA1I,EAAA,GACA2I,EA3BApQ,KA2BAuC,EAAA,EACA8N,EAAAD,EAAAF,EAAAvN,MAAA,GAAAuN,EACApM,EAAAuM,EAAArP,OAIA,GAFAiP,IAAA1P,EAAAyP,EAAAA,EAAAC,EAAAnM,GAAAmM,EAAA1P,GAEA,EAAAyP,GAAA,EAAAlM,EAAA,CAGA,IAFAvD,EAAAuD,EAAAkM,GAAAA,EACAE,EAAAG,EAAAC,OAAA,EAAA/P,GACAA,EAAAuD,EAAAvD,GAAAyP,EAAAE,GAAAlK,EAAAqK,EAAAC,OAAA/P,EAAAyP,GACA,EAAAC,IAAAC,GAAAlK,EAAAqK,EAAA1N,MAAApC,IACA6P,IAAAF,EAAA,IAAAA,GAGAvM,EAAAwM,EACAD,GAAAxH,EAAAzC,kBAAA,MAAAgK,GAAAvH,EAAAxC,mBACAiK,EAAAtJ,QAAA,IAAA0J,OAAA,OAAAN,EAAA,OAAA,KACA,MAAAvH,EAAAvC,wBAAA,KACAgK,GACAD,EAGA,OAAAxH,EAAA7C,QAAA,IAAAlC,GAAA+E,EAAAtC,QAAA,KAeAvB,EAAA2L,WAAA,SAAAC,GACA,IAAApH,EAAAqH,EAAAC,EAAAC,EAAAzQ,EAAA0Q,EAAAzQ,EAAA0Q,EAAAC,EAAA/E,EAAA9L,EAAAqC,EACAM,EAAA7C,KACAgD,EAAAH,EAAArC,EAEA,GAAA,MAAAiQ,MACArQ,EAAA,IAAAe,EAAAsP,IAGA9C,cAAAvN,EAAAI,GAAA,IAAAJ,EAAAmC,IAAAnC,EAAA4K,GAAA9F,IACA,MAAAtE,MACAiB,EAAA,aACAzB,EAAAuN,YAAA,iBAAA,oBAAA1I,EAAA7E,IAIA,IAAA4C,EAAA,OAAA,IAAA7B,EAAA0B,GAoBA,IAlBAwG,EAAA,IAAAlI,EAAA+D,GACA6L,EAAAL,EAAA,IAAAvP,EAAA+D,GACAyL,EAAAG,EAAA,IAAA3P,EAAA+D,GACA3C,EAAAD,EAAAU,GAIA7C,EAAAkJ,EAAAlJ,EAAAoC,EAAAvB,OAAA6B,EAAA1C,EAAA,EACAkJ,EAAA7I,EAAA,GAAA0B,GAAA2O,EAAA1Q,EAAA6B,GAAA,EAAAA,EAAA6O,EAAAA,GACAJ,GAAAA,GAAA,EAAArQ,EAAA4M,WAAA3D,GAAA,EAAAlJ,EAAAkJ,EAAA0H,EAAA3Q,EAEAyQ,EAAArL,EACAA,EAAA,EAAA,EACApF,EAAA,IAAAe,EAAAoB,GAGAuO,EAAAtQ,EAAA,GAAA,EAGAwL,EAAA9H,EAAA9D,EAAAiJ,EAAA,EAAA,GAEA,IADAuH,EAAAF,EAAAjF,KAAAO,EAAA6B,MAAA8C,KACA3D,WAAAyD,IACAC,EAAAC,EACAA,EAAAC,EACAG,EAAAD,EAAArF,KAAAO,EAAA6B,MAAA+C,EAAAG,IACAD,EAAAF,EACAvH,EAAAjJ,EAAAuO,MAAA3C,EAAA6B,MAAA+C,EAAAvH,IACAjJ,EAAAwQ,EAeA,OAZAA,EAAA1M,EAAAuM,EAAA9B,MAAA+B,GAAAC,EAAA,EAAA,GACAG,EAAAA,EAAArF,KAAAmF,EAAA/C,MAAAkD,IACAL,EAAAA,EAAAjF,KAAAmF,EAAA/C,MAAA8C,IACAG,EAAAvO,EAAAwO,EAAAxO,EAAAM,EAAAN,EAIArC,EAAAgE,EAAA6M,EAAAJ,EAHAxQ,GAAA,EAGAiF,GAAAuJ,MAAA9L,GAAAkK,MAAAC,WACA9I,EAAA4M,EAAAJ,EAAAvQ,EAAAiF,GAAAuJ,MAAA9L,GAAAkK,OAAA,EAAA,CAAAgE,EAAAJ,GAAA,CAAAG,EAAAJ,GAEAlL,EAAAqL,EAEA3Q,GAOA2E,EAAAmM,SAAA,WACA,OAAA/L,EAAAjF,OAeA6E,EAAAoM,YAAA,SAAA7H,EAAAT,GAEA,OADA,MAAAS,GAAAhG,EAAAgG,EAAA,EAAAhH,GACAsG,EAAA1I,KAAAoJ,EAAAT,EAAA,IAeA9D,EAAAG,SAAA,SAAAjC,GACA,IAAAY,EACAvD,EAAAJ,KACAuC,EAAAnC,EAAAmC,EACApC,EAAAC,EAAAD,EA0BA,OAvBA,OAAAA,EACAoC,GACAoB,EAAA,WACApB,EAAA,IAAAoB,EAAA,IAAAA,IAEAA,EAAA,OAIAA,EADA,MAAAZ,EACA5C,GAAAkF,GAAAC,GAAAnF,EACAuD,EAAApB,EAAAlC,EAAAI,GAAAL,GACA0D,GAAAvB,EAAAlC,EAAAI,GAAAL,EAAA,KACA,KAAA4C,EAEAc,GAAAvB,GADAlC,EAAA4G,EAAA,IAAA7F,EAAAf,GAAA+E,EAAAhF,EAAA,EAAAiF,IACA5E,GAAAJ,EAAAD,EAAA,MAEAiD,EAAAL,EAAA,EAAAsD,EAAArF,OAAA,QACAmD,EAAAN,GAAAvB,EAAAlC,EAAAI,GAAAL,EAAA,KAAA,GAAA4C,EAAAR,GAAA,IAGAA,EAAA,GAAAnC,EAAAI,EAAA,KAAAmD,EAAA,IAAAA,IAGAA,GAQAkB,EAAAI,QAAAJ,EAAAqM,OAAA,WACA,OAAAjM,EAAAjF,OAIA6E,EAAA6B,cAAA,EAEArF,IACAwD,EAAAvD,OAAA6P,aAAA,YAGAtM,EAAAvD,OAAA8P,IAAA,+BAAAvM,EAAAI,SAGA,MAAAhB,GAAA9C,EAAAkJ,IAAApG,GAEA9C,EAsIA6C,IACA,QAAA7C,EAAAA,UAAAA,OAOA,IAAAzB,GAAAA,EAAAD,QACAC,EAAAD,QAAA0B,GAKAD,EADAA,IACA,oBAAAnB,MAAAA,KAAAA,KAAAF,SAGAsB,UAAAA,EA51FA,CA81FAnB,2CCx0FAN,EAAOD,QAAU,CACb4R,YAAa,QACbC,WAAY,CACRC,UAAW,IACXhN,QAAS,KAEbiN,cAAe,CACXC,SAAU,IACVC,QAAS,IACTC,QAAS,IACTC,SAAU,KAEdC,gBAAgB,EAChBC,QAAS,SAASC,GACd,IAAIhP,EAAIgP,EAAS,GACjB,OAAkC,MAAvBA,EAAS,IAAM,IAAa,KAAc,GAANhP,EAAW,KAAc,GAANA,EAAW,KAAc,GAANA,EAAW,KAAO,MAE3GiP,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,SACVxR,KAAM,OAEVyR,eAAgB,CACZC,mBAAmB,EACnBC,YAAa,EACbX,gBAAgB,EAChBY,wBAAwB,GAE5BC,QAAS,CACLC,WAAY,CACRH,YAAa,EACbX,gBAAgB,GAEpBe,oBAAqB,CACjBC,OAAQ,WACRN,mBAAmB,EACnBO,SAAU,GAEdC,8BAA+B,CAC3BR,mBAAmB,EACnBO,SAAU,GAEdE,mBAAoB,CAChBH,OAAQ,WACRN,mBAAmB,EACnBO,SAAU,giBCjDtB,IAAMG,EAAcxS,EAAQ,iBACtByS,EAAazS,EAAQ,gBACrB0S,EAAU1S,EAAQ,aAClBU,EAAYV,EAAQ,gBAEpB2S,EAAS,CACXxB,SAAUnQ,KAAKmK,IAAI,GAAI,IACvB+F,QAASlQ,KAAKmK,IAAI,GAAI,GACtB8F,QAASjQ,KAAKmK,IAAI,GAAI,GACtB6F,SAAUhQ,KAAKmK,IAAI,GAAI,IAGrByH,EAAiB,CACnBb,YAAa,EACbc,eAAgB,EAChBC,cAAc,EACdC,SAAS,EACTV,UAAW,EACXW,kBAAkB,EAClBlB,mBAAmB,EACnBV,gBAAgB,EAChB6B,SAAU,OACVC,WAAW,EACXC,iBAAkBnS,KAAKuF,MACvB6M,4BAA4B,KAGYZ,EAAYa,eAAhD7B,IAAAA,eAAgBC,IAAAA,gBAElBF,EAAQ,CACV+B,QAAS,CAAEC,MAAO,KAAMC,SAAU/B,EAAiBgC,OAAQ,MAC3DC,OAAQ,CAAEH,MAAO,KAAMC,SAAUhC,EAAgBiC,OAAQ,KACzD3P,QAAS,CAAEyP,MAAO,IAAMC,SAAU/B,EAAiBgC,OAAQ,MAY/D,SAASE,EAAOC,GAAuC,IAA7BC,EAA6B,EAAAvJ,UAAA/J,aAAAuT,IAAAxJ,UAAA,GAAAA,UAAA,GAAZ,GAAI9K,EAAQ,EAAA8K,UAAA/J,OAAA+J,UAAA,QAAAwJ,EAOnD,GAN8B,iBAAnBD,IACPA,EAAiBnB,EAAQqB,YAAYF,KAG7BpB,EAAWuB,eAAeH,GAGlC,MAAO,wBAGX,IAAIzO,EAASyO,EAAezO,QAAU,GAClC6O,EAAUJ,EAAeI,SAAW,GAEpC7B,EAcR,SAAsBwB,EAAUC,EAAgBrU,GAC5C,OAAQqU,EAAezB,QACnB,IAAK,WAED,OADAyB,EAAiBK,EAAgBL,EAAgBrB,EAAY2B,gCA2MzE,SAAwBP,EAAUC,EAAgBO,GAC9C,IAAMC,EAAkBD,EAAMC,kBAC1BC,EAAeC,OAAOC,OAAO,GAAIX,GACjCY,EAAUF,OAAOC,OAAO,GAAI5B,EAAgB0B,GAC5C9O,OAAmBsO,EACnBY,EAAQ,GACR3B,IAAY0B,EAAQ1C,eAAiB0C,EAAQ3B,cAAgB2B,EAAQ1B,QACrEnB,EAAW0C,EAAaK,kBAAoBN,EAAgBzC,SAC5DD,EAAS2C,EAAaM,gBAAkBP,EAAgB1C,OACtDK,OAA4D,IAAnCyC,EAAQzC,uBACjCyC,EAAQzC,uBAAyByC,EAAQrD,oBAEb0C,IAA9BQ,EAAaO,eACbP,EAAaO,cAAe,GAG5B7C,IACA0C,EAAQ,KAGK,UAAb9C,IACApM,EAAmBkP,EAAQ/C,EAAS+C,GAGxC,IAAItC,EAAS0C,EAAa,CACtBlB,SAAAA,EACAC,eAAgBS,EAChBF,MAAAA,EACA5O,iBAAAA,IAGa,WAAboM,IAEIQ,EADAwB,EAASmB,OAAS,GAA0B,SAArBN,EAAQxB,SACzB,IAAAtL,OAAO+M,GAAP/M,OAAegK,GAAfhK,OAAwByK,EAAOlQ,MAAM,IAClB,EAAlB0R,EAASmB,QAAcN,EAAQvB,UAChC,IAAAvL,OAAO+M,GAAP/M,OAAegK,GAAfhK,OAAwByK,EAAOlQ,MAAM,IAElCyP,EAAS+C,EAAQtC,GAI7BR,GAAyB,YAAbA,IACb8C,GAASD,EAAQrB,4BAA8BL,EAAU,GAAK2B,EAC9DtC,EAASA,EAASsC,EAAQ/C,GAG9B,OAAOS,EAxPQ4C,CAAepB,EAAUC,EAAgBrB,GAEpD,IAAK,UAED,OADAqB,EAAiBK,EAAgBL,EAAgBrB,EAAYyC,kCA6KzE,SAA0BrB,EAAUC,EAAgBO,EAAO5U,GACvD,IAAI0V,EAAerB,EAAeqB,aAE9B9C,EAAS0C,EAAa,CACtBlB,SAAUpU,EAAyB,IAAlBoU,EAASmB,QAC1BlB,eAAAA,EACAO,MAAAA,IAEAK,EAAUF,OAAOC,OAAO,GAAI5B,EAAgBiB,GAEhD,GAAIqB,EACA,MAAA,IAAAvN,OAAW8M,EAAQrD,eAAiB,IAAM,IAA1CzJ,OAA+CyK,GAGnD,MAAA,GAAAzK,OAAUyK,GAAVzK,OAAmB8M,EAAQrD,eAAiB,IAAM,GAAlD,KA1Le+D,CAAiBvB,EAAUC,EAAgBrB,EAAahT,GAEnE,IAAK,OAED,OADAqU,EAAiBK,EAAgBL,EAAgBrB,EAAY4C,4BAkGzE,SAAoBxB,EAAUC,EAAgBO,EAAO5U,GACjD,IAAI2H,EAAO0M,EAAe1M,MAAQ,SAC9BsN,EAAUF,OAAOC,OAAO,GAAI5B,EAAgBiB,GAFSwB,EAI8BjB,EAAMf,eAArEiC,EAJiCD,EAIjD7D,eAAsD+D,EAJLF,EAIZ5D,gBAOzC+D,EALe,CACflC,QAAS,CAAEC,MAAO,KAAMC,SAAU+B,GAAwB9D,EAAiBgC,OAAQ,MACnFC,OAAQ,CAAEH,MAAO,KAAMC,SAAU8B,GAAuB9D,EAAgBiC,OAAQ,KAChF3P,QAAS,CAAEyP,MAAO,IAAMC,SAAU+B,GAAwB9D,EAAiBgC,OAAQ,MAE7DtM,GAX+BsO,EAajCC,EAAmB9B,EAASmB,OAAQS,EAAShC,SAAUgC,EAASjC,OAAlFoC,EAbmDF,EAanDE,MAAOhQ,EAb4C8P,EAa5C9P,OAETyM,EAAS0C,EAAa,CACtBlB,SAAUpU,EAAOmW,GACjB9B,eAAAA,EACAO,MAAAA,EACAwB,SAAUxB,EAAMgB,6BAGpB,MAAA,GAAAzN,OAAUyK,GAAVzK,OAAmB8M,EAAQrD,eAAiB,IAAM,IAAlDzJ,OAAuDhC,GAvHxCkQ,CAAWjC,EAAUC,EAAgBrB,EAAahT,GAC7D,IAAK,OAED,OADAqU,EAAiBK,EAAgBL,EAAgBrB,EAAYsD,4BAqJzE,SAAoBlC,GAChB,IAAImC,EAAQ/U,KAAKG,MAAMyS,EAASmB,OAAS,GAAK,IAC1CiB,EAAUhV,KAAKG,OAAOyS,EAASmB,OAAkB,GAARgB,EAAa,IAAO,IAC7DE,EAAUjV,KAAKuF,MAAMqN,EAASmB,OAAkB,GAARgB,EAAa,GAAiB,GAAVC,GAChE,MAAA,GAAArO,OAAUoO,EAAV,KAAApO,OAAoBqO,EAAU,GAAM,IAAM,IAA1CrO,OAA+CqO,EAA/C,KAAArO,OAA2DsO,EAAU,GAAM,IAAM,IAAjFtO,OAAsFsO,GAxJvEC,CAAWtC,GACtB,IAAK,UAED,OADAC,EAAiBK,EAAgBL,EAAgBrB,EAAY2D,+BA8HzE,SAAuBvC,EAAUC,EAAgBO,GAC7C,IAAIgC,EAAYhC,EAAMiC,iBAClB5B,EAAUF,OAAOC,OAAO,GAAI5B,EAAgBiB,GAE5CzB,EAAS0C,EAAa,CACtBlB,SAAAA,EACAC,eAAAA,EACAO,MAAAA,IAEA/C,EAAU+E,EAAUxC,EAASmB,QAEjC,MAAA,GAAApN,OAAUyK,GAAVzK,OAAmB8M,EAAQrD,eAAiB,IAAM,IAAlDzJ,OAAuD0J,GAxIxCiF,CAAc1C,EAAUC,EAAgBrB,GACnD,IAAK,SACL,QACI,OAAOsC,EAAa,CAChBlB,SAAAA,EACAC,eAAAA,EACArU,OAAAA,KAtCC+W,CAAa3C,EAAUC,EAAgBrU,GAGpD,OADA4S,GADAA,EAA8BhN,EAARgN,GACS6B,EAsFnC,SAASyB,EAAmBC,EAAOnC,EAAUD,GACzC,IAAI5N,EAAS6N,EAAS,GAClBlH,EAAMtL,KAAKsL,IAAIqJ,GAEnB,GAAWpC,GAAPjH,EAAc,CACd,IAAK,IAAIkK,EAAQ,EAAGA,EAAQhD,EAASjT,SAAUiW,EAAO,CAClD,IAAI5T,EAAM5B,KAAKmK,IAAIoI,EAAOiD,GACtB3T,EAAM7B,KAAKmK,IAAIoI,EAAOiD,EAAQ,GAElC,GAAW5T,GAAP0J,GAAcA,EAAMzJ,EAAK,CACzB8C,EAAS6N,EAASgD,GAClBb,GAAgB/S,EAChB,OAKJ+C,IAAW6N,EAAS,KACpBmC,GAAgB3U,KAAKmK,IAAIoI,EAAOC,EAASjT,OAAS,GAClDoF,EAAS6N,EAASA,EAASjT,OAAS,IAI5C,MAAO,CAAEoV,MAAAA,EAAOhQ,OAAAA,GAiQpB,SAAS8Q,EAAOnF,GAEZ,IADA,IAAIoF,EAAS,GACJ5W,EAAI,EAAGA,EAAIwR,EAAQxR,IACxB4W,GAAU,IAGd,OAAOA,EAmDX,SAAStH,EAAQuG,EAAO5G,EAAxB,GAAkE,IAA/BoE,EAA+B,EAAA7I,UAAA/J,aAAAuT,IAAlE,EAAA,EAAsD9S,KAAKuF,MACvD,OAAuC,IAAnCoP,EAAMpR,WAAW4B,QAAQ,KAzCjC,SAAsBwP,EAAO5G,GACzB,IAAI2H,EAASf,EAAMpR,WADiBoS,EAAAC,EAGlBF,EAAOpH,MAAM,KAHK,GAG/BnI,EAH+BwP,EAAA,GAGzBvG,EAHyBuG,EAAA,GAAAE,EAAAD,EAKEzP,EAAKmI,MAAM,KALb,GAK/BuD,EAL+BgE,EAAA,GAAAC,EAAAD,EAAA,GAKfxE,OALe,IAAAyE,EAKJ,GALIA,EAOpC,GAAW,GAAN1G,EACDsG,EAAS7D,EAAiBR,EAAWoE,EAAOrG,EAAMiC,EAAS9R,YACxD,CACH,IAAI6E,EAAS,IAGTA,GADCyN,EAAiB,EACZ,KAAAlL,OAAQvC,GAER,IAAAuC,OAAOvC,GAGjB,IAAIO,GAAU8Q,GAAQrG,EAAM,GAAKpP,KAAKsL,IAAIuG,GAAkBR,GAAUxC,OAAO,EAAGd,GAC5EpJ,EAAOpF,OAASwO,IAChBpJ,GAAU8Q,EAAO1H,EAAYpJ,EAAOpF,SAExCmW,EAAStR,EAASO,EAOtB,OAJW,GAANyK,GAAuB,EAAZrB,IACZ2H,GAAM,IAAA/O,OAAQ8O,EAAO1H,KAGlB2H,EAaIK,CAAapB,EAAO5G,GAGrB,IAAIrO,EAAUyS,GAAiB,GAAAxL,OAAIgO,EAAJ,MAAAhO,OAAcoH,IAAgB/N,KAAKmK,IAAI,GAAI4D,IAC3EK,QAAQL,GA6GrB,SAASiI,EAAkB5E,EAAQuD,EAAO7D,EAAmBsC,EAAO5O,GAChE,IAAIqL,EAAauD,EAAM6C,oBACnBC,EAAoBrG,EAAWC,UACnCtL,EAAmBA,GAAoBqL,EAAW/M,QAClD,IAAIqT,EAAgBtG,EAAWsG,eAAiB,EAE5CT,EAAStE,EAAO7N,WAChBsO,EAAiB6D,EAAOpH,MAAM,KAAK,GACnC+C,EAAWqE,EAAOpH,MAAM,KAAK,GAC3B8H,EAAkBzB,EAAQ,GAAqC,IAAhC9C,EAAe1M,QAAQ,KAExD2L,IACIsF,IAEAvE,EAAiBA,EAAe3Q,MAAM,IAvClD,SAA8B6P,EAAa1M,GAGvC,IAFA,IAAIqR,EAAS,GACTW,EAAU,EACLvX,EAAIiS,EAAiB,EAAJjS,EAAOA,IACzBuX,IAAYhS,IACZqR,EAAOY,QAAQxX,GACfuX,EAAU,GAEdA,IAGJ,OAAOX,EA+BqCa,CAAqB1E,EAAetS,OAAQ4W,GAClDK,QAAQ,SAAC5F,EAAU6F,GACjD5E,EAAiBA,EAAe3Q,MAAM,EAAG0P,EAAW6F,GAASP,EAAoBrE,EAAe3Q,MAAM0P,EAAW6F,KAGjHL,IAEAvE,EAAc,IAAAlL,OAAOkL,KAS7B,OAFI6D,EAHCrE,EAGQQ,EAAiBrN,EAAmB6M,EAFpCQ,EAiFjB,SAASiC,EAAT4C,GAA+H,IAAvG9D,EAAuG8D,EAAvG9D,SAAUC,EAA6F6D,EAA7F7D,eAA6F8D,EAAAD,EAA7EtD,MAAAA,OAA6E,IAAAuD,EAArEnF,EAAqEmF,EAAxDnS,EAAwDkS,EAAxDlS,iBAAwDoS,EAAAF,EAAtC9B,SAAAA,OAAsC,IAAAgC,EAA3BxD,EAAMyD,kBAAqBD,EACvHjC,EAAQ/B,EAASmB,OAErB,GAAc,IAAVY,GAAevB,EAAM0D,gBACrB,OAAO1D,EAAM2D,gBAGjB,IAAKvK,SAASmI,GACV,OAAOA,EAAMpR,WAGjB,IApUJyT,EAA8BrC,EAAsCsC,EAA/BC,EAA+BC,EAC3DC,EAAcC,EACf/G,EAkUAmD,EAAUF,OAAOC,OAAO,GAAI5B,EAAgBgD,EAAU/B,GAEtD9B,EAAc0C,EAAQ1C,YACtBmG,EAA0BnG,EAAc,EAAI0C,EAAQ5B,eACpDyF,EAAyB7D,EAAQ6D,uBACjCxF,EAAe2B,EAAQ3B,aACvB+B,EAAeJ,EAAQI,aACvB9B,IAAYhB,KAAiBe,GAAgB2B,EAAQ1B,QAGrDwF,EAAoBxG,GAAe,EAAKgB,QAAuCe,IAA5BD,EAAexB,SAAyB,EAAIoC,EAAQpC,SACvGW,GAAmBjB,SAA2D+B,IAApCD,EAAeb,kBAAwD,IAAvBuF,EAA2B9D,EAAQzB,kBAC7HwF,EAAe/D,EAAQ+D,aACvB1G,EAAoB2C,EAAQ3C,kBAC5BV,EAAiBqD,EAAQrD,eACzB6B,EAAWwB,EAAQxB,SACnBC,EAAYuB,EAAQvB,UACpBmF,EAAc5D,EAAQ4D,YACtBlF,EAAmBsB,EAAQtB,iBAE3BsF,EAAe,GACnB,GAAI1F,EAAS,CACT,IAAI2F,EAjZZ,SAAAC,GAA6J,IAAnIhD,EAAmIgD,EAAnIhD,MAAO7C,EAA4H6F,EAA5H7F,aAA4H8F,EAAAD,EAA9G9D,aAAAA,OAA8G,IAAA+D,GAAAA,EAAzF7H,EAAyF4H,EAAzF5H,cAAyF8H,EAAAF,EAA1EvH,eAAAA,OAA0E,IAAAyH,GAAAA,EAAAC,EAAAH,EAAlD5G,YAAAA,OAAkD,IAAA+G,EAApC,EAAoCA,EAAAC,EAAAJ,EAAjCxF,iBAAAA,OAAiC,IAAA4F,EAAd/X,KAAKuF,MAASwS,EACrJN,EAAe,GACfnM,EAAMtL,KAAKsL,IAAIqJ,GACf4C,GAAqB,EA+BzB,GA7BIzF,GAAgB/B,EAAc+B,IAAiBH,EAAOG,IACtD2F,EAAe1H,EAAc+B,GAC7B6C,GAAgBhD,EAAOG,IAEnBxG,GAAOqG,EAAOxB,UAAa0D,GAA4D,IAA5C1B,EAAiB7G,EAAMqG,EAAOxB,WAEzEsH,EAAe1H,EAAcI,SAC7BwE,GAAgBhD,EAAOxB,UAChB7E,EAAMqG,EAAOxB,UAAY7E,GAAOqG,EAAOzB,SAAY2D,GAA2D,IAA3C1B,EAAiB7G,EAAMqG,EAAOzB,UAExGuH,EAAe1H,EAAcG,QAC7ByE,GAAgBhD,EAAOzB,SAChB5E,EAAMqG,EAAOzB,SAAW5E,GAAOqG,EAAO1B,SAAY4D,GAA2D,IAA3C1B,EAAiB7G,EAAMqG,EAAO1B,UAEvGwH,EAAe1H,EAAcE,QAC7B0E,GAAgBhD,EAAO1B,UAChB3E,EAAMqG,EAAO1B,SAAW3E,GAAOqG,EAAO3B,UAAa6D,GAA4D,IAA5C1B,EAAiB7G,EAAMqG,EAAO3B,aAExGyH,EAAe1H,EAAcC,SAC7B2E,GAAgBhD,EAAO3B,UAO3ByH,EADAA,IAFgBrH,EAAiB,IAAM,IAGRqH,EAG/B1G,EAAa,CACb,IAAIhE,EAAa4H,EAAQ,EACrB9C,EAAiB8C,EAAMpR,WAAW+K,MAAM,KAAK,GAE7C0J,EAAuBjL,EACrB8E,EAAetS,OAAS,EACxBsS,EAAetS,OAErBgY,EAAoBvX,KAAK6B,IAAIkP,EAAciH,EAAsB,GAGrE,MAAO,CAAErD,MAAAA,EAAO8C,aAAAA,EAAcF,kBAAAA,GAoWfU,CAAe,CACtBtD,MAAAA,EACA7C,aAAAA,EACA+B,aAAAA,EACA9D,cAAeqD,EAAM8E,uBACrB9H,eAAAA,EACA+B,iBAAAA,EACApB,YAAAA,IAGJ4D,EAAQ+C,EAAK/C,MACb8C,GAAgBC,EAAKD,aAEjB1G,IACAwG,EAAoBG,EAAKH,mBAIjC,GAAIF,EAAa,CACb,IAAIc,GA7WkBxD,GAA9BqC,EA6WsC,CAC1BrC,MAAAA,EACAuC,wBAAAA,IA/WkBvC,MAAsCsC,EAAAD,EAA/BE,wBAAAA,OAA+B,IAAAD,EAAL,EAAKA,EAAAE,EAAAvB,EAC9BjB,EAAM1S,gBAAgBqM,MAAM,KADE,GAC3D8I,EAD2DD,EAAA,GAC7CE,EAD6CF,EAAA,GAE5D7G,GAAU8G,EAETF,GAOsB,EAEAA,IACvB5G,GAAkBtQ,KAAKmK,IAAI,GAAI+M,EAHR,GAKvBG,EAA6B,IAD7BA,GAA8BH,EAJP,GAKT,IAAAvQ,OAAuB0Q,GAAgBA,GAGlD,CACH1C,MAAOrE,EACPmH,aAAY,IAAA9Q,OAAM0Q,KA6VlB1C,EAAQwD,EAAKxD,MACb8C,EAAeU,EAAKV,aAAeA,EAGvC,IAnHgBrG,EAAQuD,EAAO1C,EAmH3Bb,EA3QR,SAA8BA,EAAQuD,EAAO3C,EAAkBjE,EAAWqK,EAAMjG,GAC5E,IAAmB,IAAfpE,EACA,OAAOqD,EAGX,IAAIsE,EAAStH,EAAQuG,EAAO5G,EAAWoE,GALuDkG,EAAAzC,EAM1CF,EAAOnS,WAAW+K,MAAM,KANkB,GAMzFgK,EANyFD,EAAA,GAAAE,EAAAF,EAAA,GAMlEG,OANkE,IAAAD,EAMhD,GANgDA,EAQ9F,GAAIC,EAAgBC,MAAM,UAAYzG,GAAoBoG,GACtD,OAAOE,EAGX,IAAII,EAAoBF,EAAgBC,MAAM,OAC9C,OAAIL,GAAQM,EACR,GAAA/R,OAAU2R,EAAV,KAAA3R,OAAmC6R,EAAgBjV,WAAWrC,MAAM,EAAGwX,EAAkBjC,QAGtFf,EAAOnS,WA0PDoV,CAAqBhE,EAAMpR,WAAYoR,EAAO3C,EAAkBuF,EAAmBC,EAAcrF,GAY9G,OAVAf,EAAS4E,EADT5E,EA/OJ,SAAoCA,EAAQuD,EAAO2C,EAAwBvJ,GACvE,IAAI2H,EAAStE,EADqEwH,EAAAhD,EAEnCF,EAAOnS,WAAW+K,MAAM,KAFW,GAE7EgK,EAF6EM,EAAA,GAEtDJ,EAFsDI,EAAA,GAIlF,GAAIN,EAAsBG,MAAM,UAAYnB,EACxC,OAAKkB,EAIL,GAAA7R,OAAU2R,EAAsBlT,QAAQ,IAAK,IAA7C,KAAAuB,OAAoD6R,GAHzCF,EAAsBlT,QAAQ,IAAK,IAMlD,IAAMgR,EAAkBzB,EAAQ,GAA4C,IAAvC2D,EAAsBnT,QAAQ,KAOnE,GANIiR,IAEIkC,EAAwBA,EAAsBpX,MAAM,GACpDwU,EAASA,EAAOxU,MAAM,IAG1BoX,EAAsB/Y,OAASwO,EAE/B,IADA,IAAI8K,EAAe9K,EAAYuK,EAAsB/Y,OAC5CT,EAAI,EAAGA,EAAI+Z,EAAc/Z,IAC9B4W,EAAM,IAAA/O,OAAO+O,GAQrB,OAJIU,IAEAV,EAAM,IAAA/O,OAAO+O,IAEVA,EAAOnS,WAiNLuV,CAA2B1H,EAAQuD,EAAO2C,EAAwBJ,GACxCvC,EAAO7D,EAAmBsC,EAAO5O,IAEhEuN,GAAWsF,KACXjG,EAA4BA,EAAQqG,IAGpCvF,GAAayC,EAAQ,KA3HTvD,EA4HQA,EA5HOa,EA4HQA,EAAnCb,EA3HU,KADUuD,EA4HQA,GA1HrBvD,EAGK,IAAXA,EACMA,EAAOhM,QAAQ,IAAK,IAGnB,EAARuP,EACA,IAAAhO,OAAWyK,GAGE,SAAba,EACOb,EAGX,IAAAzK,OAAWyK,EAAOhM,QAAQ,IAAK,IAA/B,MA8GOgM,EAUX,SAAS8B,EAAgBL,EAAgBkG,GACrC,IAAKlG,EACD,OAAOkG,EAGX,IAAIC,EAAOzF,OAAOyF,KAAKnG,GACvB,OAAoB,IAAhBmG,EAAKzZ,QAA4B,WAAZyZ,EAAK,GACnBD,EAGJlG,EAGX5U,EAAOD,QAAU,SAACQ,GAAD,MAAa,CAC1ByI,OAAQ,WAAA,IAAA,IAAAgS,EAAA3P,UAAA/J,OAAIgI,EAAJ,IAAA2R,MAAAD,GAAAE,EAAA,EAAAA,EAAAF,EAAAE,IAAI5R,EAAJ4R,GAAA7P,UAAA6P,GAAA,OAAaxG,EAAMyG,WAAN,EAAU7R,EAAVZ,OAAA,CAAgBnI,MACrC6a,YAAa,WAAA,IAAA,IAAAC,EAAAhQ,UAAA/J,OAAIgI,EAAJ,IAAA2R,MAAAI,GAAAC,EAAA,EAAAA,EAAAD,EAAAC,IAAIhS,EAAJgS,GAAAjQ,UAAAiQ,GAAA,OAlqBjB,SAAqB3G,GACjB,IAAI8E,EAAOnH,EAAM+B,QACjB,OAAOoC,EAAmB9B,EAASmB,OAAQ2D,EAAKlF,SAAUkF,EAAKnF,OAAO5N,QAgqBjCyU,WAAX,EAAe7R,EAAfZ,OAAA,CAAqBnI,MAC/Cgb,kBAAmB,WAAA,IAAA,IAAAC,EAAAnQ,UAAA/J,OAAIgI,EAAJ,IAAA2R,MAAAO,GAAAC,EAAA,EAAAA,EAAAD,EAAAC,IAAInS,EAAJmS,GAAApQ,UAAAoQ,GAAA,OA/qBvB,SAA2B9G,GACvB,IAAI8E,EAAOnH,EAAMmC,OACjB,OAAOgC,EAAmB9B,EAASmB,OAAQ2D,EAAKlF,SAAUkF,EAAKnF,OAAO5N,QA6qBrByU,WAAjB,EAAqB7R,EAArBZ,OAAA,CAA2BnI,MAC3Dmb,mBAAoB,WAAA,IAAA,IAAAC,EAAAtQ,UAAA/J,OAAIgI,EAAJ,IAAA2R,MAAAU,GAAAC,EAAA,EAAAA,EAAAD,EAAAC,IAAItS,EAAJsS,GAAAvQ,UAAAuQ,GAAA,OA5rBxB,SAA4BjH,GACxB,IAAI8E,EAAOnH,EAAMzN,QACjB,OAAO4R,EAAmB9B,EAASmB,OAAQ2D,EAAKlF,SAAUkF,EAAKnF,OAAO5N,QA0rBnByU,WAAlB,EAAsB7R,EAAtBZ,OAAA,CAA4BnI,MAC7D0U,gBAAAA,2GCzyBJ,IAAM4G,EAAO9a,EAAQ,WACfyS,EAAazS,EAAQ,gBACrB0S,EAAU1S,EAAQ,aAEpBoU,EAAQ,GAER2G,OAAqBjH,EACrBkH,EAAY,GAEZC,EAAa,KAEbC,EAAiB,GAErB,SAASC,EAAeC,GAAOL,EAAqBK,EAEpD,SAASC,IAAwB,OAAOL,EAAUD,GAOlD3G,EAAM4G,UAAY,WAAA,OAAMzG,OAAOC,OAAO,GAAIwG,IAW1C5G,EAAMkH,gBAAkB,WAAA,OAAMP,GAO9B3G,EAAMf,aAAe,WAAA,OAAMgI,IAAsB9J,OAAS,IAO1D6C,EAAMC,gBAAkB,WAAA,OAAMgH,IAAsB3J,UAOpD0C,EAAM8E,qBAAuB,WAAA,OAAMmC,IAAsBtK,eAOzDqD,EAAM6C,kBAAoB,WAAA,OAAMoE,IAAsBxK,YAOtDuD,EAAMiC,eAAiB,WAAA,OAAMgF,IAAsBhK,SAYnD+C,EAAMyD,gBAAkB,WAAA,OAAMtD,OAAOC,OAAO,GAAI6G,IAAsBzF,SAAUsF,IAQhF9G,EAAM+B,4BAA8B,WAAA,OAAM5B,OAAOC,OAAO,GAAIJ,EAAMyD,kBAAmBwD,IAAsBE,gBAQ3GnH,EAAMgB,yBAA2B,WAAA,OAAMb,OAAOC,OAAO,GAAIJ,EAAMyD,kBAAmBwD,IAAsBG,aAQxGpH,EAAMa,+BAAiC,WAAA,OAAMV,OAAOC,OAAO,GAAIJ,EAAMyD,kBAAmBwD,IAAsBI,mBAQ9GrH,EAAMD,6BAA+B,WAAA,OAAMI,OAAOC,OAAO,GAAIJ,EAAMyD,kBAAmBwD,IAAsBxJ,iBAQ5GuC,EAAM0B,yBAA2B,WAAA,OAAMvB,OAAOC,OAAO,GAAIJ,EAAMyD,kBAAmBwD,IAAsBK,aAOxGtH,EAAMuH,YAAc,SAAC1T,GACjBA,EAASyK,EAAQqB,YAAY9L,GACzBwK,EAAWuB,eAAe/L,KAC1BiT,EAAiBjT,IAazBmM,EAAM2D,cAAgB,WAAA,OAAMkD,GAO5B7G,EAAMwH,cAAgB,SAACC,GAAD,OAAYZ,EAAgC,iBAAZY,EAAuBA,EAAS,MAOtFzH,EAAM0D,cAAgB,WAAA,OAAqB,OAAfmD,GAe5B7G,EAAM0H,aAAe,SAACV,GAClB,GAAIA,EAAK,CACL,GAAIJ,EAAUI,GACV,OAAOJ,EAAUI,GAErB,MAAM,IAAIjb,MAAJ,gBAAAwH,OAA0ByT,EAA1B,MAGV,OAAOC,KAYXjH,EAAM2H,iBAAmB,SAACrD,GAA8B,IAAxBsD,EAAwB,EAAA1R,UAAA/J,aAAAuT,IAAAxJ,UAAA,IAAAA,UAAA,GACpD,IAAKmI,EAAWwJ,iBAAiBvD,GAC7B,MAAM,IAAIvY,MAAM,yBAGpB6a,EAAUtC,EAAK9H,aAAe8H,EAE1BsD,GACAb,EAAezC,EAAK9H,cAc5BwD,EAAM8H,YAAc,SAACd,GAAwC,IAAnCe,EAAmC,EAAA7R,UAAA/J,aAAAuT,IAAAxJ,UAAA,GAAAA,UAAA,GAArBwQ,EAAKlK,YACzC,IAAKoK,EAAUI,GAAM,CACjB,IAAIzV,EAASyV,EAAI9L,MAAM,KAAK,GAExB8M,EAAsB7H,OAAOyF,KAAKgB,GAAWqB,KAAK,SAAAC,GAClD,OAAOA,EAAKhN,MAAM,KAAK,KAAO3J,IAGlC,OAAKqV,EAAUoB,QAKfjB,EAAeiB,QAJXjB,EAAegB,GAQvBhB,EAAeC,IAGnBhH,EAAM2H,iBAAiBjB,GACvBC,EAAqBD,EAAKlK,YAE1B3R,EAAOD,QAAUoV,kFCvNjBnV,EAAOD,QAAU,SAACQ,GAAD,MAAa,CAC1B+c,oBAAqB,SAACC,GAAD,OAhBUhd,EAgB0BA,OAANgd,EAf9ChF,QAAQ,SAAC4D,GACV,IAAI1C,OAAO5E,EACX,IACI4E,EAAO1Y,EAAO,gBAAA2H,OAAiByT,IACjC,MAAO1b,GACL+c,QAAQC,MAAR,mBAAA/U,OAAiCyT,EAAjC,wCAGA1C,GACAlZ,EAAOuc,iBAAiBrD,KAVpC,IAAmClZ,0CCPnC,IAAMkB,EAAYV,EAAQ,gBAgC1B,SAAS2c,EAAShd,EAAGid,EAAOpd,GACxB,IAAImW,EAAQ,IAAIjV,EAAUf,EAAEoV,QACxB8H,EAAaD,EASjB,OAPIpd,EAAOsd,SAASF,KAChBC,EAAaD,EAAM7H,QAGvB8H,EAAa,IAAInc,EAAUmc,GAE3Bld,EAAEoV,OAASY,EAAMzH,MAAM2O,GAAYtM,WAC5B5Q,EAiFXV,EAAOD,QAAU,SAAAQ,GAAM,MAAK,CACxBud,IAAK,SAACpd,EAAGid,GAAJ,OAnHOA,EAmHcA,EAnHPpd,EAmHcA,EAlH7BmW,EAAQ,IAAIjV,GADPf,EAmHcA,GAlHKoV,QACxB8H,EAAaD,EAEbpd,EAAOsd,SAASF,KAChBC,EAAaD,EAAM7H,QAGvB8H,EAAa,IAAInc,EAAUmc,GAE3Bld,EAAEoV,OAASY,EAAM3K,KAAK6R,GAAYtM,WAC3B5Q,EAXX,IAAaA,EAAGid,EAAOpd,EACfmW,EACAkH,GAkHJ9U,SAAU,SAACpI,EAAGid,GAAJ,OAAcD,EAAShd,EAAGid,EAAOpd,IAC3C0H,SAAU,SAACvH,EAAGid,GAAJ,OAzEOA,EAyEmBA,EAzEZpd,EAyEmBA,EAxEvCmW,EAAQ,IAAIjV,GADFf,EAyEmBA,GAxELoV,QACxB8H,EAAaD,EAEbpd,EAAOsd,SAASF,KAChBC,EAAaD,EAAM7H,QAGvB8H,EAAa,IAAInc,EAAUmc,GAE3Bld,EAAEoV,OAASY,EAAMvI,MAAMyP,GAAYtM,WAC5B5Q,EAXX,IAAkBA,EAAGid,EAAOpd,EACpBmW,EACAkH,GAwEJG,OAAQ,SAACrd,EAAGid,GAAJ,OApDOA,EAoDiBA,EApDVpd,EAoDiBA,EAnDnCmW,EAAQ,IAAIjV,GADJf,EAoDiBA,GAnDDoV,QACxB8H,EAAaD,EAEbpd,EAAOsd,SAASF,KAChBC,EAAaD,EAAM7H,QAGvB8H,EAAa,IAAInc,EAAUmc,GAE3Bld,EAAEoV,OAASY,EAAMlJ,UAAUoQ,GAAYtM,WAChC5Q,EAXX,IAAgBA,EAAGid,EAAOpd,EAClBmW,EACAkH,GAmDJjT,IAAK,SAACjK,EAAGid,GAAJ,OA/BKjd,EA+BaA,EA9BnBgW,EADSiH,EA+BaA,EAAOpd,EA5BtBsd,SAASF,KAChBjH,EAAQiH,EAAM7H,QAGlBpV,EAAEoV,OAASY,EACJhW,EARX,IAAcA,EAAGid,EACTjH,GA+BJsH,WAAY,SAACtd,EAAGid,GAAJ,OAbOA,EAaqBA,EAXxCD,EADIpZ,GADsB/D,EAaqBA,GAAVG,EAZhBoV,QACL6H,EAAOpd,GAEhBwB,KAAKsL,IAAI/I,EAAMwR,QAJ1B,IAAuB6H,EAAOpd,EACtB+D,GAaJ7C,UAAWA,+NCnIf,IAEM8R,EAAcxS,EAAQ,iBACtBkd,EAAYld,EAAQ,gBACpBmd,EAASnd,EAAQ,YAARA,CAAqBR,GAC9B4d,EAAcpd,EAAQ,kBACxBqd,EAAYrd,EAAQ,eAARA,CAAwBR,GACpC8d,EAAatd,EAAQ,iBAARA,CAA0BR,GACrCkT,EAAU1S,EAAQ,aAElBud,aACF,SAAAA,EAAYjM,gGAAQkM,CAAAje,KAAAge,GAChBhe,KAAKwV,OAASzD,yDAGR,OAAO9R,EAAOD,KAAKwV,0CAET,IAAbpB,EAAa,EAAArJ,UAAA/J,aAAAuT,QAAJ,GAAM,OAAOuJ,EAAUpV,OAAO1I,KAAMoU,0CAErC1L,GAMX,MALsB,iBAAXA,IACPA,EAASyK,EAAQqB,YAAY9L,KAEjCA,EAASoV,EAAUnJ,gBAAgBjM,EAAQuK,EAAY2B,iCAChD/B,OAAS,WACTiL,EAAUpV,OAAO1I,KAAM0I,yCAGV,IAAbA,EAAa,EAAAqC,UAAA/J,aAAAuT,QAAJ,GAEhB,OADA7L,EAAOmK,OAAS,OACTiL,EAAUpV,OAAO1I,KAAM0I,6CAGd,OAAOoV,EAAU7C,kBAAkBjb,iDAElC,OAAO8d,EAAU1C,mBAAmBpb,0CAE3C,OAAO8d,EAAUhD,YAAY9a,yCAEhCqd,GAAS,OAAOU,EAAWL,WAAW1d,KAAMqd,+BAEnDA,GAAS,OAAOU,EAAWP,IAAIxd,KAAMqd,oCAEhCA,GAAS,OAAOU,EAAWvV,SAASxI,KAAMqd,oCAE1CA,GAAS,OAAOU,EAAWpW,SAAS3H,KAAMqd,kCAE5CA,GAAS,OAAOU,EAAWN,OAAOzd,KAAMqd,+BAE3Ca,GAAS,OAAOH,EAAW1T,IAAIrK,KAAMme,EAAeD,oCAE9C,OAAOle,KAAKwV,yCAEV,OAAOxV,KAAKwV,4CAS5B,SAAS2I,EAAeD,GACpB,IAAI/G,EAAS+G,EASb,OARIje,EAAOsd,SAASW,GAChB/G,EAAS+G,EAAM1I,OACS,iBAAV0I,EACd/G,EAASlX,EAAOme,SAASF,GAClBvR,MAAMuR,KACb/G,EAASzK,KAGNyK,EAGX,SAASlX,EAAOie,GACZ,OAAO,IAAIF,EAAOG,EAAeD,IAGrCje,EAAOoe,QA/ES,QAiFhBpe,EAAOsd,SAAW,SAASe,GACvB,OAAOA,aAAkBN,GAO7B/d,EAAOse,SAAWtL,EAAY8I,gBAC9B9b,EAAOuc,iBAAmBvJ,EAAYuJ,iBACtCvc,EAAO0c,YAAc1J,EAAY0J,YACjC1c,EAAOwb,UAAYxI,EAAYwI,UAC/Bxb,EAAOsc,aAAetJ,EAAYsJ,aAClCtc,EAAOyb,WAAazI,EAAYoJ,cAChCpc,EAAOua,cAAgBvH,EAAYqF,gBACnCrY,EAAOmc,YAAcnJ,EAAYmJ,YACjCnc,EAAOue,sBAAwBvL,EAAY2B,6BAC3C3U,EAAOwe,SAAWd,EAAUc,SAC5Bxe,EAAO+c,oBAAsBY,EAAOZ,oBACpC/c,EAAOme,SAAWP,EAAYO,SAC9Bne,EAAOkB,UAAY4c,EAAW5c,UAE9BzB,EAAOD,QAAUQ,6JC8LjBP,EAAOD,QAAU,CACb+U,YAzBJ,SAAqB8H,GAAqB,IAtQrBA,EAAQnF,EACrB+C,EAgBcoC,EAAQnF,EACtB+C,EA+F0B/C,EAC1B+C,EAc6B/C,EAE7B+C,EA2CsB/C,EAaHmF,EAAQnF,EAmBJmF,EAAQnF,EA9CJA,EACzBrE,EA9E8BqE,EAaHA,EA2IdmF,EAAQnF,EAeCA,EAaHA,EAAa,EAAApM,UAAA/J,aAAAuT,IAAAxJ,UAAA,GAAAA,UAAA,GAAJ,GAClC,MAAsB,iBAAXuR,EACAA,GAxQcnF,EA2QIA,EAA7BmF,GA1QIpC,GADaoC,EA2QIA,GA1QFpC,MAAM,gBAErB/C,EAAOtR,OAASqU,EAAM,GACfoC,EAAO3Z,MAAMuX,EAAM,GAAGlZ,SAG1Bsb,EAUmBnF,EA2PIA,EA1OlC,SAAqBmF,EAAQnF,GACzB,IAA6B,IAAzBmF,EAAO1V,QAAQ,KAAnB,CAKA,IAA6B,IAAzB0V,EAAO1V,QAAQ,KAKnB,OAA8B,IAA1B0V,EAAO1V,QAAQ,OACfuQ,EAAOtE,OAAS,OAChBsE,EAAOvP,KAAO,YAIW,IAAzB0U,EAAO1V,QAAQ,MACfuQ,EAAOtE,OAAS,OAChBsE,EAAOvP,KAAO,WAKW,IAAzB0U,EAAO1V,QAAQ,MACfuQ,EAAOtE,OAAS,OAChBsE,EAAOvP,KAAO,YAKW,IAAzB0U,EAAO1V,QAAQ,MAKU,IAAzB0V,EAAO1V,QAAQ,OACfuQ,EAAOtE,OAAS,WALhBsE,EAAOtE,OAAS,OAzBhBsE,EAAOtE,OAAS,eALhBsE,EAAOtE,OAAS,WAyOpB6L,CADApC,GA1PIpC,GADcoC,EA2PIA,GA1PHpC,MAAM,gBAErB/C,EAAOzC,QAAUwF,EAAM,GAEhBoC,EAAO3Z,MAAM,GAAIuX,EAAM,GAAGlZ,SAG9Bsb,EAoPanF,GA5JUA,EA6JLA,GA5JrB+C,EA4JaoC,EA5JEpC,MAAM,mBAGrB/C,EAAO3E,aAAe0H,EAAM,IAWC/C,EA+ILA,GA7IxB+C,EA6IgBoC,EA9IQvM,MAAM,KAAK,GACZmK,MAAM,SAE7B/C,EAAO7D,eAAiB4G,EAAM,GAAGlZ,QAwFzC,SAAqCsb,EAAQnF,GACzC,IAA6B,IAAzBmF,EAAO1V,QAAQ,KAAa,CAC5B,IAAI0M,EAAiBgJ,EAAOvM,MAAM,KAAK,GACvCoH,EAAO4B,wBAA0D,IAAjCzF,EAAe1M,QAAQ,MAiD3D+X,CAA4BrC,EAAQnF,GAnGVA,EAoGLA,GAnGQ,IAmGhBmF,EAnGF1V,QAAQ,OACfuQ,EAAO3D,SAAU,GAWU2D,EAwFLA,GAvFG,KADNmF,EAwFLA,GAvFP1V,QAAQ,KACfuQ,EAAO5D,aAAe,YACU,IAAzB+I,EAAO1V,QAAQ,KACtBuQ,EAAO5D,aAAe,WACU,IAAzB+I,EAAO1V,QAAQ,KACtBuQ,EAAO5D,aAAe,WACU,IAAzB+I,EAAO1V,QAAQ,OACtBuQ,EAAO5D,aAAe,YAnD9B,SAAuB+I,EAAQnF,GAC3B,IAAIrE,EAAWwJ,EAAOvM,MAAM,KAAK,GACjC,GAAI+C,EAAU,CACV,IAAIoH,EAAQpH,EAASoH,MAAM,MACvBA,IACA/C,EAAOrE,SAAWoH,EAAM,GAAGlZ,SA+HnC4d,CAActC,EAAQnF,GAtEaA,EAuELA,GAvEHmF,EAuELA,GAtEXpC,MAAM,SACb/C,EAAO1D,kBAAmB,EACnB6I,EAAOpC,MAAM,QACpB/C,EAAO1D,kBAAmB,GAlDC0D,EAsHLA,GArHpBrE,EAqHYwJ,EArHMvM,MAAM,KAAK,MAE/BoH,EAAO8B,cAA0C,IAA3BnG,EAASlM,QAAQ,MAhFPuQ,EAoMLA,GAnMF,IAmMNmF,EAnMZ1V,QAAQ,OACfuQ,EAAO5E,mBAAoB,GAWE4E,EAwLLA,GAvLC,IAuLTmF,EAvLT1V,QAAQ,OACfuQ,EAAOtF,gBAAiB,EACxBsF,EAAO1E,wBAAyB,GAE5B0E,EAAO3D,SAAW2D,EAAO5D,gBACzB4D,EAAOtD,4BAA6B,IAqIjBsD,EA8CLA,GA9CHmF,EA8CLA,GA7CHpC,MAAM,oBACb/C,EAAOzD,SAAW,eAElB4I,EAAOpC,MAAM,WACb/C,EAAOzD,SAAW,QAUMyD,EAgCLA,EAARmF,EA/BJpC,MAAM,SACb/C,EAAOxD,WAAY,GAgChBwD,0CClSX,IAAM0H,EAAc,CAChB,CAACC,IAAK,MAAOC,OAAQtd,KAAKmK,IAAI,KAAM,IACpC,CAACkT,IAAK,KAAMC,OAAQtd,KAAKmK,IAAI,IAAM,IACnC,CAACkT,IAAK,MAAOC,OAAQtd,KAAKmK,IAAI,KAAM,IACpC,CAACkT,IAAK,KAAMC,OAAQtd,KAAKmK,IAAI,IAAM,IACnC,CAACkT,IAAK,MAAOC,OAAQtd,KAAKmK,IAAI,KAAM,IACpC,CAACkT,IAAK,KAAMC,OAAQtd,KAAKmK,IAAI,IAAM,IACnC,CAACkT,IAAK,MAAOC,OAAQtd,KAAKmK,IAAI,KAAM,IACpC,CAACkT,IAAK,KAAMC,OAAQtd,KAAKmK,IAAI,IAAM,IACnC,CAACkT,IAAK,MAAOC,OAAQtd,KAAKmK,IAAI,KAAM,IACpC,CAACkT,IAAK,KAAMC,OAAQtd,KAAKmK,IAAI,IAAM,IACnC,CAACkT,IAAK,MAAOC,OAAQtd,KAAKmK,IAAI,KAAM,IACpC,CAACkT,IAAK,KAAMC,OAAQtd,KAAKmK,IAAI,IAAM,IACnC,CAACkT,IAAK,MAAOC,OAAQtd,KAAKmK,IAAI,KAAM,IACpC,CAACkT,IAAK,KAAMC,OAAQtd,KAAKmK,IAAI,IAAM,IACnC,CAACkT,IAAK,MAAOC,OAAQtd,KAAKmK,IAAI,KAAM,IACpC,CAACkT,IAAK,KAAMC,OAAQtd,KAAKmK,IAAI,IAAM,IACnC,CAACkT,IAAK,IAAKC,OAAQ,IASvB,SAASC,EAAazc,GAClB,OAAOA,EAAEsE,QAAQ,wBAAyB,QA2I9C,SAASoY,EAAcC,EAAa5N,EAApC,EAAA,EAAA,EAAA,EAAA,GAAiH,IAAjE+D,EAAiE,EAAAtK,UAAA/J,aAAAuT,IAAjH,EAAA,EAAiE,GAAIzC,EAA4C,EAAA/G,UAAA/J,OAAjH,OAAiHuT,EAAnCmH,EAAmC,EAAA3Q,UAAA/J,OAAjH,OAAiHuT,EAAvB/C,EAAuB,EAAAzG,UAAA/J,OAAjH,OAAiHuT,EAAR7L,EAAQ,EAAAqC,UAAA/J,OAAjH,OAAiHuT,EAC7G,GAAoB,KAAhB2K,EAMJ,OAAIA,IAAgBxD,EACT,EApIf,SAASyD,EAAwBD,EAAa5N,EAA9C,EAAA,EAAA,EAAA,EAAA,GAA2H,IAAjE+D,EAAiE,EAAAtK,UAAA/J,aAAAuT,IAA3H,EAAA,EAA2E,GAAIzC,EAA4C,EAAA/G,UAAA/J,OAA3H,OAA2HuT,EAAnCmH,EAAmC,EAAA3Q,UAAA/J,OAA3H,OAA2HuT,EAAvB/C,EAAuB,EAAAzG,UAAA/J,OAA3H,OAA2HuT,EAAR7L,EAAQ,EAAAqC,UAAA/J,OAA3H,OAA2HuT,EACvH,IAAK5H,OAAOuS,GACR,OAAQA,EAGZ,IAAIE,EAAW,GAGXC,EAAWH,EAAYrY,QAAQ,2BAA4B,UAE/D,GAAIwY,IAAaH,EACb,OAAQ,EAAIC,EAAwBE,EAAU/N,EAAY+D,EAAgBvD,EAAS4J,EAAYlK,EAAe9I,GAKlH,IAAK,IAAInI,EAAI,EAAGA,EAAIse,EAAY7d,OAAQT,IAAK,CACzC,IAAI6F,EAASyY,EAAYte,GAGzB,IAFA6e,EAAWF,EAAYrY,QAAQ0J,OAAM,YAAAnI,OAAahC,EAAO0Y,IAApB,OAA8B,SAElDI,EACb,OAAOC,EAAwBC,EAAU9N,EAAY+D,EAAgBvD,EAAS4J,EAAYlK,EAAe9I,GAAUtC,EAAO2Y,OAQlI,IAFAK,EAAWF,EAAYrY,QAAQ,IAAK,OAEnBqY,EACb,OAAOC,EAAwBC,EAAU9N,EAAY+D,EAAgBvD,EAAS4J,EAAYlK,EAAe9I,GAAU,IAKvH,IAAI4W,EAAuBC,WAAWL,GAEtC,IAAIvS,MAAM2S,GAAV,CAIA,IAAIE,EAAgB1N,EAAQwN,GAC5B,GAAIE,GAAmC,MAAlBA,IACjBJ,EAAWF,EAAYrY,QAAQ,IAAI0J,OAAJ,GAAAnI,OAAc4W,EAAaQ,GAA3B,MAA+C,OAE7DN,EACb,OAAOC,EAAwBC,EAAU9N,EAAY+D,EAAgBvD,EAAS4J,EAAYlK,EAAe9I,GAMjH,IAAI+W,EAAwB,GAC5BzK,OAAOyF,KAAKjJ,GAAeyG,QAAQ,SAAC6G,GAChCW,EAAsBjO,EAAcsN,IAAQA,IAMhD,IAHA,IAAIY,EAAqB1K,OAAOyF,KAAKgF,GAAuBE,OAAOjY,UAC/DkY,EAAwBF,EAAmB1e,OAEtC6e,EAAI,EAAGA,EAAID,EAAuBC,IAAK,CAC5C,IAAIzJ,EAAQsJ,EAAmBG,GAC3Bf,EAAMW,EAAsBrJ,GAGhC,IADAgJ,EAAWF,EAAYrY,QAAQuP,EAAO,OACrB8I,EAAa,CAC1B,IAAIH,OAASxK,EACb,OAAQuK,GACJ,IAAK,WACDC,EAAStd,KAAKmK,IAAI,GAAI,GACtB,MACJ,IAAK,UACDmT,EAAStd,KAAKmK,IAAI,GAAI,GACtB,MACJ,IAAK,UACDmT,EAAStd,KAAKmK,IAAI,GAAI,GACtB,MACJ,IAAK,WACDmT,EAAStd,KAAKmK,IAAI,GAAI,IAG9B,OAAOuT,EAAwBC,EAAU9N,EAAY+D,EAAgBvD,EAAS4J,EAAYlK,EAAe9I,GAAUqW,KAuDpHI,CAxCX,SAAiCD,EAAa5N,EAA9C,GAA+E,IAArB+D,EAAqB,EAAAtK,UAAA/J,aAAAuT,IAA/E,EAAA,EAA2E,GAGnE6K,EAAWF,EAAYrY,QAAQwO,EAAgB,IAUnD,OAFA+J,GAJAA,EAAWA,EAASvY,QAAQ,IAAI0J,OAAJ,UAAAnI,OAAqB4W,EAAa1N,EAAWC,WAA7C,WAAkE,KAAM,SAIhF1K,QAAQyK,EAAW/M,QAAS,KA4BpCub,CAAwBZ,EAAa5N,EAAY+D,GACvB/D,EAAY+D,EAAgBvD,EAAS4J,EAAYlK,EAAe9I,GAmF1GhJ,EAAOD,QAAU,CACb2e,SAhCJ,SAAkBc,EAAaxW,GAE3B,IAlBIqX,EAEAvJ,EACAC,EAeExD,EAAcxS,EAAQ,iBAExB6Q,EAAa2B,EAAYyE,oBACzBrC,EAAiBpC,EAAY6B,kBAAkB1C,OAC/CN,EAAUmB,EAAY6D,iBACtB4E,EAAazI,EAAYuF,gBACzBhH,EAAgByB,EAAY0G,uBAE5BvD,OAAQ7B,EAEZ,GAA2B,iBAAhB2K,EAIH9I,EA1DZ,SAAqB8I,EAAa5N,GAG9B,GAFiB4N,EAAYtY,QAAQ,MAAiC,MAAzB0K,EAAWC,UAExD,CAIA,IAAIwO,EAAWb,EAAYnP,MAAM,KACjC,GAAwB,IAApBgQ,EAAS/e,OAAb,CAIA,IAAIwV,GAASuJ,EAAS,GAClBtJ,GAAWsJ,EAAS,GACpBrJ,GAAWqJ,EAAS,GAExB,OAAQpT,MAAM6J,KAAW7J,MAAM8J,KAAa9J,MAAM+J,KAuC1CsJ,CAAYd,EAAa5N,IA7B7ByO,EA8ByBb,EA9BFnP,MAAM,KAE7ByG,GAASuJ,EAAS,GAClBtJ,GAAWsJ,EAAS,IACTA,EAAS,GAEP,GAAKtJ,EAAU,KAAOD,GA0BvByI,EAAcC,EAAa5N,EAAY+D,EAAgBvD,EAAS4J,EAAYlK,EAAe9I,OAEpG,CAAA,GAA2B,iBAAhBwW,EAGd,OAFA9I,EAAQ8I,EAKZ,QAAc3K,IAAV6B,EAIJ,OAAOA,qnBClQX,IAAIyH,EAAcpd,EAAQ,kBAGpBwf,EAAc,qDAoEdC,EAAc,CAChBrN,OAAQ,CACJsN,KAAM,SACNC,YArEkB,CACtB,WACA,UACA,OACA,OACA,UACA,WAiEAxY,KAAM,CACFuY,KAAM,SACNC,YAbgB,CACpB,UACA,SACA,WAWIC,YAAa,SAACtO,EAAQrJ,GAAT,MAAsC,SAAlBA,EAAOmK,QACxCyN,QAAS,yDACTC,UAAW,SAAC7X,GAAD,MAA8B,SAAlBA,EAAOmK,SAElCS,eAAgB,CACZ6M,KAAM,SACNE,YAAa,SAACtO,GAAD,OAAsB,GAAVA,GACzBuO,QAAS,0BAEbza,OAAQ,SACR6O,QAAS,SACTnB,aAAc,CACV4M,KAAM,SACNC,YA9EwB,CAC5B,WACA,UACA,UACA,aA4EA5M,QAAS,UACT8B,aAAc,CACV6K,KAAM,UACNE,YAAa,SAACtO,EAAQrJ,GAAT,OAAuC,IAAnBA,EAAO8K,SACxC8M,QAAS,yEAEblL,iBAAkB,CACd+K,KAAM,SACNC,YAjFsB,CAC1B,SACA,QACA,YAgFA/K,eAAgB,SAChB7C,YAAa,CACT2N,KAAM,SACNK,aAAc,CACV,CACIH,YAAa,SAACtO,GAAD,OAAsB,GAAVA,GACzBuO,QAAS,0BAEb,CACID,YAAa,SAACtO,EAAQrJ,GAAT,OAAqBA,EAAOoQ,aACzCwH,QAAS,sDAIrBxN,SAAU,CACNqN,KAAM,SACNE,YAAa,SAACtO,GAAD,OAAsB,GAAVA,GACzBuO,QAAS,0BAEb7M,iBAAkB,UAClBwF,aAAc,UACdrF,iBAAkB,WAClBmF,uBAAwB,UACxBxG,kBAAmB,UACnBV,eAAgB,UAChBY,uBAAwB,UACxBoB,2BAA4B,UAC5BrC,cA5EuB,CACvB2O,KAAM,SACNM,SAAU,CACNhP,SAAU,SACVC,QAAS,SACTC,QAAS,SACTC,SAAU,WAuEd8B,SAAU,CACNyM,KAAM,SACNC,YA3GoB,CACxB,OACA,gBA2GAzM,UAAW,UACXmF,YAAa,CACTqH,KAAM,WAEVxK,aAAc,CACVwK,KAAM,UACNE,YAAa,SAACtO,EAAQrJ,GAAT,MAAsC,YAAlBA,EAAOmK,QACxCyN,QAAS,qEAIXI,EAAgB,CAClBrP,YAAa,CACT8O,KAAM,SACNI,WAAW,EACXF,YAAa,SAACxE,GACV,OAAOA,EAAI3B,MAAM+F,IAErBK,QAAS,iGAEbhP,WAAY,CACR6O,KAAM,SACNM,SAAU,CACNlP,UAAW,SACXhN,QAAS,SACTqT,cAAe,UAEnB2I,WAAW,GAEf/O,cArIgC,CAChC2O,KAAM,SACNM,SAAU,CACNhP,SAAU,CACN0O,KAAM,SACNI,WAAW,GAEf7O,QAAS,CACLyO,KAAM,SACNI,WAAW,GAEf5O,QAAS,CACLwO,KAAM,SACNI,WAAW,GAEf3O,SAAU,CACNuO,KAAM,SACNI,WAAW,IAGnBA,WAAW,GAkHX1O,eAAgB,UAChBY,uBAAwB,UACxBX,QAAS,CACLqO,KAAM,WACNI,WAAW,GAEfvO,MAAO,CACHmO,KAAM,SACNM,SAAU,CACNxO,eAAgB,SAChBC,gBAAiB,WAGzBC,SAAU,CACNgO,KAAM,SACNM,SAAU,CACNrO,OAAQ,SACRC,SAAU,SACVxR,KAAM,UAEV0f,WAAW,GAEflK,SAAU,SACV2F,cAAe,SACfC,WAAY,SACZC,iBAAkB,SAClB5J,eAAgB,SAChBqO,aAAc,SACdjO,QAAS,CACLyN,KAAM,SACNM,SAAU,CACN9N,WAAY,CACRwN,KAAM,SACNI,WAAW,GAEf3N,oBAAqB,CACjBuN,KAAM,SACNI,WAAW,GAEfxN,8BAA+B,CAC3BoN,KAAM,SACNI,WAAW,GAEfvN,mBAAoB,CAChBmN,KAAM,SACNI,WAAW,MA2B3B,SAASK,EAAc1C,GAGnB,YAAiB3J,IAFLsJ,EAAYO,SAASF,GAcrC,SAAS2C,EAAaC,EAAYC,EAAMlb,EAAxC,GAA4E,IAA5Bmb,EAA4B,EAAAjW,UAAA/J,aAAAuT,IAA5E,GAAA,EACQ0M,EAAUjM,OAAOyF,KAAKqG,GAAYI,IAAI,SAACpC,GACvC,IAAKiC,EAAKjC,GAEN,OADA5B,QAAQC,MAAR,GAAA/U,OAAiBvC,EAAjB,kBAAAuC,OAAwC0W,KACjC,EAGX,IAAI1I,EAAQ0K,EAAWhC,GACnB3F,EAAO4H,EAAKjC,GAMhB,GAJoB,iBAAT3F,IACPA,EAAO,CAACgH,KAAMhH,IAGA,WAAdA,EAAKgH,MAGL,IAFYU,EAAazK,EAAO8J,EAAR,aAAA9X,OAAkC0W,EAAlC,MAA0C,GAG9D,OAAO,OAER,GAAIqC,EAAO/K,KAAU+C,EAAKgH,KAE7B,OADAjD,QAAQC,MAAR,GAAA/U,OAAiBvC,EAAjB,KAAAuC,OAA2B0W,EAA3B,uBAAA1W,OAAoD+Q,EAAKgH,KAAzD,iBAAA/X,OAAA+Y,EAAoF/K,GAApF,gBACO,EAGX,GAAI+C,EAAKqH,cAAgBrH,EAAKqH,aAAaxf,OAEvC,IADA,IAAIA,EAASmY,EAAKqH,aAAaxf,OACtBT,EAAI,EAAGA,EAAIS,EAAQT,IAAK,CAAA,IAAA6gB,EACAjI,EAAKqH,aAAajgB,GAA1C8f,EADwBe,EACxBf,YAAaC,EADWc,EACXd,QAClB,IAAKD,EAAYjK,EAAO0K,GAEpB,OADA5D,QAAQC,MAAR,GAAA/U,OAAiBvC,EAAjB,KAAAuC,OAA2B0W,EAA3B,oBAAA1W,OAAiDkY,KAC1C,EAKnB,GAAInH,EAAKkH,cAAgBlH,EAAKkH,YAAYjK,EAAO0K,GAE7C,OADA5D,QAAQC,MAAR,GAAA/U,OAAiBvC,EAAjB,KAAAuC,OAA2B0W,EAA3B,oBAAA1W,OAAiD+Q,EAAKmH,WAC/C,EAGX,GAAInH,EAAKiH,cAAoD,IAArCjH,EAAKiH,YAAYxZ,QAAQwP,GAE7C,OADA8G,QAAQC,MAAR,GAAA/U,OAAiBvC,EAAjB,KAAAuC,OAA2B0W,EAA3B,kCAAA1W,OAA+DiZ,KAAKC,UAAUnI,EAAKiH,aAAnF,OAAAhY,OAAqGgO,EAArG,gBACO,EAGX,GAAI+C,EAAKsH,WACOI,EAAazK,EAAO+C,EAAKsH,SAAb,aAAArY,OAAoC0W,EAApC,MAGpB,OAAO,EAIf,OAAO,IA0BX,OAvBKkC,GACDC,EAAQ7Z,KAARyT,MAAAoG,EAAOM,EAASvM,OAAOyF,KAAKsG,GAAMG,IAAI,SAACpC,GACnC,IAAI3F,EAAO4H,EAAKjC,GAKhB,GAJoB,iBAAT3F,IACPA,EAAO,CAACgH,KAAMhH,IAGdA,EAAKoH,UAAW,CAChB,IAAIA,EAAYpH,EAAKoH,UAKrB,GAJyB,mBAAdA,IACPA,EAAYA,EAAUO,IAGtBP,QAAiChM,IAApBuM,EAAWhC,GAExB,OADA5B,QAAQC,MAAR,GAAA/U,OAAiBvC,EAAjB,4BAAAuC,OAAkD0W,EAAlD,OACO,EAIf,OAAO,MAIRmC,EAAQO,OAAO,SAACC,EAAKC,GACxB,OAAOD,GAAOC,IACf,GASP,SAASjN,EAAe/L,GACpB,OAAOmY,EAAanY,EAAQwX,EAAa,qBAa7CxgB,EAAOD,QAAU,CACbgf,SAtIJ,SAAkBP,EAAOxV,GACrB,IAAIiZ,EAAaf,EAAc1C,GAC3B0D,EAAgBnN,EAAe/L,GAEnC,OAAOiZ,GAAcC,GAmIrBnN,eAAAA,EACAmM,cAAAA,EACAlE,iBARJ,SAA0B6B,GACtB,OAAOsC,EAAatC,EAAUmC,EAAe,wDVzXjD","file":"numbro.min.js","sourcesContent":["(function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c=\"function\"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error(\"Cannot find module '\"+i+\"'\");throw a.code=\"MODULE_NOT_FOUND\",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u=\"function\"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()",";(function (globalObject) {\r\n  'use strict';\r\n\r\n/*\r\n *      bignumber.js v8.1.1\r\n *      A JavaScript library for arbitrary-precision arithmetic.\r\n *      https://github.com/MikeMcl/bignumber.js\r\n *      Copyright (c) 2019 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    hasSymbol = typeof Symbol == 'function' && typeof Symbol.iterator == 'symbol',\r\n\r\n    mathceil = Math.ceil,\r\n    mathfloor = Math.floor,\r\n\r\n    bignumberError = '[BigNumber Error] ',\r\n    tooManyDigits = bignumberError + 'Number primitive has more than 15 significant digits: ',\r\n\r\n    BASE = 1e14,\r\n    LOG_BASE = 14,\r\n    MAX_SAFE_INTEGER = 0x1fffffffffffff,         // 2^53 - 1\r\n    // MAX_INT32 = 0x7fffffff,                   // 2^31 - 1\r\n    POWS_TEN = [1, 10, 100, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, 1e10, 1e11, 1e12, 1e13],\r\n    SQRT_BASE = 1e7,\r\n\r\n    // EDITABLE\r\n    // The limit on the value of DECIMAL_PLACES, TO_EXP_NEG, TO_EXP_POS, MIN_EXP, MAX_EXP, and\r\n    // the arguments to toExponential, toFixed, toFormat, and toPrecision.\r\n    MAX = 1E9;                                   // 0 to MAX_INT32\r\n\r\n\r\n  /*\r\n   * Create and return a BigNumber constructor.\r\n   */\r\n  function clone(configObject) {\r\n    var div, convertBase, parseNumeric,\r\n      P = BigNumber.prototype = { constructor: BigNumber, toString: null, valueOf: null },\r\n      ONE = new BigNumber(1),\r\n\r\n\r\n      //----------------------------- EDITABLE CONFIG DEFAULTS -------------------------------\r\n\r\n\r\n      // The default values below must be integers within the inclusive ranges stated.\r\n      // The values can also be changed at run-time using BigNumber.set.\r\n\r\n      // The maximum number of decimal places for operations involving division.\r\n      DECIMAL_PLACES = 20,                     // 0 to MAX\r\n\r\n      // The rounding mode used when rounding to the above decimal places, and when using\r\n      // toExponential, toFixed, toFormat and toPrecision, and round (default value).\r\n      // UP         0 Away from zero.\r\n      // DOWN       1 Towards zero.\r\n      // CEIL       2 Towards +Infinity.\r\n      // FLOOR      3 Towards -Infinity.\r\n      // HALF_UP    4 Towards nearest neighbour. If equidistant, up.\r\n      // HALF_DOWN  5 Towards nearest neighbour. If equidistant, down.\r\n      // HALF_EVEN  6 Towards nearest neighbour. If equidistant, towards even neighbour.\r\n      // HALF_CEIL  7 Towards nearest neighbour. If equidistant, towards +Infinity.\r\n      // HALF_FLOOR 8 Towards nearest neighbour. If equidistant, towards -Infinity.\r\n      ROUNDING_MODE = 4,                       // 0 to 8\r\n\r\n      // EXPONENTIAL_AT : [TO_EXP_NEG , TO_EXP_POS]\r\n\r\n      // The exponent value at and beneath which toString returns exponential notation.\r\n      // Number type: -7\r\n      TO_EXP_NEG = -7,                         // 0 to -MAX\r\n\r\n      // The exponent value at and above which toString returns exponential notation.\r\n      // Number type: 21\r\n      TO_EXP_POS = 21,                         // 0 to MAX\r\n\r\n      // RANGE : [MIN_EXP, MAX_EXP]\r\n\r\n      // The minimum exponent value, beneath which underflow to zero occurs.\r\n      // Number type: -324  (5e-324)\r\n      MIN_EXP = -1e7,                          // -1 to -MAX\r\n\r\n      // The maximum exponent value, above which overflow to Infinity occurs.\r\n      // Number type:  308  (1.7976931348623157e+308)\r\n      // For MAX_EXP > 1e7, e.g. new BigNumber('1e100000000').plus(1) may be slow.\r\n      MAX_EXP = 1e7,                           // 1 to MAX\r\n\r\n      // Whether to use cryptographically-secure random number generation, if available.\r\n      CRYPTO = false,                          // true or false\r\n\r\n      // The modulo mode used when calculating the modulus: a mod n.\r\n      // The quotient (q = a / n) is calculated according to the corresponding rounding mode.\r\n      // The remainder (r) is calculated as: r = a - n * q.\r\n      //\r\n      // UP        0 The remainder is positive if the dividend is negative, else is negative.\r\n      // DOWN      1 The remainder has the same sign as the dividend.\r\n      //             This modulo mode is commonly known as 'truncated division' and is\r\n      //             equivalent to (a % n) in JavaScript.\r\n      // FLOOR     3 The remainder has the same sign as the divisor (Python %).\r\n      // HALF_EVEN 6 This modulo mode implements the IEEE 754 remainder function.\r\n      // EUCLID    9 Euclidian division. q = sign(n) * floor(a / abs(n)).\r\n      //             The remainder is always positive.\r\n      //\r\n      // The truncated division, floored division, Euclidian division and IEEE 754 remainder\r\n      // modes are commonly used for the modulus operation.\r\n      // Although the other rounding modes can also be used, they may not give useful results.\r\n      MODULO_MODE = 1,                         // 0 to 9\r\n\r\n      // The maximum number of significant digits of the result of the exponentiatedBy operation.\r\n      // If POW_PRECISION is 0, there will be unlimited significant digits.\r\n      POW_PRECISION = 0,                    // 0 to MAX\r\n\r\n      // The format specification used by the BigNumber.prototype.toFormat method.\r\n      FORMAT = {\r\n        prefix: '',\r\n        groupSize: 3,\r\n        secondaryGroupSize: 0,\r\n        groupSeparator: ',',\r\n        decimalSeparator: '.',\r\n        fractionGroupSize: 0,\r\n        fractionGroupSeparator: '\\xA0',      // non-breaking space\r\n        suffix: ''\r\n      },\r\n\r\n      // The alphabet used for base conversion. It must be at least 2 characters long, with no '+',\r\n      // '-', '.', whitespace, or repeated character.\r\n      // '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ$_'\r\n      ALPHABET = '0123456789abcdefghijklmnopqrstuvwxyz';\r\n\r\n\r\n    //------------------------------------------------------------------------------------------\r\n\r\n\r\n    // CONSTRUCTOR\r\n\r\n\r\n    /*\r\n     * The BigNumber constructor and exported function.\r\n     * Create and return a new instance of a BigNumber object.\r\n     *\r\n     * v {number|string|BigNumber} A numeric value.\r\n     * [b] {number} The base of v. Integer, 2 to ALPHABET.length inclusive.\r\n     */\r\n    function BigNumber(v, b) {\r\n      var alphabet, c, caseChanged, e, i, isNum, len, str,\r\n        x = this;\r\n\r\n      // Enable constructor call without `new`.\r\n      if (!(x instanceof BigNumber)) return new BigNumber(v, b);\r\n\r\n      if (b == null) {\r\n\r\n        if (v && v._isBigNumber === true) {\r\n          x.s = v.s;\r\n\r\n          if (!v.c || v.e > MAX_EXP) {\r\n            x.c = x.e = null;\r\n          } else if (v.e < MIN_EXP) {\r\n            x.c = [x.e = 0];\r\n          } else {\r\n            x.e = v.e;\r\n            x.c = v.c.slice();\r\n          }\r\n\r\n          return;\r\n        }\r\n\r\n        if ((isNum = typeof v == 'number') && v * 0 == 0) {\r\n\r\n          // Use `1 / n` to handle minus zero also.\r\n          x.s = 1 / v < 0 ? (v = -v, -1) : 1;\r\n\r\n          // Fast path for integers, where n < 2147483648 (2**31).\r\n          if (v === ~~v) {\r\n            for (e = 0, i = v; i >= 10; i /= 10, e++);\r\n\r\n            if (e > MAX_EXP) {\r\n              x.c = x.e = null;\r\n            } else {\r\n              x.e = e;\r\n              x.c = [v];\r\n            }\r\n\r\n            return;\r\n          }\r\n\r\n          str = String(v);\r\n        } else {\r\n\r\n          if (!isNumeric.test(str = String(v))) return parseNumeric(x, str, isNum);\r\n\r\n          x.s = str.charCodeAt(0) == 45 ? (str = str.slice(1), -1) : 1;\r\n        }\r\n\r\n        // Decimal point?\r\n        if ((e = str.indexOf('.')) > -1) str = str.replace('.', '');\r\n\r\n        // Exponential form?\r\n        if ((i = str.search(/e/i)) > 0) {\r\n\r\n          // Determine exponent.\r\n          if (e < 0) e = i;\r\n          e += +str.slice(i + 1);\r\n          str = str.substring(0, i);\r\n        } else if (e < 0) {\r\n\r\n          // Integer.\r\n          e = str.length;\r\n        }\r\n\r\n      } else {\r\n\r\n        // '[BigNumber Error] Base {not a primitive number|not an integer|out of range}: {b}'\r\n        intCheck(b, 2, ALPHABET.length, 'Base');\r\n\r\n        // Allow exponential notation to be used with base 10 argument, while\r\n        // also rounding to DECIMAL_PLACES as with other bases.\r\n        if (b == 10) {\r\n          x = new BigNumber(v);\r\n          return round(x, DECIMAL_PLACES + x.e + 1, ROUNDING_MODE);\r\n        }\r\n\r\n        str = String(v);\r\n\r\n        if (isNum = typeof v == 'number') {\r\n\r\n          // Avoid potential interpretation of Infinity and NaN as base 44+ values.\r\n          if (v * 0 != 0) return parseNumeric(x, str, isNum, b);\r\n\r\n          x.s = 1 / v < 0 ? (str = str.slice(1), -1) : 1;\r\n\r\n          // '[BigNumber Error] Number primitive has more than 15 significant digits: {n}'\r\n          if (BigNumber.DEBUG && str.replace(/^0\\.0*|\\./, '').length > 15) {\r\n            throw Error\r\n             (tooManyDigits + v);\r\n          }\r\n        } else {\r\n          x.s = str.charCodeAt(0) === 45 ? (str = str.slice(1), -1) : 1;\r\n        }\r\n\r\n        alphabet = ALPHABET.slice(0, b);\r\n        e = i = 0;\r\n\r\n        // Check that str is a valid base b number.\r\n        // Don't use RegExp, so alphabet can contain special characters.\r\n        for (len = str.length; i < len; i++) {\r\n          if (alphabet.indexOf(c = str.charAt(i)) < 0) {\r\n            if (c == '.') {\r\n\r\n              // If '.' is not the first character and it has not be found before.\r\n              if (i > e) {\r\n                e = len;\r\n                continue;\r\n              }\r\n            } else if (!caseChanged) {\r\n\r\n              // Allow e.g. hexadecimal 'FF' as well as 'ff'.\r\n              if (str == str.toUpperCase() && (str = str.toLowerCase()) ||\r\n                  str == str.toLowerCase() && (str = str.toUpperCase())) {\r\n                caseChanged = true;\r\n                i = -1;\r\n                e = 0;\r\n                continue;\r\n              }\r\n            }\r\n\r\n            return parseNumeric(x, String(v), isNum, b);\r\n          }\r\n        }\r\n\r\n        // Prevent later check for length on converted number.\r\n        isNum = false;\r\n        str = convertBase(str, b, 10, x.s);\r\n\r\n        // Decimal point?\r\n        if ((e = str.indexOf('.')) > -1) str = str.replace('.', '');\r\n        else e = str.length;\r\n      }\r\n\r\n      // Determine leading zeros.\r\n      for (i = 0; str.charCodeAt(i) === 48; i++);\r\n\r\n      // Determine trailing zeros.\r\n      for (len = str.length; str.charCodeAt(--len) === 48;);\r\n\r\n      if (str = str.slice(i, ++len)) {\r\n        len -= i;\r\n\r\n        // '[BigNumber Error] Number primitive has more than 15 significant digits: {n}'\r\n        if (isNum && BigNumber.DEBUG &&\r\n          len > 15 && (v > MAX_SAFE_INTEGER || v !== mathfloor(v))) {\r\n            throw Error\r\n             (tooManyDigits + (x.s * v));\r\n        }\r\n\r\n         // Overflow?\r\n        if ((e = e - i - 1) > MAX_EXP) {\r\n\r\n          // Infinity.\r\n          x.c = x.e = null;\r\n\r\n        // Underflow?\r\n        } else if (e < MIN_EXP) {\r\n\r\n          // Zero.\r\n          x.c = [x.e = 0];\r\n        } else {\r\n          x.e = e;\r\n          x.c = [];\r\n\r\n          // Transform base\r\n\r\n          // e is the base 10 exponent.\r\n          // i is where to slice str to get the first element of the coefficient array.\r\n          i = (e + 1) % LOG_BASE;\r\n          if (e < 0) i += LOG_BASE;  // i < 1\r\n\r\n          if (i < len) {\r\n            if (i) x.c.push(+str.slice(0, i));\r\n\r\n            for (len -= LOG_BASE; i < len;) {\r\n              x.c.push(+str.slice(i, i += LOG_BASE));\r\n            }\r\n\r\n            i = LOG_BASE - (str = str.slice(i)).length;\r\n          } else {\r\n            i -= len;\r\n          }\r\n\r\n          for (; i--; str += '0');\r\n          x.c.push(+str);\r\n        }\r\n      } else {\r\n\r\n        // Zero.\r\n        x.c = [x.e = 0];\r\n      }\r\n    }\r\n\r\n\r\n    // CONSTRUCTOR PROPERTIES\r\n\r\n\r\n    BigNumber.clone = clone;\r\n\r\n    BigNumber.ROUND_UP = 0;\r\n    BigNumber.ROUND_DOWN = 1;\r\n    BigNumber.ROUND_CEIL = 2;\r\n    BigNumber.ROUND_FLOOR = 3;\r\n    BigNumber.ROUND_HALF_UP = 4;\r\n    BigNumber.ROUND_HALF_DOWN = 5;\r\n    BigNumber.ROUND_HALF_EVEN = 6;\r\n    BigNumber.ROUND_HALF_CEIL = 7;\r\n    BigNumber.ROUND_HALF_FLOOR = 8;\r\n    BigNumber.EUCLID = 9;\r\n\r\n\r\n    /*\r\n     * Configure infrequently-changing library-wide settings.\r\n     *\r\n     * Accept an object with the following optional properties (if the value of a property is\r\n     * a number, it must be an integer within the inclusive range stated):\r\n     *\r\n     *   DECIMAL_PLACES   {number}           0 to MAX\r\n     *   ROUNDING_MODE    {number}           0 to 8\r\n     *   EXPONENTIAL_AT   {number|number[]}  -MAX to MAX  or  [-MAX to 0, 0 to MAX]\r\n     *   RANGE            {number|number[]}  -MAX to MAX (not zero)  or  [-MAX to -1, 1 to MAX]\r\n     *   CRYPTO           {boolean}          true or false\r\n     *   MODULO_MODE      {number}           0 to 9\r\n     *   POW_PRECISION       {number}           0 to MAX\r\n     *   ALPHABET         {string}           A string of two or more unique characters which does\r\n     *                                       not contain '.'.\r\n     *   FORMAT           {object}           An object with some of the following properties:\r\n     *     prefix                 {string}\r\n     *     groupSize              {number}\r\n     *     secondaryGroupSize     {number}\r\n     *     groupSeparator         {string}\r\n     *     decimalSeparator       {string}\r\n     *     fractionGroupSize      {number}\r\n     *     fractionGroupSeparator {string}\r\n     *     suffix                 {string}\r\n     *\r\n     * (The values assigned to the above FORMAT object properties are not checked for validity.)\r\n     *\r\n     * E.g.\r\n     * BigNumber.config({ DECIMAL_PLACES : 20, ROUNDING_MODE : 4 })\r\n     *\r\n     * Ignore properties/parameters set to null or undefined, except for ALPHABET.\r\n     *\r\n     * Return an object with the properties current values.\r\n     */\r\n    BigNumber.config = BigNumber.set = function (obj) {\r\n      var p, v;\r\n\r\n      if (obj != null) {\r\n\r\n        if (typeof obj == 'object') {\r\n\r\n          // DECIMAL_PLACES {number} Integer, 0 to MAX inclusive.\r\n          // '[BigNumber Error] DECIMAL_PLACES {not a primitive number|not an integer|out of range}: {v}'\r\n          if (obj.hasOwnProperty(p = 'DECIMAL_PLACES')) {\r\n            v = obj[p];\r\n            intCheck(v, 0, MAX, p);\r\n            DECIMAL_PLACES = v;\r\n          }\r\n\r\n          // ROUNDING_MODE {number} Integer, 0 to 8 inclusive.\r\n          // '[BigNumber Error] ROUNDING_MODE {not a primitive number|not an integer|out of range}: {v}'\r\n          if (obj.hasOwnProperty(p = 'ROUNDING_MODE')) {\r\n            v = obj[p];\r\n            intCheck(v, 0, 8, p);\r\n            ROUNDING_MODE = v;\r\n          }\r\n\r\n          // EXPONENTIAL_AT {number|number[]}\r\n          // Integer, -MAX to MAX inclusive or\r\n          // [integer -MAX to 0 inclusive, 0 to MAX inclusive].\r\n          // '[BigNumber Error] EXPONENTIAL_AT {not a primitive number|not an integer|out of range}: {v}'\r\n          if (obj.hasOwnProperty(p = 'EXPONENTIAL_AT')) {\r\n            v = obj[p];\r\n            if (v && v.pop) {\r\n              intCheck(v[0], -MAX, 0, p);\r\n              intCheck(v[1], 0, MAX, p);\r\n              TO_EXP_NEG = v[0];\r\n              TO_EXP_POS = v[1];\r\n            } else {\r\n              intCheck(v, -MAX, MAX, p);\r\n              TO_EXP_NEG = -(TO_EXP_POS = v < 0 ? -v : v);\r\n            }\r\n          }\r\n\r\n          // RANGE {number|number[]} Non-zero integer, -MAX to MAX inclusive or\r\n          // [integer -MAX to -1 inclusive, integer 1 to MAX inclusive].\r\n          // '[BigNumber Error] RANGE {not a primitive number|not an integer|out of range|cannot be zero}: {v}'\r\n          if (obj.hasOwnProperty(p = 'RANGE')) {\r\n            v = obj[p];\r\n            if (v && v.pop) {\r\n              intCheck(v[0], -MAX, -1, p);\r\n              intCheck(v[1], 1, MAX, p);\r\n              MIN_EXP = v[0];\r\n              MAX_EXP = v[1];\r\n            } else {\r\n              intCheck(v, -MAX, MAX, p);\r\n              if (v) {\r\n                MIN_EXP = -(MAX_EXP = v < 0 ? -v : v);\r\n              } else {\r\n                throw Error\r\n                 (bignumberError + p + ' cannot be zero: ' + v);\r\n              }\r\n            }\r\n          }\r\n\r\n          // CRYPTO {boolean} true or false.\r\n          // '[BigNumber Error] CRYPTO not true or false: {v}'\r\n          // '[BigNumber Error] crypto unavailable'\r\n          if (obj.hasOwnProperty(p = 'CRYPTO')) {\r\n            v = obj[p];\r\n            if (v === !!v) {\r\n              if (v) {\r\n                if (typeof crypto != 'undefined' && crypto &&\r\n                 (crypto.getRandomValues || crypto.randomBytes)) {\r\n                  CRYPTO = v;\r\n                } else {\r\n                  CRYPTO = !v;\r\n                  throw Error\r\n                   (bignumberError + 'crypto unavailable');\r\n                }\r\n              } else {\r\n                CRYPTO = v;\r\n              }\r\n            } else {\r\n              throw Error\r\n               (bignumberError + p + ' not true or false: ' + v);\r\n            }\r\n          }\r\n\r\n          // MODULO_MODE {number} Integer, 0 to 9 inclusive.\r\n          // '[BigNumber Error] MODULO_MODE {not a primitive number|not an integer|out of range}: {v}'\r\n          if (obj.hasOwnProperty(p = 'MODULO_MODE')) {\r\n            v = obj[p];\r\n            intCheck(v, 0, 9, p);\r\n            MODULO_MODE = v;\r\n          }\r\n\r\n          // POW_PRECISION {number} Integer, 0 to MAX inclusive.\r\n          // '[BigNumber Error] POW_PRECISION {not a primitive number|not an integer|out of range}: {v}'\r\n          if (obj.hasOwnProperty(p = 'POW_PRECISION')) {\r\n            v = obj[p];\r\n            intCheck(v, 0, MAX, p);\r\n            POW_PRECISION = v;\r\n          }\r\n\r\n          // FORMAT {object}\r\n          // '[BigNumber Error] FORMAT not an object: {v}'\r\n          if (obj.hasOwnProperty(p = 'FORMAT')) {\r\n            v = obj[p];\r\n            if (typeof v == 'object') FORMAT = v;\r\n            else throw Error\r\n             (bignumberError + p + ' not an object: ' + v);\r\n          }\r\n\r\n          // ALPHABET {string}\r\n          // '[BigNumber Error] ALPHABET invalid: {v}'\r\n          if (obj.hasOwnProperty(p = 'ALPHABET')) {\r\n            v = obj[p];\r\n\r\n            // Disallow if only one character,\r\n            // or if it contains '+', '-', '.', whitespace, or a repeated character.\r\n            if (typeof v == 'string' && !/^.$|[+-.\\s]|(.).*\\1/.test(v)) {\r\n              ALPHABET = v;\r\n            } else {\r\n              throw Error\r\n               (bignumberError + p + ' invalid: ' + v);\r\n            }\r\n          }\r\n\r\n        } else {\r\n\r\n          // '[BigNumber Error] Object expected: {v}'\r\n          throw Error\r\n           (bignumberError + 'Object expected: ' + obj);\r\n        }\r\n      }\r\n\r\n      return {\r\n        DECIMAL_PLACES: DECIMAL_PLACES,\r\n        ROUNDING_MODE: ROUNDING_MODE,\r\n        EXPONENTIAL_AT: [TO_EXP_NEG, TO_EXP_POS],\r\n        RANGE: [MIN_EXP, MAX_EXP],\r\n        CRYPTO: CRYPTO,\r\n        MODULO_MODE: MODULO_MODE,\r\n        POW_PRECISION: POW_PRECISION,\r\n        FORMAT: FORMAT,\r\n        ALPHABET: ALPHABET\r\n      };\r\n    };\r\n\r\n\r\n    /*\r\n     * Return true if v is a BigNumber instance, otherwise return false.\r\n     *\r\n     * If BigNumber.DEBUG is true, throw if a BigNumber instance is not well-formed.\r\n     *\r\n     * v {any}\r\n     *\r\n     * '[BigNumber Error] Invalid BigNumber: {v}'\r\n     */\r\n    BigNumber.isBigNumber = function (v) {\r\n      if (!v || v._isBigNumber !== true) return false;\r\n      if (!BigNumber.DEBUG) return true;\r\n\r\n      var i, n,\r\n        c = v.c,\r\n        e = v.e,\r\n        s = v.s;\r\n\r\n      out: if ({}.toString.call(c) == '[object Array]') {\r\n\r\n        if ((s === 1 || s === -1) && e >= -MAX && e <= MAX && e === mathfloor(e)) {\r\n\r\n          // If the first element is zero, the BigNumber value must be zero.\r\n          if (c[0] === 0) {\r\n            if (e === 0 && c.length === 1) return true;\r\n            break out;\r\n          }\r\n\r\n          // Calculate number of digits that c[0] should have, based on the exponent.\r\n          i = (e + 1) % LOG_BASE;\r\n          if (i < 1) i += LOG_BASE;\r\n\r\n          // Calculate number of digits of c[0].\r\n          //if (Math.ceil(Math.log(c[0] + 1) / Math.LN10) == i) {\r\n          if (String(c[0]).length == i) {\r\n\r\n            for (i = 0; i < c.length; i++) {\r\n              n = c[i];\r\n              if (n < 0 || n >= BASE || n !== mathfloor(n)) break out;\r\n            }\r\n\r\n            // Last element cannot be zero, unless it is the only element.\r\n            if (n !== 0) return true;\r\n          }\r\n        }\r\n\r\n      // Infinity/NaN\r\n      } else if (c === null && e === null && (s === null || s === 1 || s === -1)) {\r\n        return true;\r\n      }\r\n\r\n      throw Error\r\n        (bignumberError + 'Invalid BigNumber: ' + v);\r\n    };\r\n\r\n\r\n    /*\r\n     * Return a new BigNumber whose value is the maximum of the arguments.\r\n     *\r\n     * arguments {number|string|BigNumber}\r\n     */\r\n    BigNumber.maximum = BigNumber.max = function () {\r\n      return maxOrMin(arguments, P.lt);\r\n    };\r\n\r\n\r\n    /*\r\n     * Return a new BigNumber whose value is the minimum of the arguments.\r\n     *\r\n     * arguments {number|string|BigNumber}\r\n     */\r\n    BigNumber.minimum = BigNumber.min = function () {\r\n      return maxOrMin(arguments, P.gt);\r\n    };\r\n\r\n\r\n    /*\r\n     * Return a new BigNumber with a random value equal to or greater than 0 and less than 1,\r\n     * and with dp, or DECIMAL_PLACES if dp is omitted, decimal places (or less if trailing\r\n     * zeros are produced).\r\n     *\r\n     * [dp] {number} Decimal places. Integer, 0 to MAX inclusive.\r\n     *\r\n     * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {dp}'\r\n     * '[BigNumber Error] crypto unavailable'\r\n     */\r\n    BigNumber.random = (function () {\r\n      var pow2_53 = 0x20000000000000;\r\n\r\n      // Return a 53 bit integer n, where 0 <= n < 9007199254740992.\r\n      // Check if Math.random() produces more than 32 bits of randomness.\r\n      // If it does, assume at least 53 bits are produced, otherwise assume at least 30 bits.\r\n      // 0x40000000 is 2^30, 0x800000 is 2^23, 0x1fffff is 2^21 - 1.\r\n      var random53bitInt = (Math.random() * pow2_53) & 0x1fffff\r\n       ? function () { return mathfloor(Math.random() * pow2_53); }\r\n       : function () { return ((Math.random() * 0x40000000 | 0) * 0x800000) +\r\n         (Math.random() * 0x800000 | 0); };\r\n\r\n      return function (dp) {\r\n        var a, b, e, k, v,\r\n          i = 0,\r\n          c = [],\r\n          rand = new BigNumber(ONE);\r\n\r\n        if (dp == null) dp = DECIMAL_PLACES;\r\n        else intCheck(dp, 0, MAX);\r\n\r\n        k = mathceil(dp / LOG_BASE);\r\n\r\n        if (CRYPTO) {\r\n\r\n          // Browsers supporting crypto.getRandomValues.\r\n          if (crypto.getRandomValues) {\r\n\r\n            a = crypto.getRandomValues(new Uint32Array(k *= 2));\r\n\r\n            for (; i < k;) {\r\n\r\n              // 53 bits:\r\n              // ((Math.pow(2, 32) - 1) * Math.pow(2, 21)).toString(2)\r\n              // 11111 11111111 11111111 11111111 11100000 00000000 00000000\r\n              // ((Math.pow(2, 32) - 1) >>> 11).toString(2)\r\n              //                                     11111 11111111 11111111\r\n              // 0x20000 is 2^21.\r\n              v = a[i] * 0x20000 + (a[i + 1] >>> 11);\r\n\r\n              // Rejection sampling:\r\n              // 0 <= v < 9007199254740992\r\n              // Probability that v >= 9e15, is\r\n              // 7199254740992 / 9007199254740992 ~= 0.0008, i.e. 1 in 1251\r\n              if (v >= 9e15) {\r\n                b = crypto.getRandomValues(new Uint32Array(2));\r\n                a[i] = b[0];\r\n                a[i + 1] = b[1];\r\n              } else {\r\n\r\n                // 0 <= v <= 8999999999999999\r\n                // 0 <= (v % 1e14) <= 99999999999999\r\n                c.push(v % 1e14);\r\n                i += 2;\r\n              }\r\n            }\r\n            i = k / 2;\r\n\r\n          // Node.js supporting crypto.randomBytes.\r\n          } else if (crypto.randomBytes) {\r\n\r\n            // buffer\r\n            a = crypto.randomBytes(k *= 7);\r\n\r\n            for (; i < k;) {\r\n\r\n              // 0x1000000000000 is 2^48, 0x10000000000 is 2^40\r\n              // 0x100000000 is 2^32, 0x1000000 is 2^24\r\n              // 11111 11111111 11111111 11111111 11111111 11111111 11111111\r\n              // 0 <= v < 9007199254740992\r\n              v = ((a[i] & 31) * 0x1000000000000) + (a[i + 1] * 0x10000000000) +\r\n                 (a[i + 2] * 0x100000000) + (a[i + 3] * 0x1000000) +\r\n                 (a[i + 4] << 16) + (a[i + 5] << 8) + a[i + 6];\r\n\r\n              if (v >= 9e15) {\r\n                crypto.randomBytes(7).copy(a, i);\r\n              } else {\r\n\r\n                // 0 <= (v % 1e14) <= 99999999999999\r\n                c.push(v % 1e14);\r\n                i += 7;\r\n              }\r\n            }\r\n            i = k / 7;\r\n          } else {\r\n            CRYPTO = false;\r\n            throw Error\r\n             (bignumberError + 'crypto unavailable');\r\n          }\r\n        }\r\n\r\n        // Use Math.random.\r\n        if (!CRYPTO) {\r\n\r\n          for (; i < k;) {\r\n            v = random53bitInt();\r\n            if (v < 9e15) c[i++] = v % 1e14;\r\n          }\r\n        }\r\n\r\n        k = c[--i];\r\n        dp %= LOG_BASE;\r\n\r\n        // Convert trailing digits to zeros according to dp.\r\n        if (k && dp) {\r\n          v = POWS_TEN[LOG_BASE - dp];\r\n          c[i] = mathfloor(k / v) * v;\r\n        }\r\n\r\n        // Remove trailing elements which are zero.\r\n        for (; c[i] === 0; c.pop(), i--);\r\n\r\n        // Zero?\r\n        if (i < 0) {\r\n          c = [e = 0];\r\n        } else {\r\n\r\n          // Remove leading elements which are zero and adjust exponent accordingly.\r\n          for (e = -1 ; c[0] === 0; c.splice(0, 1), e -= LOG_BASE);\r\n\r\n          // Count the digits of the first element of c to determine leading zeros, and...\r\n          for (i = 1, v = c[0]; v >= 10; v /= 10, i++);\r\n\r\n          // adjust the exponent accordingly.\r\n          if (i < LOG_BASE) e -= LOG_BASE - i;\r\n        }\r\n\r\n        rand.e = e;\r\n        rand.c = c;\r\n        return rand;\r\n      };\r\n    })();\r\n\r\n\r\n    /*\r\n     * Return a BigNumber whose value is the sum of the arguments.\r\n     *\r\n     * arguments {number|string|BigNumber}\r\n     */\r\n    BigNumber.sum = function () {\r\n      var i = 1,\r\n        args = arguments,\r\n        sum = new BigNumber(args[0]);\r\n      for (; i < args.length;) sum = sum.plus(args[i++]);\r\n      return sum;\r\n    };\r\n\r\n\r\n    // PRIVATE FUNCTIONS\r\n\r\n\r\n    // Called by BigNumber and BigNumber.prototype.toString.\r\n    convertBase = (function () {\r\n      var decimal = '0123456789';\r\n\r\n      /*\r\n       * Convert string of baseIn to an array of numbers of baseOut.\r\n       * Eg. toBaseOut('255', 10, 16) returns [15, 15].\r\n       * Eg. toBaseOut('ff', 16, 10) returns [2, 5, 5].\r\n       */\r\n      function toBaseOut(str, baseIn, baseOut, alphabet) {\r\n        var j,\r\n          arr = [0],\r\n          arrL,\r\n          i = 0,\r\n          len = str.length;\r\n\r\n        for (; i < len;) {\r\n          for (arrL = arr.length; arrL--; arr[arrL] *= baseIn);\r\n\r\n          arr[0] += alphabet.indexOf(str.charAt(i++));\r\n\r\n          for (j = 0; j < arr.length; j++) {\r\n\r\n            if (arr[j] > baseOut - 1) {\r\n              if (arr[j + 1] == null) arr[j + 1] = 0;\r\n              arr[j + 1] += arr[j] / baseOut | 0;\r\n              arr[j] %= baseOut;\r\n            }\r\n          }\r\n        }\r\n\r\n        return arr.reverse();\r\n      }\r\n\r\n      // Convert a numeric string of baseIn to a numeric string of baseOut.\r\n      // If the caller is toString, we are converting from base 10 to baseOut.\r\n      // If the caller is BigNumber, we are converting from baseIn to base 10.\r\n      return function (str, baseIn, baseOut, sign, callerIsToString) {\r\n        var alphabet, d, e, k, r, x, xc, y,\r\n          i = str.indexOf('.'),\r\n          dp = DECIMAL_PLACES,\r\n          rm = ROUNDING_MODE;\r\n\r\n        // Non-integer.\r\n        if (i >= 0) {\r\n          k = POW_PRECISION;\r\n\r\n          // Unlimited precision.\r\n          POW_PRECISION = 0;\r\n          str = str.replace('.', '');\r\n          y = new BigNumber(baseIn);\r\n          x = y.pow(str.length - i);\r\n          POW_PRECISION = k;\r\n\r\n          // Convert str as if an integer, then restore the fraction part by dividing the\r\n          // result by its base raised to a power.\r\n\r\n          y.c = toBaseOut(toFixedPoint(coeffToString(x.c), x.e, '0'),\r\n           10, baseOut, decimal);\r\n          y.e = y.c.length;\r\n        }\r\n\r\n        // Convert the number as integer.\r\n\r\n        xc = toBaseOut(str, baseIn, baseOut, callerIsToString\r\n         ? (alphabet = ALPHABET, decimal)\r\n         : (alphabet = decimal, ALPHABET));\r\n\r\n        // xc now represents str as an integer and converted to baseOut. e is the exponent.\r\n        e = k = xc.length;\r\n\r\n        // Remove trailing zeros.\r\n        for (; xc[--k] == 0; xc.pop());\r\n\r\n        // Zero?\r\n        if (!xc[0]) return alphabet.charAt(0);\r\n\r\n        // Does str represent an integer? If so, no need for the division.\r\n        if (i < 0) {\r\n          --e;\r\n        } else {\r\n          x.c = xc;\r\n          x.e = e;\r\n\r\n          // The sign is needed for correct rounding.\r\n          x.s = sign;\r\n          x = div(x, y, dp, rm, baseOut);\r\n          xc = x.c;\r\n          r = x.r;\r\n          e = x.e;\r\n        }\r\n\r\n        // xc now represents str converted to baseOut.\r\n\r\n        // THe index of the rounding digit.\r\n        d = e + dp + 1;\r\n\r\n        // The rounding digit: the digit to the right of the digit that may be rounded up.\r\n        i = xc[d];\r\n\r\n        // Look at the rounding digits and mode to determine whether to round up.\r\n\r\n        k = baseOut / 2;\r\n        r = r || d < 0 || xc[d + 1] != null;\r\n\r\n        r = rm < 4 ? (i != null || r) && (rm == 0 || rm == (x.s < 0 ? 3 : 2))\r\n              : i > k || i == k &&(rm == 4 || r || rm == 6 && xc[d - 1] & 1 ||\r\n               rm == (x.s < 0 ? 8 : 7));\r\n\r\n        // If the index of the rounding digit is not greater than zero, or xc represents\r\n        // zero, then the result of the base conversion is zero or, if rounding up, a value\r\n        // such as 0.00001.\r\n        if (d < 1 || !xc[0]) {\r\n\r\n          // 1^-dp or 0\r\n          str = r ? toFixedPoint(alphabet.charAt(1), -dp, alphabet.charAt(0)) : alphabet.charAt(0);\r\n        } else {\r\n\r\n          // Truncate xc to the required number of decimal places.\r\n          xc.length = d;\r\n\r\n          // Round up?\r\n          if (r) {\r\n\r\n            // Rounding up may mean the previous digit has to be rounded up and so on.\r\n            for (--baseOut; ++xc[--d] > baseOut;) {\r\n              xc[d] = 0;\r\n\r\n              if (!d) {\r\n                ++e;\r\n                xc = [1].concat(xc);\r\n              }\r\n            }\r\n          }\r\n\r\n          // Determine trailing zeros.\r\n          for (k = xc.length; !xc[--k];);\r\n\r\n          // E.g. [4, 11, 15] becomes 4bf.\r\n          for (i = 0, str = ''; i <= k; str += alphabet.charAt(xc[i++]));\r\n\r\n          // Add leading zeros, decimal point and trailing zeros as required.\r\n          str = toFixedPoint(str, e, alphabet.charAt(0));\r\n        }\r\n\r\n        // The caller will add the sign.\r\n        return str;\r\n      };\r\n    })();\r\n\r\n\r\n    // Perform division in the specified base. Called by div and convertBase.\r\n    div = (function () {\r\n\r\n      // Assume non-zero x and k.\r\n      function multiply(x, k, base) {\r\n        var m, temp, xlo, xhi,\r\n          carry = 0,\r\n          i = x.length,\r\n          klo = k % SQRT_BASE,\r\n          khi = k / SQRT_BASE | 0;\r\n\r\n        for (x = x.slice(); i--;) {\r\n          xlo = x[i] % SQRT_BASE;\r\n          xhi = x[i] / SQRT_BASE | 0;\r\n          m = khi * xlo + xhi * klo;\r\n          temp = klo * xlo + ((m % SQRT_BASE) * SQRT_BASE) + carry;\r\n          carry = (temp / base | 0) + (m / SQRT_BASE | 0) + khi * xhi;\r\n          x[i] = temp % base;\r\n        }\r\n\r\n        if (carry) x = [carry].concat(x);\r\n\r\n        return x;\r\n      }\r\n\r\n      function compare(a, b, aL, bL) {\r\n        var i, cmp;\r\n\r\n        if (aL != bL) {\r\n          cmp = aL > bL ? 1 : -1;\r\n        } else {\r\n\r\n          for (i = cmp = 0; i < aL; i++) {\r\n\r\n            if (a[i] != b[i]) {\r\n              cmp = a[i] > b[i] ? 1 : -1;\r\n              break;\r\n            }\r\n          }\r\n        }\r\n\r\n        return cmp;\r\n      }\r\n\r\n      function subtract(a, b, aL, base) {\r\n        var i = 0;\r\n\r\n        // Subtract b from a.\r\n        for (; aL--;) {\r\n          a[aL] -= i;\r\n          i = a[aL] < b[aL] ? 1 : 0;\r\n          a[aL] = i * base + a[aL] - b[aL];\r\n        }\r\n\r\n        // Remove leading zeros.\r\n        for (; !a[0] && a.length > 1; a.splice(0, 1));\r\n      }\r\n\r\n      // x: dividend, y: divisor.\r\n      return function (x, y, dp, rm, base) {\r\n        var cmp, e, i, more, n, prod, prodL, q, qc, rem, remL, rem0, xi, xL, yc0,\r\n          yL, yz,\r\n          s = x.s == y.s ? 1 : -1,\r\n          xc = x.c,\r\n          yc = y.c;\r\n\r\n        // Either NaN, Infinity or 0?\r\n        if (!xc || !xc[0] || !yc || !yc[0]) {\r\n\r\n          return new BigNumber(\r\n\r\n           // Return NaN if either NaN, or both Infinity or 0.\r\n           !x.s || !y.s || (xc ? yc && xc[0] == yc[0] : !yc) ? NaN :\r\n\r\n            // Return ±0 if x is ±0 or y is ±Infinity, or return ±Infinity as y is ±0.\r\n            xc && xc[0] == 0 || !yc ? s * 0 : s / 0\r\n         );\r\n        }\r\n\r\n        q = new BigNumber(s);\r\n        qc = q.c = [];\r\n        e = x.e - y.e;\r\n        s = dp + e + 1;\r\n\r\n        if (!base) {\r\n          base = BASE;\r\n          e = bitFloor(x.e / LOG_BASE) - bitFloor(y.e / LOG_BASE);\r\n          s = s / LOG_BASE | 0;\r\n        }\r\n\r\n        // Result exponent may be one less then the current value of e.\r\n        // The coefficients of the BigNumbers from convertBase may have trailing zeros.\r\n        for (i = 0; yc[i] == (xc[i] || 0); i++);\r\n\r\n        if (yc[i] > (xc[i] || 0)) e--;\r\n\r\n        if (s < 0) {\r\n          qc.push(1);\r\n          more = true;\r\n        } else {\r\n          xL = xc.length;\r\n          yL = yc.length;\r\n          i = 0;\r\n          s += 2;\r\n\r\n          // Normalise xc and yc so highest order digit of yc is >= base / 2.\r\n\r\n          n = mathfloor(base / (yc[0] + 1));\r\n\r\n          // Not necessary, but to handle odd bases where yc[0] == (base / 2) - 1.\r\n          // if (n > 1 || n++ == 1 && yc[0] < base / 2) {\r\n          if (n > 1) {\r\n            yc = multiply(yc, n, base);\r\n            xc = multiply(xc, n, base);\r\n            yL = yc.length;\r\n            xL = xc.length;\r\n          }\r\n\r\n          xi = yL;\r\n          rem = xc.slice(0, yL);\r\n          remL = rem.length;\r\n\r\n          // Add zeros to make remainder as long as divisor.\r\n          for (; remL < yL; rem[remL++] = 0);\r\n          yz = yc.slice();\r\n          yz = [0].concat(yz);\r\n          yc0 = yc[0];\r\n          if (yc[1] >= base / 2) yc0++;\r\n          // Not necessary, but to prevent trial digit n > base, when using base 3.\r\n          // else if (base == 3 && yc0 == 1) yc0 = 1 + 1e-15;\r\n\r\n          do {\r\n            n = 0;\r\n\r\n            // Compare divisor and remainder.\r\n            cmp = compare(yc, rem, yL, remL);\r\n\r\n            // If divisor < remainder.\r\n            if (cmp < 0) {\r\n\r\n              // Calculate trial digit, n.\r\n\r\n              rem0 = rem[0];\r\n              if (yL != remL) rem0 = rem0 * base + (rem[1] || 0);\r\n\r\n              // n is how many times the divisor goes into the current remainder.\r\n              n = mathfloor(rem0 / yc0);\r\n\r\n              //  Algorithm:\r\n              //  product = divisor multiplied by trial digit (n).\r\n              //  Compare product and remainder.\r\n              //  If product is greater than remainder:\r\n              //    Subtract divisor from product, decrement trial digit.\r\n              //  Subtract product from remainder.\r\n              //  If product was less than remainder at the last compare:\r\n              //    Compare new remainder and divisor.\r\n              //    If remainder is greater than divisor:\r\n              //      Subtract divisor from remainder, increment trial digit.\r\n\r\n              if (n > 1) {\r\n\r\n                // n may be > base only when base is 3.\r\n                if (n >= base) n = base - 1;\r\n\r\n                // product = divisor * trial digit.\r\n                prod = multiply(yc, n, base);\r\n                prodL = prod.length;\r\n                remL = rem.length;\r\n\r\n                // Compare product and remainder.\r\n                // If product > remainder then trial digit n too high.\r\n                // n is 1 too high about 5% of the time, and is not known to have\r\n                // ever been more than 1 too high.\r\n                while (compare(prod, rem, prodL, remL) == 1) {\r\n                  n--;\r\n\r\n                  // Subtract divisor from product.\r\n                  subtract(prod, yL < prodL ? yz : yc, prodL, base);\r\n                  prodL = prod.length;\r\n                  cmp = 1;\r\n                }\r\n              } else {\r\n\r\n                // n is 0 or 1, cmp is -1.\r\n                // If n is 0, there is no need to compare yc and rem again below,\r\n                // so change cmp to 1 to avoid it.\r\n                // If n is 1, leave cmp as -1, so yc and rem are compared again.\r\n                if (n == 0) {\r\n\r\n                  // divisor < remainder, so n must be at least 1.\r\n                  cmp = n = 1;\r\n                }\r\n\r\n                // product = divisor\r\n                prod = yc.slice();\r\n                prodL = prod.length;\r\n              }\r\n\r\n              if (prodL < remL) prod = [0].concat(prod);\r\n\r\n              // Subtract product from remainder.\r\n              subtract(rem, prod, remL, base);\r\n              remL = rem.length;\r\n\r\n               // If product was < remainder.\r\n              if (cmp == -1) {\r\n\r\n                // Compare divisor and new remainder.\r\n                // If divisor < new remainder, subtract divisor from remainder.\r\n                // Trial digit n too low.\r\n                // n is 1 too low about 5% of the time, and very rarely 2 too low.\r\n                while (compare(yc, rem, yL, remL) < 1) {\r\n                  n++;\r\n\r\n                  // Subtract divisor from remainder.\r\n                  subtract(rem, yL < remL ? yz : yc, remL, base);\r\n                  remL = rem.length;\r\n                }\r\n              }\r\n            } else if (cmp === 0) {\r\n              n++;\r\n              rem = [0];\r\n            } // else cmp === 1 and n will be 0\r\n\r\n            // Add the next digit, n, to the result array.\r\n            qc[i++] = n;\r\n\r\n            // Update the remainder.\r\n            if (rem[0]) {\r\n              rem[remL++] = xc[xi] || 0;\r\n            } else {\r\n              rem = [xc[xi]];\r\n              remL = 1;\r\n            }\r\n          } while ((xi++ < xL || rem[0] != null) && s--);\r\n\r\n          more = rem[0] != null;\r\n\r\n          // Leading zero?\r\n          if (!qc[0]) qc.splice(0, 1);\r\n        }\r\n\r\n        if (base == BASE) {\r\n\r\n          // To calculate q.e, first get the number of digits of qc[0].\r\n          for (i = 1, s = qc[0]; s >= 10; s /= 10, i++);\r\n\r\n          round(q, dp + (q.e = i + e * LOG_BASE - 1) + 1, rm, more);\r\n\r\n        // Caller is convertBase.\r\n        } else {\r\n          q.e = e;\r\n          q.r = +more;\r\n        }\r\n\r\n        return q;\r\n      };\r\n    })();\r\n\r\n\r\n    /*\r\n     * Return a string representing the value of BigNumber n in fixed-point or exponential\r\n     * notation rounded to the specified decimal places or significant digits.\r\n     *\r\n     * n: a BigNumber.\r\n     * i: the index of the last digit required (i.e. the digit that may be rounded up).\r\n     * rm: the rounding mode.\r\n     * id: 1 (toExponential) or 2 (toPrecision).\r\n     */\r\n    function format(n, i, rm, id) {\r\n      var c0, e, ne, len, str;\r\n\r\n      if (rm == null) rm = ROUNDING_MODE;\r\n      else intCheck(rm, 0, 8);\r\n\r\n      if (!n.c) return n.toString();\r\n\r\n      c0 = n.c[0];\r\n      ne = n.e;\r\n\r\n      if (i == null) {\r\n        str = coeffToString(n.c);\r\n        str = id == 1 || id == 2 && (ne <= TO_EXP_NEG || ne >= TO_EXP_POS)\r\n         ? toExponential(str, ne)\r\n         : toFixedPoint(str, ne, '0');\r\n      } else {\r\n        n = round(new BigNumber(n), i, rm);\r\n\r\n        // n.e may have changed if the value was rounded up.\r\n        e = n.e;\r\n\r\n        str = coeffToString(n.c);\r\n        len = str.length;\r\n\r\n        // toPrecision returns exponential notation if the number of significant digits\r\n        // specified is less than the number of digits necessary to represent the integer\r\n        // part of the value in fixed-point notation.\r\n\r\n        // Exponential notation.\r\n        if (id == 1 || id == 2 && (i <= e || e <= TO_EXP_NEG)) {\r\n\r\n          // Append zeros?\r\n          for (; len < i; str += '0', len++);\r\n          str = toExponential(str, e);\r\n\r\n        // Fixed-point notation.\r\n        } else {\r\n          i -= ne;\r\n          str = toFixedPoint(str, e, '0');\r\n\r\n          // Append zeros?\r\n          if (e + 1 > len) {\r\n            if (--i > 0) for (str += '.'; i--; str += '0');\r\n          } else {\r\n            i += e - len;\r\n            if (i > 0) {\r\n              if (e + 1 == len) str += '.';\r\n              for (; i--; str += '0');\r\n            }\r\n          }\r\n        }\r\n      }\r\n\r\n      return n.s < 0 && c0 ? '-' + str : str;\r\n    }\r\n\r\n\r\n    // Handle BigNumber.max and BigNumber.min.\r\n    function maxOrMin(args, method) {\r\n      var n,\r\n        i = 1,\r\n        m = new BigNumber(args[0]);\r\n\r\n      for (; i < args.length; i++) {\r\n        n = new BigNumber(args[i]);\r\n\r\n        // If any number is NaN, return NaN.\r\n        if (!n.s) {\r\n          m = n;\r\n          break;\r\n        } else if (method.call(m, n)) {\r\n          m = n;\r\n        }\r\n      }\r\n\r\n      return m;\r\n    }\r\n\r\n\r\n    /*\r\n     * Strip trailing zeros, calculate base 10 exponent and check against MIN_EXP and MAX_EXP.\r\n     * Called by minus, plus and times.\r\n     */\r\n    function normalise(n, c, e) {\r\n      var i = 1,\r\n        j = c.length;\r\n\r\n       // Remove trailing zeros.\r\n      for (; !c[--j]; c.pop());\r\n\r\n      // Calculate the base 10 exponent. First get the number of digits of c[0].\r\n      for (j = c[0]; j >= 10; j /= 10, i++);\r\n\r\n      // Overflow?\r\n      if ((e = i + e * LOG_BASE - 1) > MAX_EXP) {\r\n\r\n        // Infinity.\r\n        n.c = n.e = null;\r\n\r\n      // Underflow?\r\n      } else if (e < MIN_EXP) {\r\n\r\n        // Zero.\r\n        n.c = [n.e = 0];\r\n      } else {\r\n        n.e = e;\r\n        n.c = c;\r\n      }\r\n\r\n      return n;\r\n    }\r\n\r\n\r\n    // Handle values that fail the validity test in BigNumber.\r\n    parseNumeric = (function () {\r\n      var basePrefix = /^(-?)0([xbo])(?=\\w[\\w.]*$)/i,\r\n        dotAfter = /^([^.]+)\\.$/,\r\n        dotBefore = /^\\.([^.]+)$/,\r\n        isInfinityOrNaN = /^-?(Infinity|NaN)$/,\r\n        whitespaceOrPlus = /^\\s*\\+(?=[\\w.])|^\\s+|\\s+$/g;\r\n\r\n      return function (x, str, isNum, b) {\r\n        var base,\r\n          s = isNum ? str : str.replace(whitespaceOrPlus, '');\r\n\r\n        // No exception on ±Infinity or NaN.\r\n        if (isInfinityOrNaN.test(s)) {\r\n          x.s = isNaN(s) ? null : s < 0 ? -1 : 1;\r\n        } else {\r\n          if (!isNum) {\r\n\r\n            // basePrefix = /^(-?)0([xbo])(?=\\w[\\w.]*$)/i\r\n            s = s.replace(basePrefix, function (m, p1, p2) {\r\n              base = (p2 = p2.toLowerCase()) == 'x' ? 16 : p2 == 'b' ? 2 : 8;\r\n              return !b || b == base ? p1 : m;\r\n            });\r\n\r\n            if (b) {\r\n              base = b;\r\n\r\n              // E.g. '1.' to '1', '.1' to '0.1'\r\n              s = s.replace(dotAfter, '$1').replace(dotBefore, '0.$1');\r\n            }\r\n\r\n            if (str != s) return new BigNumber(s, base);\r\n          }\r\n\r\n          // '[BigNumber Error] Not a number: {n}'\r\n          // '[BigNumber Error] Not a base {b} number: {n}'\r\n          if (BigNumber.DEBUG) {\r\n            throw Error\r\n              (bignumberError + 'Not a' + (b ? ' base ' + b : '') + ' number: ' + str);\r\n          }\r\n\r\n          // NaN\r\n          x.s = null;\r\n        }\r\n\r\n        x.c = x.e = null;\r\n      }\r\n    })();\r\n\r\n\r\n    /*\r\n     * Round x to sd significant digits using rounding mode rm. Check for over/under-flow.\r\n     * If r is truthy, it is known that there are more digits after the rounding digit.\r\n     */\r\n    function round(x, sd, rm, r) {\r\n      var d, i, j, k, n, ni, rd,\r\n        xc = x.c,\r\n        pows10 = POWS_TEN;\r\n\r\n      // if x is not Infinity or NaN...\r\n      if (xc) {\r\n\r\n        // rd is the rounding digit, i.e. the digit after the digit that may be rounded up.\r\n        // n is a base 1e14 number, the value of the element of array x.c containing rd.\r\n        // ni is the index of n within x.c.\r\n        // d is the number of digits of n.\r\n        // i is the index of rd within n including leading zeros.\r\n        // j is the actual index of rd within n (if < 0, rd is a leading zero).\r\n        out: {\r\n\r\n          // Get the number of digits of the first element of xc.\r\n          for (d = 1, k = xc[0]; k >= 10; k /= 10, d++);\r\n          i = sd - d;\r\n\r\n          // If the rounding digit is in the first element of xc...\r\n          if (i < 0) {\r\n            i += LOG_BASE;\r\n            j = sd;\r\n            n = xc[ni = 0];\r\n\r\n            // Get the rounding digit at index j of n.\r\n            rd = n / pows10[d - j - 1] % 10 | 0;\r\n          } else {\r\n            ni = mathceil((i + 1) / LOG_BASE);\r\n\r\n            if (ni >= xc.length) {\r\n\r\n              if (r) {\r\n\r\n                // Needed by sqrt.\r\n                for (; xc.length <= ni; xc.push(0));\r\n                n = rd = 0;\r\n                d = 1;\r\n                i %= LOG_BASE;\r\n                j = i - LOG_BASE + 1;\r\n              } else {\r\n                break out;\r\n              }\r\n            } else {\r\n              n = k = xc[ni];\r\n\r\n              // Get the number of digits of n.\r\n              for (d = 1; k >= 10; k /= 10, d++);\r\n\r\n              // Get the index of rd within n.\r\n              i %= LOG_BASE;\r\n\r\n              // Get the index of rd within n, adjusted for leading zeros.\r\n              // The number of leading zeros of n is given by LOG_BASE - d.\r\n              j = i - LOG_BASE + d;\r\n\r\n              // Get the rounding digit at index j of n.\r\n              rd = j < 0 ? 0 : n / pows10[d - j - 1] % 10 | 0;\r\n            }\r\n          }\r\n\r\n          r = r || sd < 0 ||\r\n\r\n          // Are there any non-zero digits after the rounding digit?\r\n          // The expression  n % pows10[d - j - 1]  returns all digits of n to the right\r\n          // of the digit at j, e.g. if n is 908714 and j is 2, the expression gives 714.\r\n           xc[ni + 1] != null || (j < 0 ? n : n % pows10[d - j - 1]);\r\n\r\n          r = rm < 4\r\n           ? (rd || r) && (rm == 0 || rm == (x.s < 0 ? 3 : 2))\r\n           : rd > 5 || rd == 5 && (rm == 4 || r || rm == 6 &&\r\n\r\n            // Check whether the digit to the left of the rounding digit is odd.\r\n            ((i > 0 ? j > 0 ? n / pows10[d - j] : 0 : xc[ni - 1]) % 10) & 1 ||\r\n             rm == (x.s < 0 ? 8 : 7));\r\n\r\n          if (sd < 1 || !xc[0]) {\r\n            xc.length = 0;\r\n\r\n            if (r) {\r\n\r\n              // Convert sd to decimal places.\r\n              sd -= x.e + 1;\r\n\r\n              // 1, 0.1, 0.01, 0.001, 0.0001 etc.\r\n              xc[0] = pows10[(LOG_BASE - sd % LOG_BASE) % LOG_BASE];\r\n              x.e = -sd || 0;\r\n            } else {\r\n\r\n              // Zero.\r\n              xc[0] = x.e = 0;\r\n            }\r\n\r\n            return x;\r\n          }\r\n\r\n          // Remove excess digits.\r\n          if (i == 0) {\r\n            xc.length = ni;\r\n            k = 1;\r\n            ni--;\r\n          } else {\r\n            xc.length = ni + 1;\r\n            k = pows10[LOG_BASE - i];\r\n\r\n            // E.g. 56700 becomes 56000 if 7 is the rounding digit.\r\n            // j > 0 means i > number of leading zeros of n.\r\n            xc[ni] = j > 0 ? mathfloor(n / pows10[d - j] % pows10[j]) * k : 0;\r\n          }\r\n\r\n          // Round up?\r\n          if (r) {\r\n\r\n            for (; ;) {\r\n\r\n              // If the digit to be rounded up is in the first element of xc...\r\n              if (ni == 0) {\r\n\r\n                // i will be the length of xc[0] before k is added.\r\n                for (i = 1, j = xc[0]; j >= 10; j /= 10, i++);\r\n                j = xc[0] += k;\r\n                for (k = 1; j >= 10; j /= 10, k++);\r\n\r\n                // if i != k the length has increased.\r\n                if (i != k) {\r\n                  x.e++;\r\n                  if (xc[0] == BASE) xc[0] = 1;\r\n                }\r\n\r\n                break;\r\n              } else {\r\n                xc[ni] += k;\r\n                if (xc[ni] != BASE) break;\r\n                xc[ni--] = 0;\r\n                k = 1;\r\n              }\r\n            }\r\n          }\r\n\r\n          // Remove trailing zeros.\r\n          for (i = xc.length; xc[--i] === 0; xc.pop());\r\n        }\r\n\r\n        // Overflow? Infinity.\r\n        if (x.e > MAX_EXP) {\r\n          x.c = x.e = null;\r\n\r\n        // Underflow? Zero.\r\n        } else if (x.e < MIN_EXP) {\r\n          x.c = [x.e = 0];\r\n        }\r\n      }\r\n\r\n      return x;\r\n    }\r\n\r\n\r\n    function valueOf(n) {\r\n      var str,\r\n        e = n.e;\r\n\r\n      if (e === null) return n.toString();\r\n\r\n      str = coeffToString(n.c);\r\n\r\n      str = e <= TO_EXP_NEG || e >= TO_EXP_POS\r\n        ? toExponential(str, e)\r\n        : toFixedPoint(str, e, '0');\r\n\r\n      return n.s < 0 ? '-' + str : str;\r\n    }\r\n\r\n\r\n    // PROTOTYPE/INSTANCE METHODS\r\n\r\n\r\n    /*\r\n     * Return a new BigNumber whose value is the absolute value of this BigNumber.\r\n     */\r\n    P.absoluteValue = P.abs = function () {\r\n      var x = new BigNumber(this);\r\n      if (x.s < 0) x.s = 1;\r\n      return x;\r\n    };\r\n\r\n\r\n    /*\r\n     * Return\r\n     *   1 if the value of this BigNumber is greater than the value of BigNumber(y, b),\r\n     *   -1 if the value of this BigNumber is less than the value of BigNumber(y, b),\r\n     *   0 if they have the same value,\r\n     *   or null if the value of either is NaN.\r\n     */\r\n    P.comparedTo = function (y, b) {\r\n      return compare(this, new BigNumber(y, b));\r\n    };\r\n\r\n\r\n    /*\r\n     * If dp is undefined or null or true or false, return the number of decimal places of the\r\n     * value of this BigNumber, or null if the value of this BigNumber is ±Infinity or NaN.\r\n     *\r\n     * Otherwise, if dp is a number, return a new BigNumber whose value is the value of this\r\n     * BigNumber rounded to a maximum of dp decimal places using rounding mode rm, or\r\n     * ROUNDING_MODE if rm is omitted.\r\n     *\r\n     * [dp] {number} Decimal places: integer, 0 to MAX inclusive.\r\n     * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n     *\r\n     * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {dp|rm}'\r\n     */\r\n    P.decimalPlaces = P.dp = function (dp, rm) {\r\n      var c, n, v,\r\n        x = this;\r\n\r\n      if (dp != null) {\r\n        intCheck(dp, 0, MAX);\r\n        if (rm == null) rm = ROUNDING_MODE;\r\n        else intCheck(rm, 0, 8);\r\n\r\n        return round(new BigNumber(x), dp + x.e + 1, rm);\r\n      }\r\n\r\n      if (!(c = x.c)) return null;\r\n      n = ((v = c.length - 1) - bitFloor(this.e / LOG_BASE)) * LOG_BASE;\r\n\r\n      // Subtract the number of trailing zeros of the last number.\r\n      if (v = c[v]) for (; v % 10 == 0; v /= 10, n--);\r\n      if (n < 0) n = 0;\r\n\r\n      return n;\r\n    };\r\n\r\n\r\n    /*\r\n     *  n / 0 = I\r\n     *  n / N = N\r\n     *  n / I = 0\r\n     *  0 / n = 0\r\n     *  0 / 0 = N\r\n     *  0 / N = N\r\n     *  0 / I = 0\r\n     *  N / n = N\r\n     *  N / 0 = N\r\n     *  N / N = N\r\n     *  N / I = N\r\n     *  I / n = I\r\n     *  I / 0 = I\r\n     *  I / N = N\r\n     *  I / I = N\r\n     *\r\n     * Return a new BigNumber whose value is the value of this BigNumber divided by the value of\r\n     * BigNumber(y, b), rounded according to DECIMAL_PLACES and ROUNDING_MODE.\r\n     */\r\n    P.dividedBy = P.div = function (y, b) {\r\n      return div(this, new BigNumber(y, b), DECIMAL_PLACES, ROUNDING_MODE);\r\n    };\r\n\r\n\r\n    /*\r\n     * Return a new BigNumber whose value is the integer part of dividing the value of this\r\n     * BigNumber by the value of BigNumber(y, b).\r\n     */\r\n    P.dividedToIntegerBy = P.idiv = function (y, b) {\r\n      return div(this, new BigNumber(y, b), 0, 1);\r\n    };\r\n\r\n\r\n    /*\r\n     * Return a BigNumber whose value is the value of this BigNumber exponentiated by n.\r\n     *\r\n     * If m is present, return the result modulo m.\r\n     * If n is negative round according to DECIMAL_PLACES and ROUNDING_MODE.\r\n     * If POW_PRECISION is non-zero and m is not present, round to POW_PRECISION using ROUNDING_MODE.\r\n     *\r\n     * The modular power operation works efficiently when x, n, and m are integers, otherwise it\r\n     * is equivalent to calculating x.exponentiatedBy(n).modulo(m) with a POW_PRECISION of 0.\r\n     *\r\n     * n {number|string|BigNumber} The exponent. An integer.\r\n     * [m] {number|string|BigNumber} The modulus.\r\n     *\r\n     * '[BigNumber Error] Exponent not an integer: {n}'\r\n     */\r\n    P.exponentiatedBy = P.pow = function (n, m) {\r\n      var half, isModExp, i, k, more, nIsBig, nIsNeg, nIsOdd, y,\r\n        x = this;\r\n\r\n      n = new BigNumber(n);\r\n\r\n      // Allow NaN and ±Infinity, but not other non-integers.\r\n      if (n.c && !n.isInteger()) {\r\n        throw Error\r\n          (bignumberError + 'Exponent not an integer: ' + valueOf(n));\r\n      }\r\n\r\n      if (m != null) m = new BigNumber(m);\r\n\r\n      // Exponent of MAX_SAFE_INTEGER is 15.\r\n      nIsBig = n.e > 14;\r\n\r\n      // If x is NaN, ±Infinity, ±0 or ±1, or n is ±Infinity, NaN or ±0.\r\n      if (!x.c || !x.c[0] || x.c[0] == 1 && !x.e && x.c.length == 1 || !n.c || !n.c[0]) {\r\n\r\n        // The sign of the result of pow when x is negative depends on the evenness of n.\r\n        // If +n overflows to ±Infinity, the evenness of n would be not be known.\r\n        y = new BigNumber(Math.pow(+valueOf(x), nIsBig ? 2 - isOdd(n) : +valueOf(n)));\r\n        return m ? y.mod(m) : y;\r\n      }\r\n\r\n      nIsNeg = n.s < 0;\r\n\r\n      if (m) {\r\n\r\n        // x % m returns NaN if abs(m) is zero, or m is NaN.\r\n        if (m.c ? !m.c[0] : !m.s) return new BigNumber(NaN);\r\n\r\n        isModExp = !nIsNeg && x.isInteger() && m.isInteger();\r\n\r\n        if (isModExp) x = x.mod(m);\r\n\r\n      // Overflow to ±Infinity: >=2**1e10 or >=1.0000024**1e15.\r\n      // Underflow to ±0: <=0.79**1e10 or <=0.9999975**1e15.\r\n      } else if (n.e > 9 && (x.e > 0 || x.e < -1 || (x.e == 0\r\n        // [1, 240000000]\r\n        ? x.c[0] > 1 || nIsBig && x.c[1] >= 24e7\r\n        // [80000000000000]  [99999750000000]\r\n        : x.c[0] < 8e13 || nIsBig && x.c[0] <= 9999975e7))) {\r\n\r\n        // If x is negative and n is odd, k = -0, else k = 0.\r\n        k = x.s < 0 && isOdd(n) ? -0 : 0;\r\n\r\n        // If x >= 1, k = ±Infinity.\r\n        if (x.e > -1) k = 1 / k;\r\n\r\n        // If n is negative return ±0, else return ±Infinity.\r\n        return new BigNumber(nIsNeg ? 1 / k : k);\r\n\r\n      } else if (POW_PRECISION) {\r\n\r\n        // Truncating each coefficient array to a length of k after each multiplication\r\n        // equates to truncating significant digits to POW_PRECISION + [28, 41],\r\n        // i.e. there will be a minimum of 28 guard digits retained.\r\n        k = mathceil(POW_PRECISION / LOG_BASE + 2);\r\n      }\r\n\r\n      if (nIsBig) {\r\n        half = new BigNumber(0.5);\r\n        if (nIsNeg) n.s = 1;\r\n        nIsOdd = isOdd(n);\r\n      } else {\r\n        i = Math.abs(+valueOf(n));\r\n        nIsOdd = i % 2;\r\n      }\r\n\r\n      y = new BigNumber(ONE);\r\n\r\n      // Performs 54 loop iterations for n of 9007199254740991.\r\n      for (; ;) {\r\n\r\n        if (nIsOdd) {\r\n          y = y.times(x);\r\n          if (!y.c) break;\r\n\r\n          if (k) {\r\n            if (y.c.length > k) y.c.length = k;\r\n          } else if (isModExp) {\r\n            y = y.mod(m);    //y = y.minus(div(y, m, 0, MODULO_MODE).times(m));\r\n          }\r\n        }\r\n\r\n        if (i) {\r\n          i = mathfloor(i / 2);\r\n          if (i === 0) break;\r\n          nIsOdd = i % 2;\r\n        } else {\r\n          n = n.times(half);\r\n          round(n, n.e + 1, 1);\r\n\r\n          if (n.e > 14) {\r\n            nIsOdd = isOdd(n);\r\n          } else {\r\n            i = +valueOf(n);\r\n            if (i === 0) break;\r\n            nIsOdd = i % 2;\r\n          }\r\n        }\r\n\r\n        x = x.times(x);\r\n\r\n        if (k) {\r\n          if (x.c && x.c.length > k) x.c.length = k;\r\n        } else if (isModExp) {\r\n          x = x.mod(m);    //x = x.minus(div(x, m, 0, MODULO_MODE).times(m));\r\n        }\r\n      }\r\n\r\n      if (isModExp) return y;\r\n      if (nIsNeg) y = ONE.div(y);\r\n\r\n      return m ? y.mod(m) : k ? round(y, POW_PRECISION, ROUNDING_MODE, more) : y;\r\n    };\r\n\r\n\r\n    /*\r\n     * Return a new BigNumber whose value is the value of this BigNumber rounded to an integer\r\n     * using rounding mode rm, or ROUNDING_MODE if rm is omitted.\r\n     *\r\n     * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n     *\r\n     * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {rm}'\r\n     */\r\n    P.integerValue = function (rm) {\r\n      var n = new BigNumber(this);\r\n      if (rm == null) rm = ROUNDING_MODE;\r\n      else intCheck(rm, 0, 8);\r\n      return round(n, n.e + 1, rm);\r\n    };\r\n\r\n\r\n    /*\r\n     * Return true if the value of this BigNumber is equal to the value of BigNumber(y, b),\r\n     * otherwise return false.\r\n     */\r\n    P.isEqualTo = P.eq = function (y, b) {\r\n      return compare(this, new BigNumber(y, b)) === 0;\r\n    };\r\n\r\n\r\n    /*\r\n     * Return true if the value of this BigNumber is a finite number, otherwise return false.\r\n     */\r\n    P.isFinite = function () {\r\n      return !!this.c;\r\n    };\r\n\r\n\r\n    /*\r\n     * Return true if the value of this BigNumber is greater than the value of BigNumber(y, b),\r\n     * otherwise return false.\r\n     */\r\n    P.isGreaterThan = P.gt = function (y, b) {\r\n      return compare(this, new BigNumber(y, b)) > 0;\r\n    };\r\n\r\n\r\n    /*\r\n     * Return true if the value of this BigNumber is greater than or equal to the value of\r\n     * BigNumber(y, b), otherwise return false.\r\n     */\r\n    P.isGreaterThanOrEqualTo = P.gte = function (y, b) {\r\n      return (b = compare(this, new BigNumber(y, b))) === 1 || b === 0;\r\n\r\n    };\r\n\r\n\r\n    /*\r\n     * Return true if the value of this BigNumber is an integer, otherwise return false.\r\n     */\r\n    P.isInteger = function () {\r\n      return !!this.c && bitFloor(this.e / LOG_BASE) > this.c.length - 2;\r\n    };\r\n\r\n\r\n    /*\r\n     * Return true if the value of this BigNumber is less than the value of BigNumber(y, b),\r\n     * otherwise return false.\r\n     */\r\n    P.isLessThan = P.lt = function (y, b) {\r\n      return compare(this, new BigNumber(y, b)) < 0;\r\n    };\r\n\r\n\r\n    /*\r\n     * Return true if the value of this BigNumber is less than or equal to the value of\r\n     * BigNumber(y, b), otherwise return false.\r\n     */\r\n    P.isLessThanOrEqualTo = P.lte = function (y, b) {\r\n      return (b = compare(this, new BigNumber(y, b))) === -1 || b === 0;\r\n    };\r\n\r\n\r\n    /*\r\n     * Return true if the value of this BigNumber is NaN, otherwise return false.\r\n     */\r\n    P.isNaN = function () {\r\n      return !this.s;\r\n    };\r\n\r\n\r\n    /*\r\n     * Return true if the value of this BigNumber is negative, otherwise return false.\r\n     */\r\n    P.isNegative = function () {\r\n      return this.s < 0;\r\n    };\r\n\r\n\r\n    /*\r\n     * Return true if the value of this BigNumber is positive, otherwise return false.\r\n     */\r\n    P.isPositive = function () {\r\n      return this.s > 0;\r\n    };\r\n\r\n\r\n    /*\r\n     * Return true if the value of this BigNumber is 0 or -0, otherwise return false.\r\n     */\r\n    P.isZero = function () {\r\n      return !!this.c && this.c[0] == 0;\r\n    };\r\n\r\n\r\n    /*\r\n     *  n - 0 = n\r\n     *  n - N = N\r\n     *  n - I = -I\r\n     *  0 - n = -n\r\n     *  0 - 0 = 0\r\n     *  0 - N = N\r\n     *  0 - I = -I\r\n     *  N - n = N\r\n     *  N - 0 = N\r\n     *  N - N = N\r\n     *  N - I = N\r\n     *  I - n = I\r\n     *  I - 0 = I\r\n     *  I - N = N\r\n     *  I - I = N\r\n     *\r\n     * Return a new BigNumber whose value is the value of this BigNumber minus the value of\r\n     * BigNumber(y, b).\r\n     */\r\n    P.minus = function (y, b) {\r\n      var i, j, t, xLTy,\r\n        x = this,\r\n        a = x.s;\r\n\r\n      y = new BigNumber(y, b);\r\n      b = y.s;\r\n\r\n      // Either NaN?\r\n      if (!a || !b) return new BigNumber(NaN);\r\n\r\n      // Signs differ?\r\n      if (a != b) {\r\n        y.s = -b;\r\n        return x.plus(y);\r\n      }\r\n\r\n      var xe = x.e / LOG_BASE,\r\n        ye = y.e / LOG_BASE,\r\n        xc = x.c,\r\n        yc = y.c;\r\n\r\n      if (!xe || !ye) {\r\n\r\n        // Either Infinity?\r\n        if (!xc || !yc) return xc ? (y.s = -b, y) : new BigNumber(yc ? x : NaN);\r\n\r\n        // Either zero?\r\n        if (!xc[0] || !yc[0]) {\r\n\r\n          // Return y if y is non-zero, x if x is non-zero, or zero if both are zero.\r\n          return yc[0] ? (y.s = -b, y) : new BigNumber(xc[0] ? x :\r\n\r\n           // IEEE 754 (2008) 6.3: n - n = -0 when rounding to -Infinity\r\n           ROUNDING_MODE == 3 ? -0 : 0);\r\n        }\r\n      }\r\n\r\n      xe = bitFloor(xe);\r\n      ye = bitFloor(ye);\r\n      xc = xc.slice();\r\n\r\n      // Determine which is the bigger number.\r\n      if (a = xe - ye) {\r\n\r\n        if (xLTy = a < 0) {\r\n          a = -a;\r\n          t = xc;\r\n        } else {\r\n          ye = xe;\r\n          t = yc;\r\n        }\r\n\r\n        t.reverse();\r\n\r\n        // Prepend zeros to equalise exponents.\r\n        for (b = a; b--; t.push(0));\r\n        t.reverse();\r\n      } else {\r\n\r\n        // Exponents equal. Check digit by digit.\r\n        j = (xLTy = (a = xc.length) < (b = yc.length)) ? a : b;\r\n\r\n        for (a = b = 0; b < j; b++) {\r\n\r\n          if (xc[b] != yc[b]) {\r\n            xLTy = xc[b] < yc[b];\r\n            break;\r\n          }\r\n        }\r\n      }\r\n\r\n      // x < y? Point xc to the array of the bigger number.\r\n      if (xLTy) t = xc, xc = yc, yc = t, y.s = -y.s;\r\n\r\n      b = (j = yc.length) - (i = xc.length);\r\n\r\n      // Append zeros to xc if shorter.\r\n      // No need to add zeros to yc if shorter as subtract only needs to start at yc.length.\r\n      if (b > 0) for (; b--; xc[i++] = 0);\r\n      b = BASE - 1;\r\n\r\n      // Subtract yc from xc.\r\n      for (; j > a;) {\r\n\r\n        if (xc[--j] < yc[j]) {\r\n          for (i = j; i && !xc[--i]; xc[i] = b);\r\n          --xc[i];\r\n          xc[j] += BASE;\r\n        }\r\n\r\n        xc[j] -= yc[j];\r\n      }\r\n\r\n      // Remove leading zeros and adjust exponent accordingly.\r\n      for (; xc[0] == 0; xc.splice(0, 1), --ye);\r\n\r\n      // Zero?\r\n      if (!xc[0]) {\r\n\r\n        // Following IEEE 754 (2008) 6.3,\r\n        // n - n = +0  but  n - n = -0  when rounding towards -Infinity.\r\n        y.s = ROUNDING_MODE == 3 ? -1 : 1;\r\n        y.c = [y.e = 0];\r\n        return y;\r\n      }\r\n\r\n      // No need to check for Infinity as +x - +y != Infinity && -x - -y != Infinity\r\n      // for finite x and y.\r\n      return normalise(y, xc, ye);\r\n    };\r\n\r\n\r\n    /*\r\n     *   n % 0 =  N\r\n     *   n % N =  N\r\n     *   n % I =  n\r\n     *   0 % n =  0\r\n     *  -0 % n = -0\r\n     *   0 % 0 =  N\r\n     *   0 % N =  N\r\n     *   0 % I =  0\r\n     *   N % n =  N\r\n     *   N % 0 =  N\r\n     *   N % N =  N\r\n     *   N % I =  N\r\n     *   I % n =  N\r\n     *   I % 0 =  N\r\n     *   I % N =  N\r\n     *   I % I =  N\r\n     *\r\n     * Return a new BigNumber whose value is the value of this BigNumber modulo the value of\r\n     * BigNumber(y, b). The result depends on the value of MODULO_MODE.\r\n     */\r\n    P.modulo = P.mod = function (y, b) {\r\n      var q, s,\r\n        x = this;\r\n\r\n      y = new BigNumber(y, b);\r\n\r\n      // Return NaN if x is Infinity or NaN, or y is NaN or zero.\r\n      if (!x.c || !y.s || y.c && !y.c[0]) {\r\n        return new BigNumber(NaN);\r\n\r\n      // Return x if y is Infinity or x is zero.\r\n      } else if (!y.c || x.c && !x.c[0]) {\r\n        return new BigNumber(x);\r\n      }\r\n\r\n      if (MODULO_MODE == 9) {\r\n\r\n        // Euclidian division: q = sign(y) * floor(x / abs(y))\r\n        // r = x - qy    where  0 <= r < abs(y)\r\n        s = y.s;\r\n        y.s = 1;\r\n        q = div(x, y, 0, 3);\r\n        y.s = s;\r\n        q.s *= s;\r\n      } else {\r\n        q = div(x, y, 0, MODULO_MODE);\r\n      }\r\n\r\n      y = x.minus(q.times(y));\r\n\r\n      // To match JavaScript %, ensure sign of zero is sign of dividend.\r\n      if (!y.c[0] && MODULO_MODE == 1) y.s = x.s;\r\n\r\n      return y;\r\n    };\r\n\r\n\r\n    /*\r\n     *  n * 0 = 0\r\n     *  n * N = N\r\n     *  n * I = I\r\n     *  0 * n = 0\r\n     *  0 * 0 = 0\r\n     *  0 * N = N\r\n     *  0 * I = N\r\n     *  N * n = N\r\n     *  N * 0 = N\r\n     *  N * N = N\r\n     *  N * I = N\r\n     *  I * n = I\r\n     *  I * 0 = N\r\n     *  I * N = N\r\n     *  I * I = I\r\n     *\r\n     * Return a new BigNumber whose value is the value of this BigNumber multiplied by the value\r\n     * of BigNumber(y, b).\r\n     */\r\n    P.multipliedBy = P.times = function (y, b) {\r\n      var c, e, i, j, k, m, xcL, xlo, xhi, ycL, ylo, yhi, zc,\r\n        base, sqrtBase,\r\n        x = this,\r\n        xc = x.c,\r\n        yc = (y = new BigNumber(y, b)).c;\r\n\r\n      // Either NaN, ±Infinity or ±0?\r\n      if (!xc || !yc || !xc[0] || !yc[0]) {\r\n\r\n        // Return NaN if either is NaN, or one is 0 and the other is Infinity.\r\n        if (!x.s || !y.s || xc && !xc[0] && !yc || yc && !yc[0] && !xc) {\r\n          y.c = y.e = y.s = null;\r\n        } else {\r\n          y.s *= x.s;\r\n\r\n          // Return ±Infinity if either is ±Infinity.\r\n          if (!xc || !yc) {\r\n            y.c = y.e = null;\r\n\r\n          // Return ±0 if either is ±0.\r\n          } else {\r\n            y.c = [0];\r\n            y.e = 0;\r\n          }\r\n        }\r\n\r\n        return y;\r\n      }\r\n\r\n      e = bitFloor(x.e / LOG_BASE) + bitFloor(y.e / LOG_BASE);\r\n      y.s *= x.s;\r\n      xcL = xc.length;\r\n      ycL = yc.length;\r\n\r\n      // Ensure xc points to longer array and xcL to its length.\r\n      if (xcL < ycL) zc = xc, xc = yc, yc = zc, i = xcL, xcL = ycL, ycL = i;\r\n\r\n      // Initialise the result array with zeros.\r\n      for (i = xcL + ycL, zc = []; i--; zc.push(0));\r\n\r\n      base = BASE;\r\n      sqrtBase = SQRT_BASE;\r\n\r\n      for (i = ycL; --i >= 0;) {\r\n        c = 0;\r\n        ylo = yc[i] % sqrtBase;\r\n        yhi = yc[i] / sqrtBase | 0;\r\n\r\n        for (k = xcL, j = i + k; j > i;) {\r\n          xlo = xc[--k] % sqrtBase;\r\n          xhi = xc[k] / sqrtBase | 0;\r\n          m = yhi * xlo + xhi * ylo;\r\n          xlo = ylo * xlo + ((m % sqrtBase) * sqrtBase) + zc[j] + c;\r\n          c = (xlo / base | 0) + (m / sqrtBase | 0) + yhi * xhi;\r\n          zc[j--] = xlo % base;\r\n        }\r\n\r\n        zc[j] = c;\r\n      }\r\n\r\n      if (c) {\r\n        ++e;\r\n      } else {\r\n        zc.splice(0, 1);\r\n      }\r\n\r\n      return normalise(y, zc, e);\r\n    };\r\n\r\n\r\n    /*\r\n     * Return a new BigNumber whose value is the value of this BigNumber negated,\r\n     * i.e. multiplied by -1.\r\n     */\r\n    P.negated = function () {\r\n      var x = new BigNumber(this);\r\n      x.s = -x.s || null;\r\n      return x;\r\n    };\r\n\r\n\r\n    /*\r\n     *  n + 0 = n\r\n     *  n + N = N\r\n     *  n + I = I\r\n     *  0 + n = n\r\n     *  0 + 0 = 0\r\n     *  0 + N = N\r\n     *  0 + I = I\r\n     *  N + n = N\r\n     *  N + 0 = N\r\n     *  N + N = N\r\n     *  N + I = N\r\n     *  I + n = I\r\n     *  I + 0 = I\r\n     *  I + N = N\r\n     *  I + I = I\r\n     *\r\n     * Return a new BigNumber whose value is the value of this BigNumber plus the value of\r\n     * BigNumber(y, b).\r\n     */\r\n    P.plus = function (y, b) {\r\n      var t,\r\n        x = this,\r\n        a = x.s;\r\n\r\n      y = new BigNumber(y, b);\r\n      b = y.s;\r\n\r\n      // Either NaN?\r\n      if (!a || !b) return new BigNumber(NaN);\r\n\r\n      // Signs differ?\r\n       if (a != b) {\r\n        y.s = -b;\r\n        return x.minus(y);\r\n      }\r\n\r\n      var xe = x.e / LOG_BASE,\r\n        ye = y.e / LOG_BASE,\r\n        xc = x.c,\r\n        yc = y.c;\r\n\r\n      if (!xe || !ye) {\r\n\r\n        // Return ±Infinity if either ±Infinity.\r\n        if (!xc || !yc) return new BigNumber(a / 0);\r\n\r\n        // Either zero?\r\n        // Return y if y is non-zero, x if x is non-zero, or zero if both are zero.\r\n        if (!xc[0] || !yc[0]) return yc[0] ? y : new BigNumber(xc[0] ? x : a * 0);\r\n      }\r\n\r\n      xe = bitFloor(xe);\r\n      ye = bitFloor(ye);\r\n      xc = xc.slice();\r\n\r\n      // Prepend zeros to equalise exponents. Faster to use reverse then do unshifts.\r\n      if (a = xe - ye) {\r\n        if (a > 0) {\r\n          ye = xe;\r\n          t = yc;\r\n        } else {\r\n          a = -a;\r\n          t = xc;\r\n        }\r\n\r\n        t.reverse();\r\n        for (; a--; t.push(0));\r\n        t.reverse();\r\n      }\r\n\r\n      a = xc.length;\r\n      b = yc.length;\r\n\r\n      // Point xc to the longer array, and b to the shorter length.\r\n      if (a - b < 0) t = yc, yc = xc, xc = t, b = a;\r\n\r\n      // Only start adding at yc.length - 1 as the further digits of xc can be ignored.\r\n      for (a = 0; b;) {\r\n        a = (xc[--b] = xc[b] + yc[b] + a) / BASE | 0;\r\n        xc[b] = BASE === xc[b] ? 0 : xc[b] % BASE;\r\n      }\r\n\r\n      if (a) {\r\n        xc = [a].concat(xc);\r\n        ++ye;\r\n      }\r\n\r\n      // No need to check for zero, as +x + +y != 0 && -x + -y != 0\r\n      // ye = MAX_EXP + 1 possible\r\n      return normalise(y, xc, ye);\r\n    };\r\n\r\n\r\n    /*\r\n     * If sd is undefined or null or true or false, return the number of significant digits of\r\n     * the value of this BigNumber, or null if the value of this BigNumber is ±Infinity or NaN.\r\n     * If sd is true include integer-part trailing zeros in the count.\r\n     *\r\n     * Otherwise, if sd is a number, return a new BigNumber whose value is the value of this\r\n     * BigNumber rounded to a maximum of sd significant digits using rounding mode rm, or\r\n     * ROUNDING_MODE if rm is omitted.\r\n     *\r\n     * sd {number|boolean} number: significant digits: integer, 1 to MAX inclusive.\r\n     *                     boolean: whether to count integer-part trailing zeros: true or false.\r\n     * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n     *\r\n     * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {sd|rm}'\r\n     */\r\n    P.precision = P.sd = function (sd, rm) {\r\n      var c, n, v,\r\n        x = this;\r\n\r\n      if (sd != null && sd !== !!sd) {\r\n        intCheck(sd, 1, MAX);\r\n        if (rm == null) rm = ROUNDING_MODE;\r\n        else intCheck(rm, 0, 8);\r\n\r\n        return round(new BigNumber(x), sd, rm);\r\n      }\r\n\r\n      if (!(c = x.c)) return null;\r\n      v = c.length - 1;\r\n      n = v * LOG_BASE + 1;\r\n\r\n      if (v = c[v]) {\r\n\r\n        // Subtract the number of trailing zeros of the last element.\r\n        for (; v % 10 == 0; v /= 10, n--);\r\n\r\n        // Add the number of digits of the first element.\r\n        for (v = c[0]; v >= 10; v /= 10, n++);\r\n      }\r\n\r\n      if (sd && x.e + 1 > n) n = x.e + 1;\r\n\r\n      return n;\r\n    };\r\n\r\n\r\n    /*\r\n     * Return a new BigNumber whose value is the value of this BigNumber shifted by k places\r\n     * (powers of 10). Shift to the right if n > 0, and to the left if n < 0.\r\n     *\r\n     * k {number} Integer, -MAX_SAFE_INTEGER to MAX_SAFE_INTEGER inclusive.\r\n     *\r\n     * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {k}'\r\n     */\r\n    P.shiftedBy = function (k) {\r\n      intCheck(k, -MAX_SAFE_INTEGER, MAX_SAFE_INTEGER);\r\n      return this.times('1e' + k);\r\n    };\r\n\r\n\r\n    /*\r\n     *  sqrt(-n) =  N\r\n     *  sqrt(N) =  N\r\n     *  sqrt(-I) =  N\r\n     *  sqrt(I) =  I\r\n     *  sqrt(0) =  0\r\n     *  sqrt(-0) = -0\r\n     *\r\n     * Return a new BigNumber whose value is the square root of the value of this BigNumber,\r\n     * rounded according to DECIMAL_PLACES and ROUNDING_MODE.\r\n     */\r\n    P.squareRoot = P.sqrt = function () {\r\n      var m, n, r, rep, t,\r\n        x = this,\r\n        c = x.c,\r\n        s = x.s,\r\n        e = x.e,\r\n        dp = DECIMAL_PLACES + 4,\r\n        half = new BigNumber('0.5');\r\n\r\n      // Negative/NaN/Infinity/zero?\r\n      if (s !== 1 || !c || !c[0]) {\r\n        return new BigNumber(!s || s < 0 && (!c || c[0]) ? NaN : c ? x : 1 / 0);\r\n      }\r\n\r\n      // Initial estimate.\r\n      s = Math.sqrt(+valueOf(x));\r\n\r\n      // Math.sqrt underflow/overflow?\r\n      // Pass x to Math.sqrt as integer, then adjust the exponent of the result.\r\n      if (s == 0 || s == 1 / 0) {\r\n        n = coeffToString(c);\r\n        if ((n.length + e) % 2 == 0) n += '0';\r\n        s = Math.sqrt(+n);\r\n        e = bitFloor((e + 1) / 2) - (e < 0 || e % 2);\r\n\r\n        if (s == 1 / 0) {\r\n          n = '1e' + e;\r\n        } else {\r\n          n = s.toExponential();\r\n          n = n.slice(0, n.indexOf('e') + 1) + e;\r\n        }\r\n\r\n        r = new BigNumber(n);\r\n      } else {\r\n        r = new BigNumber(s + '');\r\n      }\r\n\r\n      // Check for zero.\r\n      // r could be zero if MIN_EXP is changed after the this value was created.\r\n      // This would cause a division by zero (x/t) and hence Infinity below, which would cause\r\n      // coeffToString to throw.\r\n      if (r.c[0]) {\r\n        e = r.e;\r\n        s = e + dp;\r\n        if (s < 3) s = 0;\r\n\r\n        // Newton-Raphson iteration.\r\n        for (; ;) {\r\n          t = r;\r\n          r = half.times(t.plus(div(x, t, dp, 1)));\r\n\r\n          if (coeffToString(t.c).slice(0, s) === (n = coeffToString(r.c)).slice(0, s)) {\r\n\r\n            // The exponent of r may here be one less than the final result exponent,\r\n            // e.g 0.0009999 (e-4) --> 0.001 (e-3), so adjust s so the rounding digits\r\n            // are indexed correctly.\r\n            if (r.e < e) --s;\r\n            n = n.slice(s - 3, s + 1);\r\n\r\n            // The 4th rounding digit may be in error by -1 so if the 4 rounding digits\r\n            // are 9999 or 4999 (i.e. approaching a rounding boundary) continue the\r\n            // iteration.\r\n            if (n == '9999' || !rep && n == '4999') {\r\n\r\n              // On the first iteration only, check to see if rounding up gives the\r\n              // exact result as the nines may infinitely repeat.\r\n              if (!rep) {\r\n                round(t, t.e + DECIMAL_PLACES + 2, 0);\r\n\r\n                if (t.times(t).eq(x)) {\r\n                  r = t;\r\n                  break;\r\n                }\r\n              }\r\n\r\n              dp += 4;\r\n              s += 4;\r\n              rep = 1;\r\n            } else {\r\n\r\n              // If rounding digits are null, 0{0,4} or 50{0,3}, check for exact\r\n              // result. If not, then there are further digits and m will be truthy.\r\n              if (!+n || !+n.slice(1) && n.charAt(0) == '5') {\r\n\r\n                // Truncate to the first rounding digit.\r\n                round(r, r.e + DECIMAL_PLACES + 2, 1);\r\n                m = !r.times(r).eq(x);\r\n              }\r\n\r\n              break;\r\n            }\r\n          }\r\n        }\r\n      }\r\n\r\n      return round(r, r.e + DECIMAL_PLACES + 1, ROUNDING_MODE, m);\r\n    };\r\n\r\n\r\n    /*\r\n     * Return a string representing the value of this BigNumber in exponential notation and\r\n     * rounded using ROUNDING_MODE to dp fixed decimal places.\r\n     *\r\n     * [dp] {number} Decimal places. Integer, 0 to MAX inclusive.\r\n     * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n     *\r\n     * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {dp|rm}'\r\n     */\r\n    P.toExponential = function (dp, rm) {\r\n      if (dp != null) {\r\n        intCheck(dp, 0, MAX);\r\n        dp++;\r\n      }\r\n      return format(this, dp, rm, 1);\r\n    };\r\n\r\n\r\n    /*\r\n     * Return a string representing the value of this BigNumber in fixed-point notation rounding\r\n     * to dp fixed decimal places using rounding mode rm, or ROUNDING_MODE if rm is omitted.\r\n     *\r\n     * Note: as with JavaScript's number type, (-0).toFixed(0) is '0',\r\n     * but e.g. (-0.00001).toFixed(0) is '-0'.\r\n     *\r\n     * [dp] {number} Decimal places. Integer, 0 to MAX inclusive.\r\n     * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n     *\r\n     * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {dp|rm}'\r\n     */\r\n    P.toFixed = function (dp, rm) {\r\n      if (dp != null) {\r\n        intCheck(dp, 0, MAX);\r\n        dp = dp + this.e + 1;\r\n      }\r\n      return format(this, dp, rm);\r\n    };\r\n\r\n\r\n    /*\r\n     * Return a string representing the value of this BigNumber in fixed-point notation rounded\r\n     * using rm or ROUNDING_MODE to dp decimal places, and formatted according to the properties\r\n     * of the format or FORMAT object (see BigNumber.set).\r\n     *\r\n     * The formatting object may contain some or all of the properties shown below.\r\n     *\r\n     * FORMAT = {\r\n     *   prefix: '',\r\n     *   groupSize: 3,\r\n     *   secondaryGroupSize: 0,\r\n     *   groupSeparator: ',',\r\n     *   decimalSeparator: '.',\r\n     *   fractionGroupSize: 0,\r\n     *   fractionGroupSeparator: '\\xA0',      // non-breaking space\r\n     *   suffix: ''\r\n     * };\r\n     *\r\n     * [dp] {number} Decimal places. Integer, 0 to MAX inclusive.\r\n     * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n     * [format] {object} Formatting options. See FORMAT pbject above.\r\n     *\r\n     * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {dp|rm}'\r\n     * '[BigNumber Error] Argument not an object: {format}'\r\n     */\r\n    P.toFormat = function (dp, rm, format) {\r\n      var str,\r\n        x = this;\r\n\r\n      if (format == null) {\r\n        if (dp != null && rm && typeof rm == 'object') {\r\n          format = rm;\r\n          rm = null;\r\n        } else if (dp && typeof dp == 'object') {\r\n          format = dp;\r\n          dp = rm = null;\r\n        } else {\r\n          format = FORMAT;\r\n        }\r\n      } else if (typeof format != 'object') {\r\n        throw Error\r\n          (bignumberError + 'Argument not an object: ' + format);\r\n      }\r\n\r\n      str = x.toFixed(dp, rm);\r\n\r\n      if (x.c) {\r\n        var i,\r\n          arr = str.split('.'),\r\n          g1 = +format.groupSize,\r\n          g2 = +format.secondaryGroupSize,\r\n          groupSeparator = format.groupSeparator || '',\r\n          intPart = arr[0],\r\n          fractionPart = arr[1],\r\n          isNeg = x.s < 0,\r\n          intDigits = isNeg ? intPart.slice(1) : intPart,\r\n          len = intDigits.length;\r\n\r\n        if (g2) i = g1, g1 = g2, g2 = i, len -= i;\r\n\r\n        if (g1 > 0 && len > 0) {\r\n          i = len % g1 || g1;\r\n          intPart = intDigits.substr(0, i);\r\n          for (; i < len; i += g1) intPart += groupSeparator + intDigits.substr(i, g1);\r\n          if (g2 > 0) intPart += groupSeparator + intDigits.slice(i);\r\n          if (isNeg) intPart = '-' + intPart;\r\n        }\r\n\r\n        str = fractionPart\r\n         ? intPart + (format.decimalSeparator || '') + ((g2 = +format.fractionGroupSize)\r\n          ? fractionPart.replace(new RegExp('\\\\d{' + g2 + '}\\\\B', 'g'),\r\n           '$&' + (format.fractionGroupSeparator || ''))\r\n          : fractionPart)\r\n         : intPart;\r\n      }\r\n\r\n      return (format.prefix || '') + str + (format.suffix || '');\r\n    };\r\n\r\n\r\n    /*\r\n     * Return an array of two BigNumbers representing the value of this BigNumber as a simple\r\n     * fraction with an integer numerator and an integer denominator.\r\n     * The denominator will be a positive non-zero value less than or equal to the specified\r\n     * maximum denominator. If a maximum denominator is not specified, the denominator will be\r\n     * the lowest value necessary to represent the number exactly.\r\n     *\r\n     * [md] {number|string|BigNumber} Integer >= 1, or Infinity. The maximum denominator.\r\n     *\r\n     * '[BigNumber Error] Argument {not an integer|out of range} : {md}'\r\n     */\r\n    P.toFraction = function (md) {\r\n      var d, d0, d1, d2, e, exp, n, n0, n1, q, r, s,\r\n        x = this,\r\n        xc = x.c;\r\n\r\n      if (md != null) {\r\n        n = new BigNumber(md);\r\n\r\n        // Throw if md is less than one or is not an integer, unless it is Infinity.\r\n        if (!n.isInteger() && (n.c || n.s !== 1) || n.lt(ONE)) {\r\n          throw Error\r\n            (bignumberError + 'Argument ' +\r\n              (n.isInteger() ? 'out of range: ' : 'not an integer: ') + valueOf(n));\r\n        }\r\n      }\r\n\r\n      if (!xc) return new BigNumber(x);\r\n\r\n      d = new BigNumber(ONE);\r\n      n1 = d0 = new BigNumber(ONE);\r\n      d1 = n0 = new BigNumber(ONE);\r\n      s = coeffToString(xc);\r\n\r\n      // Determine initial denominator.\r\n      // d is a power of 10 and the minimum max denominator that specifies the value exactly.\r\n      e = d.e = s.length - x.e - 1;\r\n      d.c[0] = POWS_TEN[(exp = e % LOG_BASE) < 0 ? LOG_BASE + exp : exp];\r\n      md = !md || n.comparedTo(d) > 0 ? (e > 0 ? d : n1) : n;\r\n\r\n      exp = MAX_EXP;\r\n      MAX_EXP = 1 / 0;\r\n      n = new BigNumber(s);\r\n\r\n      // n0 = d1 = 0\r\n      n0.c[0] = 0;\r\n\r\n      for (; ;)  {\r\n        q = div(n, d, 0, 1);\r\n        d2 = d0.plus(q.times(d1));\r\n        if (d2.comparedTo(md) == 1) break;\r\n        d0 = d1;\r\n        d1 = d2;\r\n        n1 = n0.plus(q.times(d2 = n1));\r\n        n0 = d2;\r\n        d = n.minus(q.times(d2 = d));\r\n        n = d2;\r\n      }\r\n\r\n      d2 = div(md.minus(d0), d1, 0, 1);\r\n      n0 = n0.plus(d2.times(n1));\r\n      d0 = d0.plus(d2.times(d1));\r\n      n0.s = n1.s = x.s;\r\n      e = e * 2;\r\n\r\n      // Determine which fraction is closer to x, n0/d0 or n1/d1\r\n      r = div(n1, d1, e, ROUNDING_MODE).minus(x).abs().comparedTo(\r\n          div(n0, d0, e, ROUNDING_MODE).minus(x).abs()) < 1 ? [n1, d1] : [n0, d0];\r\n\r\n      MAX_EXP = exp;\r\n\r\n      return r;\r\n    };\r\n\r\n\r\n    /*\r\n     * Return the value of this BigNumber converted to a number primitive.\r\n     */\r\n    P.toNumber = function () {\r\n      return +valueOf(this);\r\n    };\r\n\r\n\r\n    /*\r\n     * Return a string representing the value of this BigNumber rounded to sd significant digits\r\n     * using rounding mode rm or ROUNDING_MODE. If sd is less than the number of digits\r\n     * necessary to represent the integer part of the value in fixed-point notation, then use\r\n     * exponential notation.\r\n     *\r\n     * [sd] {number} Significant digits. Integer, 1 to MAX inclusive.\r\n     * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n     *\r\n     * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {sd|rm}'\r\n     */\r\n    P.toPrecision = function (sd, rm) {\r\n      if (sd != null) intCheck(sd, 1, MAX);\r\n      return format(this, sd, rm, 2);\r\n    };\r\n\r\n\r\n    /*\r\n     * Return a string representing the value of this BigNumber in base b, or base 10 if b is\r\n     * omitted. If a base is specified, including base 10, round according to DECIMAL_PLACES and\r\n     * ROUNDING_MODE. If a base is not specified, and this BigNumber has a positive exponent\r\n     * that is equal to or greater than TO_EXP_POS, or a negative exponent equal to or less than\r\n     * TO_EXP_NEG, return exponential notation.\r\n     *\r\n     * [b] {number} Integer, 2 to ALPHABET.length inclusive.\r\n     *\r\n     * '[BigNumber Error] Base {not a primitive number|not an integer|out of range}: {b}'\r\n     */\r\n    P.toString = function (b) {\r\n      var str,\r\n        n = this,\r\n        s = n.s,\r\n        e = n.e;\r\n\r\n      // Infinity or NaN?\r\n      if (e === null) {\r\n        if (s) {\r\n          str = 'Infinity';\r\n          if (s < 0) str = '-' + str;\r\n        } else {\r\n          str = 'NaN';\r\n        }\r\n      } else {\r\n        if (b == null) {\r\n          str = e <= TO_EXP_NEG || e >= TO_EXP_POS\r\n           ? toExponential(coeffToString(n.c), e)\r\n           : toFixedPoint(coeffToString(n.c), e, '0');\r\n        } else if (b === 10) {\r\n          n = round(new BigNumber(n), DECIMAL_PLACES + e + 1, ROUNDING_MODE);\r\n          str = toFixedPoint(coeffToString(n.c), n.e, '0');\r\n        } else {\r\n          intCheck(b, 2, ALPHABET.length, 'Base');\r\n          str = convertBase(toFixedPoint(coeffToString(n.c), e, '0'), 10, b, s, true);\r\n        }\r\n\r\n        if (s < 0 && n.c[0]) str = '-' + str;\r\n      }\r\n\r\n      return str;\r\n    };\r\n\r\n\r\n    /*\r\n     * Return as toString, but do not accept a base argument, and include the minus sign for\r\n     * negative zero.\r\n     */\r\n    P.valueOf = P.toJSON = function () {\r\n      return valueOf(this);\r\n    };\r\n\r\n\r\n    P._isBigNumber = true;\r\n\r\n    if (hasSymbol) {\r\n      P[Symbol.toStringTag] = 'BigNumber';\r\n\r\n      // Node.js v10.12.0+\r\n      P[Symbol.for('nodejs.util.inspect.custom')] = P.valueOf;\r\n    }\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\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 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 = 0 }) {\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 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","/*!\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.3.6\";\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","/*!\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 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"]}