{"version":3,"sources":["webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/_object-keys-internal.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/_hide.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/_dom-create.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/_object-assign.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/es6.array.from.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/_to-object.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/_enum-keys.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/es6.string.iterator.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/_descriptors.js","webpack:///./node_modules/babel-runtime/helpers/typeof.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/_property-desc.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/_a-function.js","webpack:///./node_modules/babel-runtime/core-js/get-iterator.js","webpack:///./node_modules/babel-runtime/core-js/symbol/iterator.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/_object-gopn-ext.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/_object-pie.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/_string-at.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/_object-dp.js","webpack:///./node_modules/base64-js/index.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/core.get-iterator-method.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/_iter-create.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/_add-to-unscopables.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/es7.symbol.async-iterator.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/_to-primitive.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/fn/object/define-property.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/_iter-define.js","webpack:///./node_modules/bn.js/lib/bn.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/_array-includes.js","webpack:///./node_modules/babel-runtime/core-js/object/assign.js","webpack:///./node_modules/babel-runtime/helpers/extends.js","webpack:///./node_modules/base-x/src/index.js","webpack:///./node_modules/babel-runtime/core-js/object/define-property.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/_create-property.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/_fails.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/_object-gopd.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/_cof.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/es7.symbol.observable.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/_is-array.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/fn/symbol/iterator.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/_export.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/_core.js","webpack:///./node_modules/babel-runtime/helpers/createClass.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/_shared-key.js","webpack:///./node_modules/babel-runtime/helpers/defineProperty.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/_object-gopn.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/web.dom.iterable.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/es6.array.iterator.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/es6.symbol.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/_classof.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/_to-iobject.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/_is-array-iter.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/_object-create.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/_an-object.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/_is-object.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/fn/is-iterable.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/fn/get-iterator.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/fn/symbol/index.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/_object-dps.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/_iter-detect.js","webpack:///./node_modules/babel-runtime/helpers/classCallCheck.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/_iterators.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/core.is-iterable.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/_uid.js","webpack:///./node_modules/babel-runtime/helpers/objectWithoutProperties.js","webpack:///./node_modules/bignumber.js/bignumber.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/_html.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/_set-to-string-tag.js","webpack:///./node_modules/babel-helper-vue-jsx-merge-props/index.js","webpack:///./node_modules/babel-runtime/core-js/is-iterable.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/_enum-bug-keys.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/_object-keys.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/fn/array/from.js","webpack:///./node_modules/babel-runtime/helpers/toConsumableArray.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/_ctx.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/_has.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/_to-absolute-index.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/_iobject.js","webpack:///./node_modules/babel-runtime/core-js/array/from.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/core.get-iterator.js","webpack:///./node_modules/babel-runtime/helpers/slicedToArray.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/_shared.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/fn/object/assign.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/_redefine.js","webpack:///./node_modules/bech32/index.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/es6.object.define-property.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/_iter-call.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/_defined.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/_wks.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/_object-gpo.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/_to-length.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/_wks-define.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/_meta.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/_library.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/es6.object.assign.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/_iter-step.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/_global.js","webpack:///./node_modules/babel-runtime/core-js/symbol.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/_ie8-dom-define.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/_to-integer.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/_wks-ext.js","webpack:///./node_modules/babel-runtime/node_modules/core-js/library/modules/_object-gops.js"],"names":["has","toIObject","arrayIndexOf","IE_PROTO","module","exports","object","names","key","O","i","result","push","length","dP","createDesc","value","f","isObject","document","is","createElement","it","DESCRIPTORS","getKeys","gOPS","pIE","toObject","IObject","$assign","Object","assign","A","B","S","Symbol","K","split","forEach","k","keys","join","target","source","T","aLen","arguments","index","getSymbols","isEnum","concat","j","call","ctx","$export","isArrayIter","toLength","createProperty","getIterFn","F","iter","Array","from","arrayLike","step","iterator","C","this","mapfn","mapping","iterFn","next","done","defined","symbols","$at","String","iterated","_t","_i","point","defineProperty","get","a","__esModule","_iterator2","_interopRequireDefault","_symbol2","_typeof","default","obj","constructor","prototype","bitmap","enumerable","configurable","writable","TypeError","gOPN","toString","windowNames","window","getOwnPropertyNames","e","slice","getWindowNames","propertyIsEnumerable","toInteger","TO_STRING","that","pos","b","s","l","charCodeAt","charAt","anObject","IE8_DOM_DEFINE","toPrimitive","P","Attributes","byteLength","b64","lens","getLens","validLen","placeHoldersLen","toByteArray","tmp","arr","Arr","_byteLength","curByte","len","revLookup","fromByteArray","uint8","extraBytes","parts","maxChunkLength","len2","encodeChunk","lookup","Uint8Array","code","Error","indexOf","tripletToBase64","num","start","end","output","classof","ITERATOR","Iterators","getIteratorMethod","create","descriptor","setToStringTag","IteratorPrototype","Constructor","NAME","fn","val","valueOf","$Object","desc","LIBRARY","redefine","hide","$iterCreate","getPrototypeOf","BUGGY","KEYS","VALUES","returnThis","Base","DEFAULT","IS_SET","FORCED","methods","getMethod","kind","proto","TAG","DEF_VALUES","VALUES_BUG","$native","$default","$entries","$anyNative","entries","name","values","assert","msg","inherits","ctor","superCtor","super_","TempCtor","BN","number","base","endian","isBN","negative","words","red","_init","Buffer","wordSize","parseHex4Bits","string","c","parseHexByte","lowerBound","r","parseBase","str","mul","Math","min","isArray","max","left","right","cmp","_initNumber","_initArray","replace","_parseHex","_parseBase","toArray","ceil","w","off","strip","limbLen","limbPow","total","mod","word","imuln","_iaddn","pow","copy","dest","clone","_expand","size","_normSign","inspect","zeros","groupSizes","groupBases","smallMulTo","self","out","lo","carry","ncarry","rword","maxJ","padding","groupSize","groupBase","isZero","modn","idivn","toNumber","ret","toJSON","toBuffer","toArrayLike","ArrayType","reqLength","littleEndian","res","q","andln","iushrn","clz32","_countBits","t","_zeroBits","bitLength","hi","zeroBits","toTwos","width","abs","inotn","iaddn","fromTwos","testn","notn","ineg","isNeg","neg","iuor","ior","or","uor","iuand","iand","and","uand","iuxor","ixor","xor","uxor","bytesNeeded","bitsLeft","setn","bit","wbit","iadd","isub","add","sub","comb10MulTo","mid","o","a0","al0","ah0","a1","al1","ah1","a2","al2","ah2","a3","al3","ah3","a4","al4","ah4","a5","al5","ah5","a6","al6","ah6","a7","al7","ah7","a8","al8","ah8","a9","al9","ah9","b0","bl0","bh0","b1","bl1","bh1","b2","bl2","bh2","b3","bl3","bh3","b4","bl4","bh4","b5","bl5","bh5","b6","bl6","bh6","b7","bl7","bh7","b8","bl8","bh8","b9","bl9","bh9","w0","imul","w1","w2","w3","w4","w5","w6","w7","w8","w9","w10","w11","w12","w13","w14","w15","w16","w17","w18","jumboMulTo","FFTM","mulp","x","y","mulTo","hncarry","bigMulTo","makeRBT","N","revBin","rb","permute","rbt","rws","iws","rtws","itws","transform","rtwdf","cos","PI","itwdf","sin","p","rtwdf_","itwdf_","re","ie","ro","io","rx","guessLen13b","n","m","odd","conjugate","normalize13b","ws","round","convert13b","stub","ph","_","rwst","iwst","nrws","nrwst","niwst","rmws","mulf","muln","sqr","isqr","toBitArray","iushln","bits","carryMask","newCarry","ishln","hint","extended","h","mask","maskedWords","ishrn","shln","ushln","shrn","ushrn","imaskn","maskn","isubn","addn","subn","iabs","_ishlnsubmul","shift","_wordDiv","mode","bhi","diff","qj","div","divmod","positive","divn","umod","divRound","dm","half","r2","acc","egcd","D","g","isEven","yp","xp","im","isOdd","jm","gcd","_invmp","x1","x2","delta","cmpn","invm","bincn","ucmp","gtn","gt","gten","gte","ltn","lt","lten","lte","eqn","eq","Red","toRed","convertTo","_forceRed","fromRed","convertFrom","forceRed","redAdd","redIAdd","redSub","redISub","redShl","shl","redMul","_verify2","redIMul","redSqr","_verify1","redISqr","redSqrt","sqrt","redInvm","redNeg","redPow","primes","k256","p224","p192","p25519","MPrime","_tmp","K256","P224","P192","P25519","prime","_prime","Mont","imod","rinv","minv","ireduce","rlen","imulK","_strip","input","outLen","prev","mod3","one","nOne","lpow","z","inv","wnd","current","currentLen","mont","u","toAbsoluteIndex","IS_INCLUDES","$this","el","fromIndex","_assign2","hasOwnProperty","_Buffer","ALPHABET","BASE_MAP","xc","BASE","LEADER","FACTOR","log","iFACTOR","decodeUnsafe","alloc","psz","zeroes","b256","it3","it4","vch","allocUnsafe","fill","encode","isBuffer","pbegin","pend","b58","it1","it2","repeat","decode","buffer","$defineProperty","exec","gOPD","getOwnPropertyDescriptor","cof","arg","global","core","PROTOTYPE","type","own","IS_FORCED","IS_GLOBAL","G","IS_STATIC","IS_PROTO","IS_BIND","IS_WRAP","W","expProto","apply","Function","virtual","R","U","version","__e","_defineProperty2","defineProperties","props","protoProps","staticProps","shared","uid","$keys","hiddenKeys","TO_STRING_TAG","DOMIterables","Collection","addToUnscopables","_k","Arguments","META","KEY","$fails","wks","wksExt","wksDefine","enumKeys","_create","gOPNExt","$GOPD","$GOPS","$DP","$Symbol","$JSON","JSON","_stringify","stringify","HIDDEN","TO_PRIMITIVE","SymbolRegistry","AllSymbols","OPSymbols","ObjectProto","USE_NATIVE","QObject","setter","findChild","setSymbolDesc","protoDesc","wrap","tag","sym","isSymbol","$defineProperties","$propertyIsEnumerable","E","$getOwnPropertyDescriptor","$getOwnPropertyNames","$getOwnPropertySymbols","IS_OP","$set","set","es6Symbols","wellKnownSymbols","store","keyFor","useSetter","useSimple","getOwnPropertySymbols","FAILS_ON_PRIMITIVES","replacer","$replacer","args","ARG","tryGet","callee","ArrayProto","dPs","enumBugKeys","Empty","createDict","iframeDocument","iframe","style","display","appendChild","src","contentWindow","open","write","close","Properties","SAFE_CLOSING","riter","skipClosing","safe","instance","isIterable","id","px","random","globalObject","BigNumber","isNumeric","mathceil","mathfloor","floor","bignumberError","tooManyDigits","LOG_BASE","MAX_SAFE_INTEGER","POWS_TEN","SQRT_BASE","MAX","bitFloor","coeffToString","compare","yc","intCheck","toExponential","toFixedPoint","zs","configObject","convertBase","parseNumeric","ONE","DECIMAL_PLACES","ROUNDING_MODE","TO_EXP_NEG","TO_EXP_POS","MIN_EXP","MAX_EXP","CRYPTO","MODULO_MODE","POW_PRECISION","FORMAT","prefix","secondaryGroupSize","groupSeparator","decimalSeparator","fractionGroupSize","fractionGroupSeparator","suffix","alphabetHasNormalDecimalDigits","v","alphabet","caseChanged","isNum","_isBigNumber","test","search","substring","DEBUG","toUpperCase","toLowerCase","format","rm","c0","ne","maxOrMin","method","normalise","pop","sd","d","ni","rd","pows10","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","crypto","getRandomValues","randomBytes","EXPONENTIAL_AT","RANGE","isBigNumber","maximum","minimum","pow2_53","random53bitInt","dp","rand","Uint32Array","splice","sum","plus","decimal","toBaseOut","baseIn","baseOut","arrL","reverse","sign","callerIsToString","multiply","temp","xlo","xhi","klo","khi","aL","bL","subtract","more","prod","prodL","qc","rem","remL","rem0","xi","xL","yc0","yL","yz","NaN","basePrefix","dotAfter","dotBefore","isInfinityOrNaN","whitespaceOrPlus","isNaN","p1","p2","absoluteValue","comparedTo","decimalPlaces","dividedBy","dividedToIntegerBy","idiv","exponentiatedBy","isModExp","nIsBig","nIsNeg","nIsOdd","isInteger","times","integerValue","isEqualTo","isFinite","isGreaterThan","isGreaterThanOrEqualTo","isLessThan","isLessThanOrEqualTo","isNegative","isPositive","minus","xLTy","xe","ye","modulo","multipliedBy","xcL","ycL","ylo","yhi","zc","sqrtBase","negated","precision","shiftedBy","squareRoot","rep","toFixed","toFormat","g1","g2","intPart","fractionPart","intDigits","substr","RegExp","toFraction","md","d0","d1","d2","exp","n0","n1","toPrecision","documentElement","def","stat","nestRE","mergeFn","objs","reduce","aa","bb","nestedKey","_from2","arr2","aFunction","getIterator","_isIterable3","_getIterator3","_arr","_n","_d","_e","_s","err","sliceIterator","SHARED","copyright","ALPHABET_MAP","polymodStep","pre","prefixChk","chk","__decode","LIMIT","lowered","uppered","lastIndexOf","wordChars","convert","data","inBits","outBits","pad","maxV","toWordsUnsafe","bytes","toWords","fromWordsUnsafe","fromWords","USE_SYMBOL","setDesc","isExtensible","FREEZE","preventExtensions","setMeta","meta","NEED","fastKey","getWeak","onFreeze","__g"],"mappings":"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","file":"js/chunk-vendors~62ab6885.a6505109.js","sourcesContent":["var has = require('./_has');\nvar toIObject = require('./_to-iobject');\nvar arrayIndexOf = require('./_array-includes')(false);\nvar IE_PROTO = require('./_shared-key')('IE_PROTO');\n\nmodule.exports = function (object, names) {\n  var O = toIObject(object);\n  var i = 0;\n  var result = [];\n  var key;\n  for (key in O) if (key != IE_PROTO) has(O, key) && result.push(key);\n  // Don't enum bug & hidden keys\n  while (names.length > i) if (has(O, key = names[i++])) {\n    ~arrayIndexOf(result, key) || result.push(key);\n  }\n  return result;\n};\n","var dP = require('./_object-dp');\nvar createDesc = require('./_property-desc');\nmodule.exports = require('./_descriptors') ? function (object, key, value) {\n  return dP.f(object, key, createDesc(1, value));\n} : function (object, key, value) {\n  object[key] = value;\n  return object;\n};\n","var isObject = require('./_is-object');\nvar document = require('./_global').document;\n// typeof document.createElement is 'object' in old IE\nvar is = isObject(document) && isObject(document.createElement);\nmodule.exports = function (it) {\n  return is ? document.createElement(it) : {};\n};\n","'use strict';\n// 19.1.2.1 Object.assign(target, source, ...)\nvar DESCRIPTORS = require('./_descriptors');\nvar getKeys = require('./_object-keys');\nvar gOPS = require('./_object-gops');\nvar pIE = require('./_object-pie');\nvar toObject = require('./_to-object');\nvar IObject = require('./_iobject');\nvar $assign = Object.assign;\n\n// should work with symbols and should have deterministic property order (V8 bug)\nmodule.exports = !$assign || require('./_fails')(function () {\n  var A = {};\n  var B = {};\n  // eslint-disable-next-line no-undef\n  var S = Symbol();\n  var K = 'abcdefghijklmnopqrst';\n  A[S] = 7;\n  K.split('').forEach(function (k) { B[k] = k; });\n  return $assign({}, A)[S] != 7 || Object.keys($assign({}, B)).join('') != K;\n}) ? function assign(target, source) { // eslint-disable-line no-unused-vars\n  var T = toObject(target);\n  var aLen = arguments.length;\n  var index = 1;\n  var getSymbols = gOPS.f;\n  var isEnum = pIE.f;\n  while (aLen > index) {\n    var S = IObject(arguments[index++]);\n    var keys = getSymbols ? getKeys(S).concat(getSymbols(S)) : getKeys(S);\n    var length = keys.length;\n    var j = 0;\n    var key;\n    while (length > j) {\n      key = keys[j++];\n      if (!DESCRIPTORS || isEnum.call(S, key)) T[key] = S[key];\n    }\n  } return T;\n} : $assign;\n","'use strict';\nvar ctx = require('./_ctx');\nvar $export = require('./_export');\nvar toObject = require('./_to-object');\nvar call = require('./_iter-call');\nvar isArrayIter = require('./_is-array-iter');\nvar toLength = require('./_to-length');\nvar createProperty = require('./_create-property');\nvar getIterFn = require('./core.get-iterator-method');\n\n$export($export.S + $export.F * !require('./_iter-detect')(function (iter) { Array.from(iter); }), 'Array', {\n  // 22.1.2.1 Array.from(arrayLike, mapfn = undefined, thisArg = undefined)\n  from: function from(arrayLike /* , mapfn = undefined, thisArg = undefined */) {\n    var O = toObject(arrayLike);\n    var C = typeof this == 'function' ? this : Array;\n    var aLen = arguments.length;\n    var mapfn = aLen > 1 ? arguments[1] : undefined;\n    var mapping = mapfn !== undefined;\n    var index = 0;\n    var iterFn = getIterFn(O);\n    var length, result, step, iterator;\n    if (mapping) mapfn = ctx(mapfn, aLen > 2 ? arguments[2] : undefined, 2);\n    // if object isn't iterable or it's array with default iterator - use simple case\n    if (iterFn != undefined && !(C == Array && isArrayIter(iterFn))) {\n      for (iterator = iterFn.call(O), result = new C(); !(step = iterator.next()).done; index++) {\n        createProperty(result, index, mapping ? call(iterator, mapfn, [step.value, index], true) : step.value);\n      }\n    } else {\n      length = toLength(O.length);\n      for (result = new C(length); length > index; index++) {\n        createProperty(result, index, mapping ? mapfn(O[index], index) : O[index]);\n      }\n    }\n    result.length = index;\n    return result;\n  }\n});\n","// 7.1.13 ToObject(argument)\nvar defined = require('./_defined');\nmodule.exports = function (it) {\n  return Object(defined(it));\n};\n","// all enumerable object keys, includes symbols\nvar getKeys = require('./_object-keys');\nvar gOPS = require('./_object-gops');\nvar pIE = require('./_object-pie');\nmodule.exports = function (it) {\n  var result = getKeys(it);\n  var getSymbols = gOPS.f;\n  if (getSymbols) {\n    var symbols = getSymbols(it);\n    var isEnum = pIE.f;\n    var i = 0;\n    var key;\n    while (symbols.length > i) if (isEnum.call(it, key = symbols[i++])) result.push(key);\n  } return result;\n};\n","'use strict';\nvar $at = require('./_string-at')(true);\n\n// 21.1.3.27 String.prototype[@@iterator]()\nrequire('./_iter-define')(String, 'String', function (iterated) {\n  this._t = String(iterated); // target\n  this._i = 0;                // next index\n// 21.1.5.2.1 %StringIteratorPrototype%.next()\n}, function () {\n  var O = this._t;\n  var index = this._i;\n  var point;\n  if (index >= O.length) return { value: undefined, done: true };\n  point = $at(O, index);\n  this._i += point.length;\n  return { value: point, done: false };\n});\n","// Thank's IE8 for his funny defineProperty\nmodule.exports = !require('./_fails')(function () {\n  return Object.defineProperty({}, 'a', { get: function () { return 7; } }).a != 7;\n});\n","\"use strict\";\n\nexports.__esModule = true;\n\nvar _iterator = require(\"../core-js/symbol/iterator\");\n\nvar _iterator2 = _interopRequireDefault(_iterator);\n\nvar _symbol = require(\"../core-js/symbol\");\n\nvar _symbol2 = _interopRequireDefault(_symbol);\n\nvar _typeof = typeof _symbol2.default === \"function\" && typeof _iterator2.default === \"symbol\" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof _symbol2.default === \"function\" && obj.constructor === _symbol2.default && obj !== _symbol2.default.prototype ? \"symbol\" : typeof obj; };\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nexports.default = typeof _symbol2.default === \"function\" && _typeof(_iterator2.default) === \"symbol\" ? function (obj) {\n  return typeof obj === \"undefined\" ? \"undefined\" : _typeof(obj);\n} : function (obj) {\n  return obj && typeof _symbol2.default === \"function\" && obj.constructor === _symbol2.default && obj !== _symbol2.default.prototype ? \"symbol\" : typeof obj === \"undefined\" ? \"undefined\" : _typeof(obj);\n};","module.exports = function (bitmap, value) {\n  return {\n    enumerable: !(bitmap & 1),\n    configurable: !(bitmap & 2),\n    writable: !(bitmap & 4),\n    value: value\n  };\n};\n","module.exports = function (it) {\n  if (typeof it != 'function') throw TypeError(it + ' is not a function!');\n  return it;\n};\n","module.exports = { \"default\": require(\"core-js/library/fn/get-iterator\"), __esModule: true };","module.exports = { \"default\": require(\"core-js/library/fn/symbol/iterator\"), __esModule: true };","// fallback for IE11 buggy Object.getOwnPropertyNames with iframe and window\nvar toIObject = require('./_to-iobject');\nvar gOPN = require('./_object-gopn').f;\nvar toString = {}.toString;\n\nvar windowNames = typeof window == 'object' && window && Object.getOwnPropertyNames\n  ? Object.getOwnPropertyNames(window) : [];\n\nvar getWindowNames = function (it) {\n  try {\n    return gOPN(it);\n  } catch (e) {\n    return windowNames.slice();\n  }\n};\n\nmodule.exports.f = function getOwnPropertyNames(it) {\n  return windowNames && toString.call(it) == '[object Window]' ? getWindowNames(it) : gOPN(toIObject(it));\n};\n","exports.f = {}.propertyIsEnumerable;\n","var toInteger = require('./_to-integer');\nvar defined = require('./_defined');\n// true  -> String#at\n// false -> String#codePointAt\nmodule.exports = function (TO_STRING) {\n  return function (that, pos) {\n    var s = String(defined(that));\n    var i = toInteger(pos);\n    var l = s.length;\n    var a, b;\n    if (i < 0 || i >= l) return TO_STRING ? '' : undefined;\n    a = s.charCodeAt(i);\n    return a < 0xd800 || a > 0xdbff || i + 1 === l || (b = s.charCodeAt(i + 1)) < 0xdc00 || b > 0xdfff\n      ? TO_STRING ? s.charAt(i) : a\n      : TO_STRING ? s.slice(i, i + 2) : (a - 0xd800 << 10) + (b - 0xdc00) + 0x10000;\n  };\n};\n","var anObject = require('./_an-object');\nvar IE8_DOM_DEFINE = require('./_ie8-dom-define');\nvar toPrimitive = require('./_to-primitive');\nvar dP = Object.defineProperty;\n\nexports.f = require('./_descriptors') ? Object.defineProperty : function defineProperty(O, P, Attributes) {\n  anObject(O);\n  P = toPrimitive(P, true);\n  anObject(Attributes);\n  if (IE8_DOM_DEFINE) try {\n    return dP(O, P, Attributes);\n  } catch (e) { /* empty */ }\n  if ('get' in Attributes || 'set' in Attributes) throw TypeError('Accessors not supported!');\n  if ('value' in Attributes) O[P] = Attributes.value;\n  return O;\n};\n","'use strict'\n\nexports.byteLength = byteLength\nexports.toByteArray = toByteArray\nexports.fromByteArray = fromByteArray\n\nvar lookup = []\nvar revLookup = []\nvar Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array\n\nvar code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'\nfor (var i = 0, len = code.length; i < len; ++i) {\n  lookup[i] = code[i]\n  revLookup[code.charCodeAt(i)] = i\n}\n\n// Support decoding URL-safe base64 strings, as Node.js does.\n// See: https://en.wikipedia.org/wiki/Base64#URL_applications\nrevLookup['-'.charCodeAt(0)] = 62\nrevLookup['_'.charCodeAt(0)] = 63\n\nfunction getLens (b64) {\n  var len = b64.length\n\n  if (len % 4 > 0) {\n    throw new Error('Invalid string. Length must be a multiple of 4')\n  }\n\n  // Trim off extra bytes after placeholder bytes are found\n  // See: https://github.com/beatgammit/base64-js/issues/42\n  var validLen = b64.indexOf('=')\n  if (validLen === -1) validLen = len\n\n  var placeHoldersLen = validLen === len\n    ? 0\n    : 4 - (validLen % 4)\n\n  return [validLen, placeHoldersLen]\n}\n\n// base64 is 4/3 + up to two characters of the original data\nfunction byteLength (b64) {\n  var lens = getLens(b64)\n  var validLen = lens[0]\n  var placeHoldersLen = lens[1]\n  return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen\n}\n\nfunction _byteLength (b64, validLen, placeHoldersLen) {\n  return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen\n}\n\nfunction toByteArray (b64) {\n  var tmp\n  var lens = getLens(b64)\n  var validLen = lens[0]\n  var placeHoldersLen = lens[1]\n\n  var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen))\n\n  var curByte = 0\n\n  // if there are placeholders, only get up to the last complete 4 chars\n  var len = placeHoldersLen > 0\n    ? validLen - 4\n    : validLen\n\n  var i\n  for (i = 0; i < len; i += 4) {\n    tmp =\n      (revLookup[b64.charCodeAt(i)] << 18) |\n      (revLookup[b64.charCodeAt(i + 1)] << 12) |\n      (revLookup[b64.charCodeAt(i + 2)] << 6) |\n      revLookup[b64.charCodeAt(i + 3)]\n    arr[curByte++] = (tmp >> 16) & 0xFF\n    arr[curByte++] = (tmp >> 8) & 0xFF\n    arr[curByte++] = tmp & 0xFF\n  }\n\n  if (placeHoldersLen === 2) {\n    tmp =\n      (revLookup[b64.charCodeAt(i)] << 2) |\n      (revLookup[b64.charCodeAt(i + 1)] >> 4)\n    arr[curByte++] = tmp & 0xFF\n  }\n\n  if (placeHoldersLen === 1) {\n    tmp =\n      (revLookup[b64.charCodeAt(i)] << 10) |\n      (revLookup[b64.charCodeAt(i + 1)] << 4) |\n      (revLookup[b64.charCodeAt(i + 2)] >> 2)\n    arr[curByte++] = (tmp >> 8) & 0xFF\n    arr[curByte++] = tmp & 0xFF\n  }\n\n  return arr\n}\n\nfunction tripletToBase64 (num) {\n  return lookup[num >> 18 & 0x3F] +\n    lookup[num >> 12 & 0x3F] +\n    lookup[num >> 6 & 0x3F] +\n    lookup[num & 0x3F]\n}\n\nfunction encodeChunk (uint8, start, end) {\n  var tmp\n  var output = []\n  for (var i = start; i < end; i += 3) {\n    tmp =\n      ((uint8[i] << 16) & 0xFF0000) +\n      ((uint8[i + 1] << 8) & 0xFF00) +\n      (uint8[i + 2] & 0xFF)\n    output.push(tripletToBase64(tmp))\n  }\n  return output.join('')\n}\n\nfunction fromByteArray (uint8) {\n  var tmp\n  var len = uint8.length\n  var extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes\n  var parts = []\n  var maxChunkLength = 16383 // must be multiple of 3\n\n  // go through the array every three bytes, we'll deal with trailing stuff later\n  for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {\n    parts.push(encodeChunk(uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)))\n  }\n\n  // pad the end with zeros, but make sure to not forget the extra bytes\n  if (extraBytes === 1) {\n    tmp = uint8[len - 1]\n    parts.push(\n      lookup[tmp >> 2] +\n      lookup[(tmp << 4) & 0x3F] +\n      '=='\n    )\n  } else if (extraBytes === 2) {\n    tmp = (uint8[len - 2] << 8) + uint8[len - 1]\n    parts.push(\n      lookup[tmp >> 10] +\n      lookup[(tmp >> 4) & 0x3F] +\n      lookup[(tmp << 2) & 0x3F] +\n      '='\n    )\n  }\n\n  return parts.join('')\n}\n","var classof = require('./_classof');\nvar ITERATOR = require('./_wks')('iterator');\nvar Iterators = require('./_iterators');\nmodule.exports = require('./_core').getIteratorMethod = function (it) {\n  if (it != undefined) return it[ITERATOR]\n    || it['@@iterator']\n    || Iterators[classof(it)];\n};\n","'use strict';\nvar create = require('./_object-create');\nvar descriptor = require('./_property-desc');\nvar setToStringTag = require('./_set-to-string-tag');\nvar IteratorPrototype = {};\n\n// 25.1.2.1.1 %IteratorPrototype%[@@iterator]()\nrequire('./_hide')(IteratorPrototype, require('./_wks')('iterator'), function () { return this; });\n\nmodule.exports = function (Constructor, NAME, next) {\n  Constructor.prototype = create(IteratorPrototype, { next: descriptor(1, next) });\n  setToStringTag(Constructor, NAME + ' Iterator');\n};\n","module.exports = function () { /* empty */ };\n","require('./_wks-define')('asyncIterator');\n","// 7.1.1 ToPrimitive(input [, PreferredType])\nvar isObject = require('./_is-object');\n// instead of the ES6 spec version, we didn't implement @@toPrimitive case\n// and the second argument - flag - preferred type is a string\nmodule.exports = function (it, S) {\n  if (!isObject(it)) return it;\n  var fn, val;\n  if (S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it))) return val;\n  if (typeof (fn = it.valueOf) == 'function' && !isObject(val = fn.call(it))) return val;\n  if (!S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it))) return val;\n  throw TypeError(\"Can't convert object to primitive value\");\n};\n","require('../../modules/es6.object.define-property');\nvar $Object = require('../../modules/_core').Object;\nmodule.exports = function defineProperty(it, key, desc) {\n  return $Object.defineProperty(it, key, desc);\n};\n","'use strict';\nvar LIBRARY = require('./_library');\nvar $export = require('./_export');\nvar redefine = require('./_redefine');\nvar hide = require('./_hide');\nvar Iterators = require('./_iterators');\nvar $iterCreate = require('./_iter-create');\nvar setToStringTag = require('./_set-to-string-tag');\nvar getPrototypeOf = require('./_object-gpo');\nvar ITERATOR = require('./_wks')('iterator');\nvar BUGGY = !([].keys && 'next' in [].keys()); // Safari has buggy iterators w/o `next`\nvar FF_ITERATOR = '@@iterator';\nvar KEYS = 'keys';\nvar VALUES = 'values';\n\nvar returnThis = function () { return this; };\n\nmodule.exports = function (Base, NAME, Constructor, next, DEFAULT, IS_SET, FORCED) {\n  $iterCreate(Constructor, NAME, next);\n  var getMethod = function (kind) {\n    if (!BUGGY && kind in proto) return proto[kind];\n    switch (kind) {\n      case KEYS: return function keys() { return new Constructor(this, kind); };\n      case VALUES: return function values() { return new Constructor(this, kind); };\n    } return function entries() { return new Constructor(this, kind); };\n  };\n  var TAG = NAME + ' Iterator';\n  var DEF_VALUES = DEFAULT == VALUES;\n  var VALUES_BUG = false;\n  var proto = Base.prototype;\n  var $native = proto[ITERATOR] || proto[FF_ITERATOR] || DEFAULT && proto[DEFAULT];\n  var $default = $native || getMethod(DEFAULT);\n  var $entries = DEFAULT ? !DEF_VALUES ? $default : getMethod('entries') : undefined;\n  var $anyNative = NAME == 'Array' ? proto.entries || $native : $native;\n  var methods, key, IteratorPrototype;\n  // Fix native\n  if ($anyNative) {\n    IteratorPrototype = getPrototypeOf($anyNative.call(new Base()));\n    if (IteratorPrototype !== Object.prototype && IteratorPrototype.next) {\n      // Set @@toStringTag to native iterators\n      setToStringTag(IteratorPrototype, TAG, true);\n      // fix for some old engines\n      if (!LIBRARY && typeof IteratorPrototype[ITERATOR] != 'function') hide(IteratorPrototype, ITERATOR, returnThis);\n    }\n  }\n  // fix Array#{values, @@iterator}.name in V8 / FF\n  if (DEF_VALUES && $native && $native.name !== VALUES) {\n    VALUES_BUG = true;\n    $default = function values() { return $native.call(this); };\n  }\n  // Define iterator\n  if ((!LIBRARY || FORCED) && (BUGGY || VALUES_BUG || !proto[ITERATOR])) {\n    hide(proto, ITERATOR, $default);\n  }\n  // Plug for library\n  Iterators[NAME] = $default;\n  Iterators[TAG] = returnThis;\n  if (DEFAULT) {\n    methods = {\n      values: DEF_VALUES ? $default : getMethod(VALUES),\n      keys: IS_SET ? $default : getMethod(KEYS),\n      entries: $entries\n    };\n    if (FORCED) for (key in methods) {\n      if (!(key in proto)) redefine(proto, key, methods[key]);\n    } else $export($export.P + $export.F * (BUGGY || VALUES_BUG), NAME, methods);\n  }\n  return methods;\n};\n","(function (module, exports) {\n  'use strict';\n\n  // Utils\n  function assert (val, msg) {\n    if (!val) throw new Error(msg || 'Assertion failed');\n  }\n\n  // Could use `inherits` module, but don't want to move from single file\n  // architecture yet.\n  function inherits (ctor, superCtor) {\n    ctor.super_ = superCtor;\n    var TempCtor = function () {};\n    TempCtor.prototype = superCtor.prototype;\n    ctor.prototype = new TempCtor();\n    ctor.prototype.constructor = ctor;\n  }\n\n  // BN\n\n  function BN (number, base, endian) {\n    if (BN.isBN(number)) {\n      return number;\n    }\n\n    this.negative = 0;\n    this.words = null;\n    this.length = 0;\n\n    // Reduction context\n    this.red = null;\n\n    if (number !== null) {\n      if (base === 'le' || base === 'be') {\n        endian = base;\n        base = 10;\n      }\n\n      this._init(number || 0, base || 10, endian || 'be');\n    }\n  }\n  if (typeof module === 'object') {\n    module.exports = BN;\n  } else {\n    exports.BN = BN;\n  }\n\n  BN.BN = BN;\n  BN.wordSize = 26;\n\n  var Buffer;\n  try {\n    if (typeof window !== 'undefined' && typeof window.Buffer !== 'undefined') {\n      Buffer = window.Buffer;\n    } else {\n      Buffer = require('buffer').Buffer;\n    }\n  } catch (e) {\n  }\n\n  BN.isBN = function isBN (num) {\n    if (num instanceof BN) {\n      return true;\n    }\n\n    return num !== null && typeof num === 'object' &&\n      num.constructor.wordSize === BN.wordSize && Array.isArray(num.words);\n  };\n\n  BN.max = function max (left, right) {\n    if (left.cmp(right) > 0) return left;\n    return right;\n  };\n\n  BN.min = function min (left, right) {\n    if (left.cmp(right) < 0) return left;\n    return right;\n  };\n\n  BN.prototype._init = function init (number, base, endian) {\n    if (typeof number === 'number') {\n      return this._initNumber(number, base, endian);\n    }\n\n    if (typeof number === 'object') {\n      return this._initArray(number, base, endian);\n    }\n\n    if (base === 'hex') {\n      base = 16;\n    }\n    assert(base === (base | 0) && base >= 2 && base <= 36);\n\n    number = number.toString().replace(/\\s+/g, '');\n    var start = 0;\n    if (number[0] === '-') {\n      start++;\n      this.negative = 1;\n    }\n\n    if (start < number.length) {\n      if (base === 16) {\n        this._parseHex(number, start, endian);\n      } else {\n        this._parseBase(number, base, start);\n        if (endian === 'le') {\n          this._initArray(this.toArray(), base, endian);\n        }\n      }\n    }\n  };\n\n  BN.prototype._initNumber = function _initNumber (number, base, endian) {\n    if (number < 0) {\n      this.negative = 1;\n      number = -number;\n    }\n    if (number < 0x4000000) {\n      this.words = [ number & 0x3ffffff ];\n      this.length = 1;\n    } else if (number < 0x10000000000000) {\n      this.words = [\n        number & 0x3ffffff,\n        (number / 0x4000000) & 0x3ffffff\n      ];\n      this.length = 2;\n    } else {\n      assert(number < 0x20000000000000); // 2 ^ 53 (unsafe)\n      this.words = [\n        number & 0x3ffffff,\n        (number / 0x4000000) & 0x3ffffff,\n        1\n      ];\n      this.length = 3;\n    }\n\n    if (endian !== 'le') return;\n\n    // Reverse the bytes\n    this._initArray(this.toArray(), base, endian);\n  };\n\n  BN.prototype._initArray = function _initArray (number, base, endian) {\n    // Perhaps a Uint8Array\n    assert(typeof number.length === 'number');\n    if (number.length <= 0) {\n      this.words = [ 0 ];\n      this.length = 1;\n      return this;\n    }\n\n    this.length = Math.ceil(number.length / 3);\n    this.words = new Array(this.length);\n    for (var i = 0; i < this.length; i++) {\n      this.words[i] = 0;\n    }\n\n    var j, w;\n    var off = 0;\n    if (endian === 'be') {\n      for (i = number.length - 1, j = 0; i >= 0; i -= 3) {\n        w = number[i] | (number[i - 1] << 8) | (number[i - 2] << 16);\n        this.words[j] |= (w << off) & 0x3ffffff;\n        this.words[j + 1] = (w >>> (26 - off)) & 0x3ffffff;\n        off += 24;\n        if (off >= 26) {\n          off -= 26;\n          j++;\n        }\n      }\n    } else if (endian === 'le') {\n      for (i = 0, j = 0; i < number.length; i += 3) {\n        w = number[i] | (number[i + 1] << 8) | (number[i + 2] << 16);\n        this.words[j] |= (w << off) & 0x3ffffff;\n        this.words[j + 1] = (w >>> (26 - off)) & 0x3ffffff;\n        off += 24;\n        if (off >= 26) {\n          off -= 26;\n          j++;\n        }\n      }\n    }\n    return this.strip();\n  };\n\n  function parseHex4Bits (string, index) {\n    var c = string.charCodeAt(index);\n    // 'A' - 'F'\n    if (c >= 65 && c <= 70) {\n      return c - 55;\n    // 'a' - 'f'\n    } else if (c >= 97 && c <= 102) {\n      return c - 87;\n    // '0' - '9'\n    } else {\n      return (c - 48) & 0xf;\n    }\n  }\n\n  function parseHexByte (string, lowerBound, index) {\n    var r = parseHex4Bits(string, index);\n    if (index - 1 >= lowerBound) {\n      r |= parseHex4Bits(string, index - 1) << 4;\n    }\n    return r;\n  }\n\n  BN.prototype._parseHex = function _parseHex (number, start, endian) {\n    // Create possibly bigger array to ensure that it fits the number\n    this.length = Math.ceil((number.length - start) / 6);\n    this.words = new Array(this.length);\n    for (var i = 0; i < this.length; i++) {\n      this.words[i] = 0;\n    }\n\n    // 24-bits chunks\n    var off = 0;\n    var j = 0;\n\n    var w;\n    if (endian === 'be') {\n      for (i = number.length - 1; i >= start; i -= 2) {\n        w = parseHexByte(number, start, i) << off;\n        this.words[j] |= w & 0x3ffffff;\n        if (off >= 18) {\n          off -= 18;\n          j += 1;\n          this.words[j] |= w >>> 26;\n        } else {\n          off += 8;\n        }\n      }\n    } else {\n      var parseLength = number.length - start;\n      for (i = parseLength % 2 === 0 ? start + 1 : start; i < number.length; i += 2) {\n        w = parseHexByte(number, start, i) << off;\n        this.words[j] |= w & 0x3ffffff;\n        if (off >= 18) {\n          off -= 18;\n          j += 1;\n          this.words[j] |= w >>> 26;\n        } else {\n          off += 8;\n        }\n      }\n    }\n\n    this.strip();\n  };\n\n  function parseBase (str, start, end, mul) {\n    var r = 0;\n    var len = Math.min(str.length, end);\n    for (var i = start; i < len; i++) {\n      var c = str.charCodeAt(i) - 48;\n\n      r *= mul;\n\n      // 'a'\n      if (c >= 49) {\n        r += c - 49 + 0xa;\n\n      // 'A'\n      } else if (c >= 17) {\n        r += c - 17 + 0xa;\n\n      // '0' - '9'\n      } else {\n        r += c;\n      }\n    }\n    return r;\n  }\n\n  BN.prototype._parseBase = function _parseBase (number, base, start) {\n    // Initialize as zero\n    this.words = [ 0 ];\n    this.length = 1;\n\n    // Find length of limb in base\n    for (var limbLen = 0, limbPow = 1; limbPow <= 0x3ffffff; limbPow *= base) {\n      limbLen++;\n    }\n    limbLen--;\n    limbPow = (limbPow / base) | 0;\n\n    var total = number.length - start;\n    var mod = total % limbLen;\n    var end = Math.min(total, total - mod) + start;\n\n    var word = 0;\n    for (var i = start; i < end; i += limbLen) {\n      word = parseBase(number, i, i + limbLen, base);\n\n      this.imuln(limbPow);\n      if (this.words[0] + word < 0x4000000) {\n        this.words[0] += word;\n      } else {\n        this._iaddn(word);\n      }\n    }\n\n    if (mod !== 0) {\n      var pow = 1;\n      word = parseBase(number, i, number.length, base);\n\n      for (i = 0; i < mod; i++) {\n        pow *= base;\n      }\n\n      this.imuln(pow);\n      if (this.words[0] + word < 0x4000000) {\n        this.words[0] += word;\n      } else {\n        this._iaddn(word);\n      }\n    }\n\n    this.strip();\n  };\n\n  BN.prototype.copy = function copy (dest) {\n    dest.words = new Array(this.length);\n    for (var i = 0; i < this.length; i++) {\n      dest.words[i] = this.words[i];\n    }\n    dest.length = this.length;\n    dest.negative = this.negative;\n    dest.red = this.red;\n  };\n\n  BN.prototype.clone = function clone () {\n    var r = new BN(null);\n    this.copy(r);\n    return r;\n  };\n\n  BN.prototype._expand = function _expand (size) {\n    while (this.length < size) {\n      this.words[this.length++] = 0;\n    }\n    return this;\n  };\n\n  // Remove leading `0` from `this`\n  BN.prototype.strip = function strip () {\n    while (this.length > 1 && this.words[this.length - 1] === 0) {\n      this.length--;\n    }\n    return this._normSign();\n  };\n\n  BN.prototype._normSign = function _normSign () {\n    // -0 = 0\n    if (this.length === 1 && this.words[0] === 0) {\n      this.negative = 0;\n    }\n    return this;\n  };\n\n  BN.prototype.inspect = function inspect () {\n    return (this.red ? '<BN-R: ' : '<BN: ') + this.toString(16) + '>';\n  };\n\n  /*\n\n  var zeros = [];\n  var groupSizes = [];\n  var groupBases = [];\n\n  var s = '';\n  var i = -1;\n  while (++i < BN.wordSize) {\n    zeros[i] = s;\n    s += '0';\n  }\n  groupSizes[0] = 0;\n  groupSizes[1] = 0;\n  groupBases[0] = 0;\n  groupBases[1] = 0;\n  var base = 2 - 1;\n  while (++base < 36 + 1) {\n    var groupSize = 0;\n    var groupBase = 1;\n    while (groupBase < (1 << BN.wordSize) / base) {\n      groupBase *= base;\n      groupSize += 1;\n    }\n    groupSizes[base] = groupSize;\n    groupBases[base] = groupBase;\n  }\n\n  */\n\n  var zeros = [\n    '',\n    '0',\n    '00',\n    '000',\n    '0000',\n    '00000',\n    '000000',\n    '0000000',\n    '00000000',\n    '000000000',\n    '0000000000',\n    '00000000000',\n    '000000000000',\n    '0000000000000',\n    '00000000000000',\n    '000000000000000',\n    '0000000000000000',\n    '00000000000000000',\n    '000000000000000000',\n    '0000000000000000000',\n    '00000000000000000000',\n    '000000000000000000000',\n    '0000000000000000000000',\n    '00000000000000000000000',\n    '000000000000000000000000',\n    '0000000000000000000000000'\n  ];\n\n  var groupSizes = [\n    0, 0,\n    25, 16, 12, 11, 10, 9, 8,\n    8, 7, 7, 7, 7, 6, 6,\n    6, 6, 6, 6, 6, 5, 5,\n    5, 5, 5, 5, 5, 5, 5,\n    5, 5, 5, 5, 5, 5, 5\n  ];\n\n  var groupBases = [\n    0, 0,\n    33554432, 43046721, 16777216, 48828125, 60466176, 40353607, 16777216,\n    43046721, 10000000, 19487171, 35831808, 62748517, 7529536, 11390625,\n    16777216, 24137569, 34012224, 47045881, 64000000, 4084101, 5153632,\n    6436343, 7962624, 9765625, 11881376, 14348907, 17210368, 20511149,\n    24300000, 28629151, 33554432, 39135393, 45435424, 52521875, 60466176\n  ];\n\n  BN.prototype.toString = function toString (base, padding) {\n    base = base || 10;\n    padding = padding | 0 || 1;\n\n    var out;\n    if (base === 16 || base === 'hex') {\n      out = '';\n      var off = 0;\n      var carry = 0;\n      for (var i = 0; i < this.length; i++) {\n        var w = this.words[i];\n        var word = (((w << off) | carry) & 0xffffff).toString(16);\n        carry = (w >>> (24 - off)) & 0xffffff;\n        if (carry !== 0 || i !== this.length - 1) {\n          out = zeros[6 - word.length] + word + out;\n        } else {\n          out = word + out;\n        }\n        off += 2;\n        if (off >= 26) {\n          off -= 26;\n          i--;\n        }\n      }\n      if (carry !== 0) {\n        out = carry.toString(16) + out;\n      }\n      while (out.length % padding !== 0) {\n        out = '0' + out;\n      }\n      if (this.negative !== 0) {\n        out = '-' + out;\n      }\n      return out;\n    }\n\n    if (base === (base | 0) && base >= 2 && base <= 36) {\n      // var groupSize = Math.floor(BN.wordSize * Math.LN2 / Math.log(base));\n      var groupSize = groupSizes[base];\n      // var groupBase = Math.pow(base, groupSize);\n      var groupBase = groupBases[base];\n      out = '';\n      var c = this.clone();\n      c.negative = 0;\n      while (!c.isZero()) {\n        var r = c.modn(groupBase).toString(base);\n        c = c.idivn(groupBase);\n\n        if (!c.isZero()) {\n          out = zeros[groupSize - r.length] + r + out;\n        } else {\n          out = r + out;\n        }\n      }\n      if (this.isZero()) {\n        out = '0' + out;\n      }\n      while (out.length % padding !== 0) {\n        out = '0' + out;\n      }\n      if (this.negative !== 0) {\n        out = '-' + out;\n      }\n      return out;\n    }\n\n    assert(false, 'Base should be between 2 and 36');\n  };\n\n  BN.prototype.toNumber = function toNumber () {\n    var ret = this.words[0];\n    if (this.length === 2) {\n      ret += this.words[1] * 0x4000000;\n    } else if (this.length === 3 && this.words[2] === 0x01) {\n      // NOTE: at this stage it is known that the top bit is set\n      ret += 0x10000000000000 + (this.words[1] * 0x4000000);\n    } else if (this.length > 2) {\n      assert(false, 'Number can only safely store up to 53 bits');\n    }\n    return (this.negative !== 0) ? -ret : ret;\n  };\n\n  BN.prototype.toJSON = function toJSON () {\n    return this.toString(16);\n  };\n\n  BN.prototype.toBuffer = function toBuffer (endian, length) {\n    assert(typeof Buffer !== 'undefined');\n    return this.toArrayLike(Buffer, endian, length);\n  };\n\n  BN.prototype.toArray = function toArray (endian, length) {\n    return this.toArrayLike(Array, endian, length);\n  };\n\n  BN.prototype.toArrayLike = function toArrayLike (ArrayType, endian, length) {\n    var byteLength = this.byteLength();\n    var reqLength = length || Math.max(1, byteLength);\n    assert(byteLength <= reqLength, 'byte array longer than desired length');\n    assert(reqLength > 0, 'Requested array length <= 0');\n\n    this.strip();\n    var littleEndian = endian === 'le';\n    var res = new ArrayType(reqLength);\n\n    var b, i;\n    var q = this.clone();\n    if (!littleEndian) {\n      // Assume big-endian\n      for (i = 0; i < reqLength - byteLength; i++) {\n        res[i] = 0;\n      }\n\n      for (i = 0; !q.isZero(); i++) {\n        b = q.andln(0xff);\n        q.iushrn(8);\n\n        res[reqLength - i - 1] = b;\n      }\n    } else {\n      for (i = 0; !q.isZero(); i++) {\n        b = q.andln(0xff);\n        q.iushrn(8);\n\n        res[i] = b;\n      }\n\n      for (; i < reqLength; i++) {\n        res[i] = 0;\n      }\n    }\n\n    return res;\n  };\n\n  if (Math.clz32) {\n    BN.prototype._countBits = function _countBits (w) {\n      return 32 - Math.clz32(w);\n    };\n  } else {\n    BN.prototype._countBits = function _countBits (w) {\n      var t = w;\n      var r = 0;\n      if (t >= 0x1000) {\n        r += 13;\n        t >>>= 13;\n      }\n      if (t >= 0x40) {\n        r += 7;\n        t >>>= 7;\n      }\n      if (t >= 0x8) {\n        r += 4;\n        t >>>= 4;\n      }\n      if (t >= 0x02) {\n        r += 2;\n        t >>>= 2;\n      }\n      return r + t;\n    };\n  }\n\n  BN.prototype._zeroBits = function _zeroBits (w) {\n    // Short-cut\n    if (w === 0) return 26;\n\n    var t = w;\n    var r = 0;\n    if ((t & 0x1fff) === 0) {\n      r += 13;\n      t >>>= 13;\n    }\n    if ((t & 0x7f) === 0) {\n      r += 7;\n      t >>>= 7;\n    }\n    if ((t & 0xf) === 0) {\n      r += 4;\n      t >>>= 4;\n    }\n    if ((t & 0x3) === 0) {\n      r += 2;\n      t >>>= 2;\n    }\n    if ((t & 0x1) === 0) {\n      r++;\n    }\n    return r;\n  };\n\n  // Return number of used bits in a BN\n  BN.prototype.bitLength = function bitLength () {\n    var w = this.words[this.length - 1];\n    var hi = this._countBits(w);\n    return (this.length - 1) * 26 + hi;\n  };\n\n  function toBitArray (num) {\n    var w = new Array(num.bitLength());\n\n    for (var bit = 0; bit < w.length; bit++) {\n      var off = (bit / 26) | 0;\n      var wbit = bit % 26;\n\n      w[bit] = (num.words[off] & (1 << wbit)) >>> wbit;\n    }\n\n    return w;\n  }\n\n  // Number of trailing zero bits\n  BN.prototype.zeroBits = function zeroBits () {\n    if (this.isZero()) return 0;\n\n    var r = 0;\n    for (var i = 0; i < this.length; i++) {\n      var b = this._zeroBits(this.words[i]);\n      r += b;\n      if (b !== 26) break;\n    }\n    return r;\n  };\n\n  BN.prototype.byteLength = function byteLength () {\n    return Math.ceil(this.bitLength() / 8);\n  };\n\n  BN.prototype.toTwos = function toTwos (width) {\n    if (this.negative !== 0) {\n      return this.abs().inotn(width).iaddn(1);\n    }\n    return this.clone();\n  };\n\n  BN.prototype.fromTwos = function fromTwos (width) {\n    if (this.testn(width - 1)) {\n      return this.notn(width).iaddn(1).ineg();\n    }\n    return this.clone();\n  };\n\n  BN.prototype.isNeg = function isNeg () {\n    return this.negative !== 0;\n  };\n\n  // Return negative clone of `this`\n  BN.prototype.neg = function neg () {\n    return this.clone().ineg();\n  };\n\n  BN.prototype.ineg = function ineg () {\n    if (!this.isZero()) {\n      this.negative ^= 1;\n    }\n\n    return this;\n  };\n\n  // Or `num` with `this` in-place\n  BN.prototype.iuor = function iuor (num) {\n    while (this.length < num.length) {\n      this.words[this.length++] = 0;\n    }\n\n    for (var i = 0; i < num.length; i++) {\n      this.words[i] = this.words[i] | num.words[i];\n    }\n\n    return this.strip();\n  };\n\n  BN.prototype.ior = function ior (num) {\n    assert((this.negative | num.negative) === 0);\n    return this.iuor(num);\n  };\n\n  // Or `num` with `this`\n  BN.prototype.or = function or (num) {\n    if (this.length > num.length) return this.clone().ior(num);\n    return num.clone().ior(this);\n  };\n\n  BN.prototype.uor = function uor (num) {\n    if (this.length > num.length) return this.clone().iuor(num);\n    return num.clone().iuor(this);\n  };\n\n  // And `num` with `this` in-place\n  BN.prototype.iuand = function iuand (num) {\n    // b = min-length(num, this)\n    var b;\n    if (this.length > num.length) {\n      b = num;\n    } else {\n      b = this;\n    }\n\n    for (var i = 0; i < b.length; i++) {\n      this.words[i] = this.words[i] & num.words[i];\n    }\n\n    this.length = b.length;\n\n    return this.strip();\n  };\n\n  BN.prototype.iand = function iand (num) {\n    assert((this.negative | num.negative) === 0);\n    return this.iuand(num);\n  };\n\n  // And `num` with `this`\n  BN.prototype.and = function and (num) {\n    if (this.length > num.length) return this.clone().iand(num);\n    return num.clone().iand(this);\n  };\n\n  BN.prototype.uand = function uand (num) {\n    if (this.length > num.length) return this.clone().iuand(num);\n    return num.clone().iuand(this);\n  };\n\n  // Xor `num` with `this` in-place\n  BN.prototype.iuxor = function iuxor (num) {\n    // a.length > b.length\n    var a;\n    var b;\n    if (this.length > num.length) {\n      a = this;\n      b = num;\n    } else {\n      a = num;\n      b = this;\n    }\n\n    for (var i = 0; i < b.length; i++) {\n      this.words[i] = a.words[i] ^ b.words[i];\n    }\n\n    if (this !== a) {\n      for (; i < a.length; i++) {\n        this.words[i] = a.words[i];\n      }\n    }\n\n    this.length = a.length;\n\n    return this.strip();\n  };\n\n  BN.prototype.ixor = function ixor (num) {\n    assert((this.negative | num.negative) === 0);\n    return this.iuxor(num);\n  };\n\n  // Xor `num` with `this`\n  BN.prototype.xor = function xor (num) {\n    if (this.length > num.length) return this.clone().ixor(num);\n    return num.clone().ixor(this);\n  };\n\n  BN.prototype.uxor = function uxor (num) {\n    if (this.length > num.length) return this.clone().iuxor(num);\n    return num.clone().iuxor(this);\n  };\n\n  // Not ``this`` with ``width`` bitwidth\n  BN.prototype.inotn = function inotn (width) {\n    assert(typeof width === 'number' && width >= 0);\n\n    var bytesNeeded = Math.ceil(width / 26) | 0;\n    var bitsLeft = width % 26;\n\n    // Extend the buffer with leading zeroes\n    this._expand(bytesNeeded);\n\n    if (bitsLeft > 0) {\n      bytesNeeded--;\n    }\n\n    // Handle complete words\n    for (var i = 0; i < bytesNeeded; i++) {\n      this.words[i] = ~this.words[i] & 0x3ffffff;\n    }\n\n    // Handle the residue\n    if (bitsLeft > 0) {\n      this.words[i] = ~this.words[i] & (0x3ffffff >> (26 - bitsLeft));\n    }\n\n    // And remove leading zeroes\n    return this.strip();\n  };\n\n  BN.prototype.notn = function notn (width) {\n    return this.clone().inotn(width);\n  };\n\n  // Set `bit` of `this`\n  BN.prototype.setn = function setn (bit, val) {\n    assert(typeof bit === 'number' && bit >= 0);\n\n    var off = (bit / 26) | 0;\n    var wbit = bit % 26;\n\n    this._expand(off + 1);\n\n    if (val) {\n      this.words[off] = this.words[off] | (1 << wbit);\n    } else {\n      this.words[off] = this.words[off] & ~(1 << wbit);\n    }\n\n    return this.strip();\n  };\n\n  // Add `num` to `this` in-place\n  BN.prototype.iadd = function iadd (num) {\n    var r;\n\n    // negative + positive\n    if (this.negative !== 0 && num.negative === 0) {\n      this.negative = 0;\n      r = this.isub(num);\n      this.negative ^= 1;\n      return this._normSign();\n\n    // positive + negative\n    } else if (this.negative === 0 && num.negative !== 0) {\n      num.negative = 0;\n      r = this.isub(num);\n      num.negative = 1;\n      return r._normSign();\n    }\n\n    // a.length > b.length\n    var a, b;\n    if (this.length > num.length) {\n      a = this;\n      b = num;\n    } else {\n      a = num;\n      b = this;\n    }\n\n    var carry = 0;\n    for (var i = 0; i < b.length; i++) {\n      r = (a.words[i] | 0) + (b.words[i] | 0) + carry;\n      this.words[i] = r & 0x3ffffff;\n      carry = r >>> 26;\n    }\n    for (; carry !== 0 && i < a.length; i++) {\n      r = (a.words[i] | 0) + carry;\n      this.words[i] = r & 0x3ffffff;\n      carry = r >>> 26;\n    }\n\n    this.length = a.length;\n    if (carry !== 0) {\n      this.words[this.length] = carry;\n      this.length++;\n    // Copy the rest of the words\n    } else if (a !== this) {\n      for (; i < a.length; i++) {\n        this.words[i] = a.words[i];\n      }\n    }\n\n    return this;\n  };\n\n  // Add `num` to `this`\n  BN.prototype.add = function add (num) {\n    var res;\n    if (num.negative !== 0 && this.negative === 0) {\n      num.negative = 0;\n      res = this.sub(num);\n      num.negative ^= 1;\n      return res;\n    } else if (num.negative === 0 && this.negative !== 0) {\n      this.negative = 0;\n      res = num.sub(this);\n      this.negative = 1;\n      return res;\n    }\n\n    if (this.length > num.length) return this.clone().iadd(num);\n\n    return num.clone().iadd(this);\n  };\n\n  // Subtract `num` from `this` in-place\n  BN.prototype.isub = function isub (num) {\n    // this - (-num) = this + num\n    if (num.negative !== 0) {\n      num.negative = 0;\n      var r = this.iadd(num);\n      num.negative = 1;\n      return r._normSign();\n\n    // -this - num = -(this + num)\n    } else if (this.negative !== 0) {\n      this.negative = 0;\n      this.iadd(num);\n      this.negative = 1;\n      return this._normSign();\n    }\n\n    // At this point both numbers are positive\n    var cmp = this.cmp(num);\n\n    // Optimization - zeroify\n    if (cmp === 0) {\n      this.negative = 0;\n      this.length = 1;\n      this.words[0] = 0;\n      return this;\n    }\n\n    // a > b\n    var a, b;\n    if (cmp > 0) {\n      a = this;\n      b = num;\n    } else {\n      a = num;\n      b = this;\n    }\n\n    var carry = 0;\n    for (var i = 0; i < b.length; i++) {\n      r = (a.words[i] | 0) - (b.words[i] | 0) + carry;\n      carry = r >> 26;\n      this.words[i] = r & 0x3ffffff;\n    }\n    for (; carry !== 0 && i < a.length; i++) {\n      r = (a.words[i] | 0) + carry;\n      carry = r >> 26;\n      this.words[i] = r & 0x3ffffff;\n    }\n\n    // Copy rest of the words\n    if (carry === 0 && i < a.length && a !== this) {\n      for (; i < a.length; i++) {\n        this.words[i] = a.words[i];\n      }\n    }\n\n    this.length = Math.max(this.length, i);\n\n    if (a !== this) {\n      this.negative = 1;\n    }\n\n    return this.strip();\n  };\n\n  // Subtract `num` from `this`\n  BN.prototype.sub = function sub (num) {\n    return this.clone().isub(num);\n  };\n\n  function smallMulTo (self, num, out) {\n    out.negative = num.negative ^ self.negative;\n    var len = (self.length + num.length) | 0;\n    out.length = len;\n    len = (len - 1) | 0;\n\n    // Peel one iteration (compiler can't do it, because of code complexity)\n    var a = self.words[0] | 0;\n    var b = num.words[0] | 0;\n    var r = a * b;\n\n    var lo = r & 0x3ffffff;\n    var carry = (r / 0x4000000) | 0;\n    out.words[0] = lo;\n\n    for (var k = 1; k < len; k++) {\n      // Sum all words with the same `i + j = k` and accumulate `ncarry`,\n      // note that ncarry could be >= 0x3ffffff\n      var ncarry = carry >>> 26;\n      var rword = carry & 0x3ffffff;\n      var maxJ = Math.min(k, num.length - 1);\n      for (var j = Math.max(0, k - self.length + 1); j <= maxJ; j++) {\n        var i = (k - j) | 0;\n        a = self.words[i] | 0;\n        b = num.words[j] | 0;\n        r = a * b + rword;\n        ncarry += (r / 0x4000000) | 0;\n        rword = r & 0x3ffffff;\n      }\n      out.words[k] = rword | 0;\n      carry = ncarry | 0;\n    }\n    if (carry !== 0) {\n      out.words[k] = carry | 0;\n    } else {\n      out.length--;\n    }\n\n    return out.strip();\n  }\n\n  // TODO(indutny): it may be reasonable to omit it for users who don't need\n  // to work with 256-bit numbers, otherwise it gives 20% improvement for 256-bit\n  // multiplication (like elliptic secp256k1).\n  var comb10MulTo = function comb10MulTo (self, num, out) {\n    var a = self.words;\n    var b = num.words;\n    var o = out.words;\n    var c = 0;\n    var lo;\n    var mid;\n    var hi;\n    var a0 = a[0] | 0;\n    var al0 = a0 & 0x1fff;\n    var ah0 = a0 >>> 13;\n    var a1 = a[1] | 0;\n    var al1 = a1 & 0x1fff;\n    var ah1 = a1 >>> 13;\n    var a2 = a[2] | 0;\n    var al2 = a2 & 0x1fff;\n    var ah2 = a2 >>> 13;\n    var a3 = a[3] | 0;\n    var al3 = a3 & 0x1fff;\n    var ah3 = a3 >>> 13;\n    var a4 = a[4] | 0;\n    var al4 = a4 & 0x1fff;\n    var ah4 = a4 >>> 13;\n    var a5 = a[5] | 0;\n    var al5 = a5 & 0x1fff;\n    var ah5 = a5 >>> 13;\n    var a6 = a[6] | 0;\n    var al6 = a6 & 0x1fff;\n    var ah6 = a6 >>> 13;\n    var a7 = a[7] | 0;\n    var al7 = a7 & 0x1fff;\n    var ah7 = a7 >>> 13;\n    var a8 = a[8] | 0;\n    var al8 = a8 & 0x1fff;\n    var ah8 = a8 >>> 13;\n    var a9 = a[9] | 0;\n    var al9 = a9 & 0x1fff;\n    var ah9 = a9 >>> 13;\n    var b0 = b[0] | 0;\n    var bl0 = b0 & 0x1fff;\n    var bh0 = b0 >>> 13;\n    var b1 = b[1] | 0;\n    var bl1 = b1 & 0x1fff;\n    var bh1 = b1 >>> 13;\n    var b2 = b[2] | 0;\n    var bl2 = b2 & 0x1fff;\n    var bh2 = b2 >>> 13;\n    var b3 = b[3] | 0;\n    var bl3 = b3 & 0x1fff;\n    var bh3 = b3 >>> 13;\n    var b4 = b[4] | 0;\n    var bl4 = b4 & 0x1fff;\n    var bh4 = b4 >>> 13;\n    var b5 = b[5] | 0;\n    var bl5 = b5 & 0x1fff;\n    var bh5 = b5 >>> 13;\n    var b6 = b[6] | 0;\n    var bl6 = b6 & 0x1fff;\n    var bh6 = b6 >>> 13;\n    var b7 = b[7] | 0;\n    var bl7 = b7 & 0x1fff;\n    var bh7 = b7 >>> 13;\n    var b8 = b[8] | 0;\n    var bl8 = b8 & 0x1fff;\n    var bh8 = b8 >>> 13;\n    var b9 = b[9] | 0;\n    var bl9 = b9 & 0x1fff;\n    var bh9 = b9 >>> 13;\n\n    out.negative = self.negative ^ num.negative;\n    out.length = 19;\n    /* k = 0 */\n    lo = Math.imul(al0, bl0);\n    mid = Math.imul(al0, bh0);\n    mid = (mid + Math.imul(ah0, bl0)) | 0;\n    hi = Math.imul(ah0, bh0);\n    var w0 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n    c = (((hi + (mid >>> 13)) | 0) + (w0 >>> 26)) | 0;\n    w0 &= 0x3ffffff;\n    /* k = 1 */\n    lo = Math.imul(al1, bl0);\n    mid = Math.imul(al1, bh0);\n    mid = (mid + Math.imul(ah1, bl0)) | 0;\n    hi = Math.imul(ah1, bh0);\n    lo = (lo + Math.imul(al0, bl1)) | 0;\n    mid = (mid + Math.imul(al0, bh1)) | 0;\n    mid = (mid + Math.imul(ah0, bl1)) | 0;\n    hi = (hi + Math.imul(ah0, bh1)) | 0;\n    var w1 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n    c = (((hi + (mid >>> 13)) | 0) + (w1 >>> 26)) | 0;\n    w1 &= 0x3ffffff;\n    /* k = 2 */\n    lo = Math.imul(al2, bl0);\n    mid = Math.imul(al2, bh0);\n    mid = (mid + Math.imul(ah2, bl0)) | 0;\n    hi = Math.imul(ah2, bh0);\n    lo = (lo + Math.imul(al1, bl1)) | 0;\n    mid = (mid + Math.imul(al1, bh1)) | 0;\n    mid = (mid + Math.imul(ah1, bl1)) | 0;\n    hi = (hi + Math.imul(ah1, bh1)) | 0;\n    lo = (lo + Math.imul(al0, bl2)) | 0;\n    mid = (mid + Math.imul(al0, bh2)) | 0;\n    mid = (mid + Math.imul(ah0, bl2)) | 0;\n    hi = (hi + Math.imul(ah0, bh2)) | 0;\n    var w2 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n    c = (((hi + (mid >>> 13)) | 0) + (w2 >>> 26)) | 0;\n    w2 &= 0x3ffffff;\n    /* k = 3 */\n    lo = Math.imul(al3, bl0);\n    mid = Math.imul(al3, bh0);\n    mid = (mid + Math.imul(ah3, bl0)) | 0;\n    hi = Math.imul(ah3, bh0);\n    lo = (lo + Math.imul(al2, bl1)) | 0;\n    mid = (mid + Math.imul(al2, bh1)) | 0;\n    mid = (mid + Math.imul(ah2, bl1)) | 0;\n    hi = (hi + Math.imul(ah2, bh1)) | 0;\n    lo = (lo + Math.imul(al1, bl2)) | 0;\n    mid = (mid + Math.imul(al1, bh2)) | 0;\n    mid = (mid + Math.imul(ah1, bl2)) | 0;\n    hi = (hi + Math.imul(ah1, bh2)) | 0;\n    lo = (lo + Math.imul(al0, bl3)) | 0;\n    mid = (mid + Math.imul(al0, bh3)) | 0;\n    mid = (mid + Math.imul(ah0, bl3)) | 0;\n    hi = (hi + Math.imul(ah0, bh3)) | 0;\n    var w3 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n    c = (((hi + (mid >>> 13)) | 0) + (w3 >>> 26)) | 0;\n    w3 &= 0x3ffffff;\n    /* k = 4 */\n    lo = Math.imul(al4, bl0);\n    mid = Math.imul(al4, bh0);\n    mid = (mid + Math.imul(ah4, bl0)) | 0;\n    hi = Math.imul(ah4, bh0);\n    lo = (lo + Math.imul(al3, bl1)) | 0;\n    mid = (mid + Math.imul(al3, bh1)) | 0;\n    mid = (mid + Math.imul(ah3, bl1)) | 0;\n    hi = (hi + Math.imul(ah3, bh1)) | 0;\n    lo = (lo + Math.imul(al2, bl2)) | 0;\n    mid = (mid + Math.imul(al2, bh2)) | 0;\n    mid = (mid + Math.imul(ah2, bl2)) | 0;\n    hi = (hi + Math.imul(ah2, bh2)) | 0;\n    lo = (lo + Math.imul(al1, bl3)) | 0;\n    mid = (mid + Math.imul(al1, bh3)) | 0;\n    mid = (mid + Math.imul(ah1, bl3)) | 0;\n    hi = (hi + Math.imul(ah1, bh3)) | 0;\n    lo = (lo + Math.imul(al0, bl4)) | 0;\n    mid = (mid + Math.imul(al0, bh4)) | 0;\n    mid = (mid + Math.imul(ah0, bl4)) | 0;\n    hi = (hi + Math.imul(ah0, bh4)) | 0;\n    var w4 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n    c = (((hi + (mid >>> 13)) | 0) + (w4 >>> 26)) | 0;\n    w4 &= 0x3ffffff;\n    /* k = 5 */\n    lo = Math.imul(al5, bl0);\n    mid = Math.imul(al5, bh0);\n    mid = (mid + Math.imul(ah5, bl0)) | 0;\n    hi = Math.imul(ah5, bh0);\n    lo = (lo + Math.imul(al4, bl1)) | 0;\n    mid = (mid + Math.imul(al4, bh1)) | 0;\n    mid = (mid + Math.imul(ah4, bl1)) | 0;\n    hi = (hi + Math.imul(ah4, bh1)) | 0;\n    lo = (lo + Math.imul(al3, bl2)) | 0;\n    mid = (mid + Math.imul(al3, bh2)) | 0;\n    mid = (mid + Math.imul(ah3, bl2)) | 0;\n    hi = (hi + Math.imul(ah3, bh2)) | 0;\n    lo = (lo + Math.imul(al2, bl3)) | 0;\n    mid = (mid + Math.imul(al2, bh3)) | 0;\n    mid = (mid + Math.imul(ah2, bl3)) | 0;\n    hi = (hi + Math.imul(ah2, bh3)) | 0;\n    lo = (lo + Math.imul(al1, bl4)) | 0;\n    mid = (mid + Math.imul(al1, bh4)) | 0;\n    mid = (mid + Math.imul(ah1, bl4)) | 0;\n    hi = (hi + Math.imul(ah1, bh4)) | 0;\n    lo = (lo + Math.imul(al0, bl5)) | 0;\n    mid = (mid + Math.imul(al0, bh5)) | 0;\n    mid = (mid + Math.imul(ah0, bl5)) | 0;\n    hi = (hi + Math.imul(ah0, bh5)) | 0;\n    var w5 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n    c = (((hi + (mid >>> 13)) | 0) + (w5 >>> 26)) | 0;\n    w5 &= 0x3ffffff;\n    /* k = 6 */\n    lo = Math.imul(al6, bl0);\n    mid = Math.imul(al6, bh0);\n    mid = (mid + Math.imul(ah6, bl0)) | 0;\n    hi = Math.imul(ah6, bh0);\n    lo = (lo + Math.imul(al5, bl1)) | 0;\n    mid = (mid + Math.imul(al5, bh1)) | 0;\n    mid = (mid + Math.imul(ah5, bl1)) | 0;\n    hi = (hi + Math.imul(ah5, bh1)) | 0;\n    lo = (lo + Math.imul(al4, bl2)) | 0;\n    mid = (mid + Math.imul(al4, bh2)) | 0;\n    mid = (mid + Math.imul(ah4, bl2)) | 0;\n    hi = (hi + Math.imul(ah4, bh2)) | 0;\n    lo = (lo + Math.imul(al3, bl3)) | 0;\n    mid = (mid + Math.imul(al3, bh3)) | 0;\n    mid = (mid + Math.imul(ah3, bl3)) | 0;\n    hi = (hi + Math.imul(ah3, bh3)) | 0;\n    lo = (lo + Math.imul(al2, bl4)) | 0;\n    mid = (mid + Math.imul(al2, bh4)) | 0;\n    mid = (mid + Math.imul(ah2, bl4)) | 0;\n    hi = (hi + Math.imul(ah2, bh4)) | 0;\n    lo = (lo + Math.imul(al1, bl5)) | 0;\n    mid = (mid + Math.imul(al1, bh5)) | 0;\n    mid = (mid + Math.imul(ah1, bl5)) | 0;\n    hi = (hi + Math.imul(ah1, bh5)) | 0;\n    lo = (lo + Math.imul(al0, bl6)) | 0;\n    mid = (mid + Math.imul(al0, bh6)) | 0;\n    mid = (mid + Math.imul(ah0, bl6)) | 0;\n    hi = (hi + Math.imul(ah0, bh6)) | 0;\n    var w6 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n    c = (((hi + (mid >>> 13)) | 0) + (w6 >>> 26)) | 0;\n    w6 &= 0x3ffffff;\n    /* k = 7 */\n    lo = Math.imul(al7, bl0);\n    mid = Math.imul(al7, bh0);\n    mid = (mid + Math.imul(ah7, bl0)) | 0;\n    hi = Math.imul(ah7, bh0);\n    lo = (lo + Math.imul(al6, bl1)) | 0;\n    mid = (mid + Math.imul(al6, bh1)) | 0;\n    mid = (mid + Math.imul(ah6, bl1)) | 0;\n    hi = (hi + Math.imul(ah6, bh1)) | 0;\n    lo = (lo + Math.imul(al5, bl2)) | 0;\n    mid = (mid + Math.imul(al5, bh2)) | 0;\n    mid = (mid + Math.imul(ah5, bl2)) | 0;\n    hi = (hi + Math.imul(ah5, bh2)) | 0;\n    lo = (lo + Math.imul(al4, bl3)) | 0;\n    mid = (mid + Math.imul(al4, bh3)) | 0;\n    mid = (mid + Math.imul(ah4, bl3)) | 0;\n    hi = (hi + Math.imul(ah4, bh3)) | 0;\n    lo = (lo + Math.imul(al3, bl4)) | 0;\n    mid = (mid + Math.imul(al3, bh4)) | 0;\n    mid = (mid + Math.imul(ah3, bl4)) | 0;\n    hi = (hi + Math.imul(ah3, bh4)) | 0;\n    lo = (lo + Math.imul(al2, bl5)) | 0;\n    mid = (mid + Math.imul(al2, bh5)) | 0;\n    mid = (mid + Math.imul(ah2, bl5)) | 0;\n    hi = (hi + Math.imul(ah2, bh5)) | 0;\n    lo = (lo + Math.imul(al1, bl6)) | 0;\n    mid = (mid + Math.imul(al1, bh6)) | 0;\n    mid = (mid + Math.imul(ah1, bl6)) | 0;\n    hi = (hi + Math.imul(ah1, bh6)) | 0;\n    lo = (lo + Math.imul(al0, bl7)) | 0;\n    mid = (mid + Math.imul(al0, bh7)) | 0;\n    mid = (mid + Math.imul(ah0, bl7)) | 0;\n    hi = (hi + Math.imul(ah0, bh7)) | 0;\n    var w7 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n    c = (((hi + (mid >>> 13)) | 0) + (w7 >>> 26)) | 0;\n    w7 &= 0x3ffffff;\n    /* k = 8 */\n    lo = Math.imul(al8, bl0);\n    mid = Math.imul(al8, bh0);\n    mid = (mid + Math.imul(ah8, bl0)) | 0;\n    hi = Math.imul(ah8, bh0);\n    lo = (lo + Math.imul(al7, bl1)) | 0;\n    mid = (mid + Math.imul(al7, bh1)) | 0;\n    mid = (mid + Math.imul(ah7, bl1)) | 0;\n    hi = (hi + Math.imul(ah7, bh1)) | 0;\n    lo = (lo + Math.imul(al6, bl2)) | 0;\n    mid = (mid + Math.imul(al6, bh2)) | 0;\n    mid = (mid + Math.imul(ah6, bl2)) | 0;\n    hi = (hi + Math.imul(ah6, bh2)) | 0;\n    lo = (lo + Math.imul(al5, bl3)) | 0;\n    mid = (mid + Math.imul(al5, bh3)) | 0;\n    mid = (mid + Math.imul(ah5, bl3)) | 0;\n    hi = (hi + Math.imul(ah5, bh3)) | 0;\n    lo = (lo + Math.imul(al4, bl4)) | 0;\n    mid = (mid + Math.imul(al4, bh4)) | 0;\n    mid = (mid + Math.imul(ah4, bl4)) | 0;\n    hi = (hi + Math.imul(ah4, bh4)) | 0;\n    lo = (lo + Math.imul(al3, bl5)) | 0;\n    mid = (mid + Math.imul(al3, bh5)) | 0;\n    mid = (mid + Math.imul(ah3, bl5)) | 0;\n    hi = (hi + Math.imul(ah3, bh5)) | 0;\n    lo = (lo + Math.imul(al2, bl6)) | 0;\n    mid = (mid + Math.imul(al2, bh6)) | 0;\n    mid = (mid + Math.imul(ah2, bl6)) | 0;\n    hi = (hi + Math.imul(ah2, bh6)) | 0;\n    lo = (lo + Math.imul(al1, bl7)) | 0;\n    mid = (mid + Math.imul(al1, bh7)) | 0;\n    mid = (mid + Math.imul(ah1, bl7)) | 0;\n    hi = (hi + Math.imul(ah1, bh7)) | 0;\n    lo = (lo + Math.imul(al0, bl8)) | 0;\n    mid = (mid + Math.imul(al0, bh8)) | 0;\n    mid = (mid + Math.imul(ah0, bl8)) | 0;\n    hi = (hi + Math.imul(ah0, bh8)) | 0;\n    var w8 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n    c = (((hi + (mid >>> 13)) | 0) + (w8 >>> 26)) | 0;\n    w8 &= 0x3ffffff;\n    /* k = 9 */\n    lo = Math.imul(al9, bl0);\n    mid = Math.imul(al9, bh0);\n    mid = (mid + Math.imul(ah9, bl0)) | 0;\n    hi = Math.imul(ah9, bh0);\n    lo = (lo + Math.imul(al8, bl1)) | 0;\n    mid = (mid + Math.imul(al8, bh1)) | 0;\n    mid = (mid + Math.imul(ah8, bl1)) | 0;\n    hi = (hi + Math.imul(ah8, bh1)) | 0;\n    lo = (lo + Math.imul(al7, bl2)) | 0;\n    mid = (mid + Math.imul(al7, bh2)) | 0;\n    mid = (mid + Math.imul(ah7, bl2)) | 0;\n    hi = (hi + Math.imul(ah7, bh2)) | 0;\n    lo = (lo + Math.imul(al6, bl3)) | 0;\n    mid = (mid + Math.imul(al6, bh3)) | 0;\n    mid = (mid + Math.imul(ah6, bl3)) | 0;\n    hi = (hi + Math.imul(ah6, bh3)) | 0;\n    lo = (lo + Math.imul(al5, bl4)) | 0;\n    mid = (mid + Math.imul(al5, bh4)) | 0;\n    mid = (mid + Math.imul(ah5, bl4)) | 0;\n    hi = (hi + Math.imul(ah5, bh4)) | 0;\n    lo = (lo + Math.imul(al4, bl5)) | 0;\n    mid = (mid + Math.imul(al4, bh5)) | 0;\n    mid = (mid + Math.imul(ah4, bl5)) | 0;\n    hi = (hi + Math.imul(ah4, bh5)) | 0;\n    lo = (lo + Math.imul(al3, bl6)) | 0;\n    mid = (mid + Math.imul(al3, bh6)) | 0;\n    mid = (mid + Math.imul(ah3, bl6)) | 0;\n    hi = (hi + Math.imul(ah3, bh6)) | 0;\n    lo = (lo + Math.imul(al2, bl7)) | 0;\n    mid = (mid + Math.imul(al2, bh7)) | 0;\n    mid = (mid + Math.imul(ah2, bl7)) | 0;\n    hi = (hi + Math.imul(ah2, bh7)) | 0;\n    lo = (lo + Math.imul(al1, bl8)) | 0;\n    mid = (mid + Math.imul(al1, bh8)) | 0;\n    mid = (mid + Math.imul(ah1, bl8)) | 0;\n    hi = (hi + Math.imul(ah1, bh8)) | 0;\n    lo = (lo + Math.imul(al0, bl9)) | 0;\n    mid = (mid + Math.imul(al0, bh9)) | 0;\n    mid = (mid + Math.imul(ah0, bl9)) | 0;\n    hi = (hi + Math.imul(ah0, bh9)) | 0;\n    var w9 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n    c = (((hi + (mid >>> 13)) | 0) + (w9 >>> 26)) | 0;\n    w9 &= 0x3ffffff;\n    /* k = 10 */\n    lo = Math.imul(al9, bl1);\n    mid = Math.imul(al9, bh1);\n    mid = (mid + Math.imul(ah9, bl1)) | 0;\n    hi = Math.imul(ah9, bh1);\n    lo = (lo + Math.imul(al8, bl2)) | 0;\n    mid = (mid + Math.imul(al8, bh2)) | 0;\n    mid = (mid + Math.imul(ah8, bl2)) | 0;\n    hi = (hi + Math.imul(ah8, bh2)) | 0;\n    lo = (lo + Math.imul(al7, bl3)) | 0;\n    mid = (mid + Math.imul(al7, bh3)) | 0;\n    mid = (mid + Math.imul(ah7, bl3)) | 0;\n    hi = (hi + Math.imul(ah7, bh3)) | 0;\n    lo = (lo + Math.imul(al6, bl4)) | 0;\n    mid = (mid + Math.imul(al6, bh4)) | 0;\n    mid = (mid + Math.imul(ah6, bl4)) | 0;\n    hi = (hi + Math.imul(ah6, bh4)) | 0;\n    lo = (lo + Math.imul(al5, bl5)) | 0;\n    mid = (mid + Math.imul(al5, bh5)) | 0;\n    mid = (mid + Math.imul(ah5, bl5)) | 0;\n    hi = (hi + Math.imul(ah5, bh5)) | 0;\n    lo = (lo + Math.imul(al4, bl6)) | 0;\n    mid = (mid + Math.imul(al4, bh6)) | 0;\n    mid = (mid + Math.imul(ah4, bl6)) | 0;\n    hi = (hi + Math.imul(ah4, bh6)) | 0;\n    lo = (lo + Math.imul(al3, bl7)) | 0;\n    mid = (mid + Math.imul(al3, bh7)) | 0;\n    mid = (mid + Math.imul(ah3, bl7)) | 0;\n    hi = (hi + Math.imul(ah3, bh7)) | 0;\n    lo = (lo + Math.imul(al2, bl8)) | 0;\n    mid = (mid + Math.imul(al2, bh8)) | 0;\n    mid = (mid + Math.imul(ah2, bl8)) | 0;\n    hi = (hi + Math.imul(ah2, bh8)) | 0;\n    lo = (lo + Math.imul(al1, bl9)) | 0;\n    mid = (mid + Math.imul(al1, bh9)) | 0;\n    mid = (mid + Math.imul(ah1, bl9)) | 0;\n    hi = (hi + Math.imul(ah1, bh9)) | 0;\n    var w10 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n    c = (((hi + (mid >>> 13)) | 0) + (w10 >>> 26)) | 0;\n    w10 &= 0x3ffffff;\n    /* k = 11 */\n    lo = Math.imul(al9, bl2);\n    mid = Math.imul(al9, bh2);\n    mid = (mid + Math.imul(ah9, bl2)) | 0;\n    hi = Math.imul(ah9, bh2);\n    lo = (lo + Math.imul(al8, bl3)) | 0;\n    mid = (mid + Math.imul(al8, bh3)) | 0;\n    mid = (mid + Math.imul(ah8, bl3)) | 0;\n    hi = (hi + Math.imul(ah8, bh3)) | 0;\n    lo = (lo + Math.imul(al7, bl4)) | 0;\n    mid = (mid + Math.imul(al7, bh4)) | 0;\n    mid = (mid + Math.imul(ah7, bl4)) | 0;\n    hi = (hi + Math.imul(ah7, bh4)) | 0;\n    lo = (lo + Math.imul(al6, bl5)) | 0;\n    mid = (mid + Math.imul(al6, bh5)) | 0;\n    mid = (mid + Math.imul(ah6, bl5)) | 0;\n    hi = (hi + Math.imul(ah6, bh5)) | 0;\n    lo = (lo + Math.imul(al5, bl6)) | 0;\n    mid = (mid + Math.imul(al5, bh6)) | 0;\n    mid = (mid + Math.imul(ah5, bl6)) | 0;\n    hi = (hi + Math.imul(ah5, bh6)) | 0;\n    lo = (lo + Math.imul(al4, bl7)) | 0;\n    mid = (mid + Math.imul(al4, bh7)) | 0;\n    mid = (mid + Math.imul(ah4, bl7)) | 0;\n    hi = (hi + Math.imul(ah4, bh7)) | 0;\n    lo = (lo + Math.imul(al3, bl8)) | 0;\n    mid = (mid + Math.imul(al3, bh8)) | 0;\n    mid = (mid + Math.imul(ah3, bl8)) | 0;\n    hi = (hi + Math.imul(ah3, bh8)) | 0;\n    lo = (lo + Math.imul(al2, bl9)) | 0;\n    mid = (mid + Math.imul(al2, bh9)) | 0;\n    mid = (mid + Math.imul(ah2, bl9)) | 0;\n    hi = (hi + Math.imul(ah2, bh9)) | 0;\n    var w11 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n    c = (((hi + (mid >>> 13)) | 0) + (w11 >>> 26)) | 0;\n    w11 &= 0x3ffffff;\n    /* k = 12 */\n    lo = Math.imul(al9, bl3);\n    mid = Math.imul(al9, bh3);\n    mid = (mid + Math.imul(ah9, bl3)) | 0;\n    hi = Math.imul(ah9, bh3);\n    lo = (lo + Math.imul(al8, bl4)) | 0;\n    mid = (mid + Math.imul(al8, bh4)) | 0;\n    mid = (mid + Math.imul(ah8, bl4)) | 0;\n    hi = (hi + Math.imul(ah8, bh4)) | 0;\n    lo = (lo + Math.imul(al7, bl5)) | 0;\n    mid = (mid + Math.imul(al7, bh5)) | 0;\n    mid = (mid + Math.imul(ah7, bl5)) | 0;\n    hi = (hi + Math.imul(ah7, bh5)) | 0;\n    lo = (lo + Math.imul(al6, bl6)) | 0;\n    mid = (mid + Math.imul(al6, bh6)) | 0;\n    mid = (mid + Math.imul(ah6, bl6)) | 0;\n    hi = (hi + Math.imul(ah6, bh6)) | 0;\n    lo = (lo + Math.imul(al5, bl7)) | 0;\n    mid = (mid + Math.imul(al5, bh7)) | 0;\n    mid = (mid + Math.imul(ah5, bl7)) | 0;\n    hi = (hi + Math.imul(ah5, bh7)) | 0;\n    lo = (lo + Math.imul(al4, bl8)) | 0;\n    mid = (mid + Math.imul(al4, bh8)) | 0;\n    mid = (mid + Math.imul(ah4, bl8)) | 0;\n    hi = (hi + Math.imul(ah4, bh8)) | 0;\n    lo = (lo + Math.imul(al3, bl9)) | 0;\n    mid = (mid + Math.imul(al3, bh9)) | 0;\n    mid = (mid + Math.imul(ah3, bl9)) | 0;\n    hi = (hi + Math.imul(ah3, bh9)) | 0;\n    var w12 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n    c = (((hi + (mid >>> 13)) | 0) + (w12 >>> 26)) | 0;\n    w12 &= 0x3ffffff;\n    /* k = 13 */\n    lo = Math.imul(al9, bl4);\n    mid = Math.imul(al9, bh4);\n    mid = (mid + Math.imul(ah9, bl4)) | 0;\n    hi = Math.imul(ah9, bh4);\n    lo = (lo + Math.imul(al8, bl5)) | 0;\n    mid = (mid + Math.imul(al8, bh5)) | 0;\n    mid = (mid + Math.imul(ah8, bl5)) | 0;\n    hi = (hi + Math.imul(ah8, bh5)) | 0;\n    lo = (lo + Math.imul(al7, bl6)) | 0;\n    mid = (mid + Math.imul(al7, bh6)) | 0;\n    mid = (mid + Math.imul(ah7, bl6)) | 0;\n    hi = (hi + Math.imul(ah7, bh6)) | 0;\n    lo = (lo + Math.imul(al6, bl7)) | 0;\n    mid = (mid + Math.imul(al6, bh7)) | 0;\n    mid = (mid + Math.imul(ah6, bl7)) | 0;\n    hi = (hi + Math.imul(ah6, bh7)) | 0;\n    lo = (lo + Math.imul(al5, bl8)) | 0;\n    mid = (mid + Math.imul(al5, bh8)) | 0;\n    mid = (mid + Math.imul(ah5, bl8)) | 0;\n    hi = (hi + Math.imul(ah5, bh8)) | 0;\n    lo = (lo + Math.imul(al4, bl9)) | 0;\n    mid = (mid + Math.imul(al4, bh9)) | 0;\n    mid = (mid + Math.imul(ah4, bl9)) | 0;\n    hi = (hi + Math.imul(ah4, bh9)) | 0;\n    var w13 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n    c = (((hi + (mid >>> 13)) | 0) + (w13 >>> 26)) | 0;\n    w13 &= 0x3ffffff;\n    /* k = 14 */\n    lo = Math.imul(al9, bl5);\n    mid = Math.imul(al9, bh5);\n    mid = (mid + Math.imul(ah9, bl5)) | 0;\n    hi = Math.imul(ah9, bh5);\n    lo = (lo + Math.imul(al8, bl6)) | 0;\n    mid = (mid + Math.imul(al8, bh6)) | 0;\n    mid = (mid + Math.imul(ah8, bl6)) | 0;\n    hi = (hi + Math.imul(ah8, bh6)) | 0;\n    lo = (lo + Math.imul(al7, bl7)) | 0;\n    mid = (mid + Math.imul(al7, bh7)) | 0;\n    mid = (mid + Math.imul(ah7, bl7)) | 0;\n    hi = (hi + Math.imul(ah7, bh7)) | 0;\n    lo = (lo + Math.imul(al6, bl8)) | 0;\n    mid = (mid + Math.imul(al6, bh8)) | 0;\n    mid = (mid + Math.imul(ah6, bl8)) | 0;\n    hi = (hi + Math.imul(ah6, bh8)) | 0;\n    lo = (lo + Math.imul(al5, bl9)) | 0;\n    mid = (mid + Math.imul(al5, bh9)) | 0;\n    mid = (mid + Math.imul(ah5, bl9)) | 0;\n    hi = (hi + Math.imul(ah5, bh9)) | 0;\n    var w14 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n    c = (((hi + (mid >>> 13)) | 0) + (w14 >>> 26)) | 0;\n    w14 &= 0x3ffffff;\n    /* k = 15 */\n    lo = Math.imul(al9, bl6);\n    mid = Math.imul(al9, bh6);\n    mid = (mid + Math.imul(ah9, bl6)) | 0;\n    hi = Math.imul(ah9, bh6);\n    lo = (lo + Math.imul(al8, bl7)) | 0;\n    mid = (mid + Math.imul(al8, bh7)) | 0;\n    mid = (mid + Math.imul(ah8, bl7)) | 0;\n    hi = (hi + Math.imul(ah8, bh7)) | 0;\n    lo = (lo + Math.imul(al7, bl8)) | 0;\n    mid = (mid + Math.imul(al7, bh8)) | 0;\n    mid = (mid + Math.imul(ah7, bl8)) | 0;\n    hi = (hi + Math.imul(ah7, bh8)) | 0;\n    lo = (lo + Math.imul(al6, bl9)) | 0;\n    mid = (mid + Math.imul(al6, bh9)) | 0;\n    mid = (mid + Math.imul(ah6, bl9)) | 0;\n    hi = (hi + Math.imul(ah6, bh9)) | 0;\n    var w15 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n    c = (((hi + (mid >>> 13)) | 0) + (w15 >>> 26)) | 0;\n    w15 &= 0x3ffffff;\n    /* k = 16 */\n    lo = Math.imul(al9, bl7);\n    mid = Math.imul(al9, bh7);\n    mid = (mid + Math.imul(ah9, bl7)) | 0;\n    hi = Math.imul(ah9, bh7);\n    lo = (lo + Math.imul(al8, bl8)) | 0;\n    mid = (mid + Math.imul(al8, bh8)) | 0;\n    mid = (mid + Math.imul(ah8, bl8)) | 0;\n    hi = (hi + Math.imul(ah8, bh8)) | 0;\n    lo = (lo + Math.imul(al7, bl9)) | 0;\n    mid = (mid + Math.imul(al7, bh9)) | 0;\n    mid = (mid + Math.imul(ah7, bl9)) | 0;\n    hi = (hi + Math.imul(ah7, bh9)) | 0;\n    var w16 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n    c = (((hi + (mid >>> 13)) | 0) + (w16 >>> 26)) | 0;\n    w16 &= 0x3ffffff;\n    /* k = 17 */\n    lo = Math.imul(al9, bl8);\n    mid = Math.imul(al9, bh8);\n    mid = (mid + Math.imul(ah9, bl8)) | 0;\n    hi = Math.imul(ah9, bh8);\n    lo = (lo + Math.imul(al8, bl9)) | 0;\n    mid = (mid + Math.imul(al8, bh9)) | 0;\n    mid = (mid + Math.imul(ah8, bl9)) | 0;\n    hi = (hi + Math.imul(ah8, bh9)) | 0;\n    var w17 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n    c = (((hi + (mid >>> 13)) | 0) + (w17 >>> 26)) | 0;\n    w17 &= 0x3ffffff;\n    /* k = 18 */\n    lo = Math.imul(al9, bl9);\n    mid = Math.imul(al9, bh9);\n    mid = (mid + Math.imul(ah9, bl9)) | 0;\n    hi = Math.imul(ah9, bh9);\n    var w18 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n    c = (((hi + (mid >>> 13)) | 0) + (w18 >>> 26)) | 0;\n    w18 &= 0x3ffffff;\n    o[0] = w0;\n    o[1] = w1;\n    o[2] = w2;\n    o[3] = w3;\n    o[4] = w4;\n    o[5] = w5;\n    o[6] = w6;\n    o[7] = w7;\n    o[8] = w8;\n    o[9] = w9;\n    o[10] = w10;\n    o[11] = w11;\n    o[12] = w12;\n    o[13] = w13;\n    o[14] = w14;\n    o[15] = w15;\n    o[16] = w16;\n    o[17] = w17;\n    o[18] = w18;\n    if (c !== 0) {\n      o[19] = c;\n      out.length++;\n    }\n    return out;\n  };\n\n  // Polyfill comb\n  if (!Math.imul) {\n    comb10MulTo = smallMulTo;\n  }\n\n  function bigMulTo (self, num, out) {\n    out.negative = num.negative ^ self.negative;\n    out.length = self.length + num.length;\n\n    var carry = 0;\n    var hncarry = 0;\n    for (var k = 0; k < out.length - 1; k++) {\n      // Sum all words with the same `i + j = k` and accumulate `ncarry`,\n      // note that ncarry could be >= 0x3ffffff\n      var ncarry = hncarry;\n      hncarry = 0;\n      var rword = carry & 0x3ffffff;\n      var maxJ = Math.min(k, num.length - 1);\n      for (var j = Math.max(0, k - self.length + 1); j <= maxJ; j++) {\n        var i = k - j;\n        var a = self.words[i] | 0;\n        var b = num.words[j] | 0;\n        var r = a * b;\n\n        var lo = r & 0x3ffffff;\n        ncarry = (ncarry + ((r / 0x4000000) | 0)) | 0;\n        lo = (lo + rword) | 0;\n        rword = lo & 0x3ffffff;\n        ncarry = (ncarry + (lo >>> 26)) | 0;\n\n        hncarry += ncarry >>> 26;\n        ncarry &= 0x3ffffff;\n      }\n      out.words[k] = rword;\n      carry = ncarry;\n      ncarry = hncarry;\n    }\n    if (carry !== 0) {\n      out.words[k] = carry;\n    } else {\n      out.length--;\n    }\n\n    return out.strip();\n  }\n\n  function jumboMulTo (self, num, out) {\n    var fftm = new FFTM();\n    return fftm.mulp(self, num, out);\n  }\n\n  BN.prototype.mulTo = function mulTo (num, out) {\n    var res;\n    var len = this.length + num.length;\n    if (this.length === 10 && num.length === 10) {\n      res = comb10MulTo(this, num, out);\n    } else if (len < 63) {\n      res = smallMulTo(this, num, out);\n    } else if (len < 1024) {\n      res = bigMulTo(this, num, out);\n    } else {\n      res = jumboMulTo(this, num, out);\n    }\n\n    return res;\n  };\n\n  // Cooley-Tukey algorithm for FFT\n  // slightly revisited to rely on looping instead of recursion\n\n  function FFTM (x, y) {\n    this.x = x;\n    this.y = y;\n  }\n\n  FFTM.prototype.makeRBT = function makeRBT (N) {\n    var t = new Array(N);\n    var l = BN.prototype._countBits(N) - 1;\n    for (var i = 0; i < N; i++) {\n      t[i] = this.revBin(i, l, N);\n    }\n\n    return t;\n  };\n\n  // Returns binary-reversed representation of `x`\n  FFTM.prototype.revBin = function revBin (x, l, N) {\n    if (x === 0 || x === N - 1) return x;\n\n    var rb = 0;\n    for (var i = 0; i < l; i++) {\n      rb |= (x & 1) << (l - i - 1);\n      x >>= 1;\n    }\n\n    return rb;\n  };\n\n  // Performs \"tweedling\" phase, therefore 'emulating'\n  // behaviour of the recursive algorithm\n  FFTM.prototype.permute = function permute (rbt, rws, iws, rtws, itws, N) {\n    for (var i = 0; i < N; i++) {\n      rtws[i] = rws[rbt[i]];\n      itws[i] = iws[rbt[i]];\n    }\n  };\n\n  FFTM.prototype.transform = function transform (rws, iws, rtws, itws, N, rbt) {\n    this.permute(rbt, rws, iws, rtws, itws, N);\n\n    for (var s = 1; s < N; s <<= 1) {\n      var l = s << 1;\n\n      var rtwdf = Math.cos(2 * Math.PI / l);\n      var itwdf = Math.sin(2 * Math.PI / l);\n\n      for (var p = 0; p < N; p += l) {\n        var rtwdf_ = rtwdf;\n        var itwdf_ = itwdf;\n\n        for (var j = 0; j < s; j++) {\n          var re = rtws[p + j];\n          var ie = itws[p + j];\n\n          var ro = rtws[p + j + s];\n          var io = itws[p + j + s];\n\n          var rx = rtwdf_ * ro - itwdf_ * io;\n\n          io = rtwdf_ * io + itwdf_ * ro;\n          ro = rx;\n\n          rtws[p + j] = re + ro;\n          itws[p + j] = ie + io;\n\n          rtws[p + j + s] = re - ro;\n          itws[p + j + s] = ie - io;\n\n          /* jshint maxdepth : false */\n          if (j !== l) {\n            rx = rtwdf * rtwdf_ - itwdf * itwdf_;\n\n            itwdf_ = rtwdf * itwdf_ + itwdf * rtwdf_;\n            rtwdf_ = rx;\n          }\n        }\n      }\n    }\n  };\n\n  FFTM.prototype.guessLen13b = function guessLen13b (n, m) {\n    var N = Math.max(m, n) | 1;\n    var odd = N & 1;\n    var i = 0;\n    for (N = N / 2 | 0; N; N = N >>> 1) {\n      i++;\n    }\n\n    return 1 << i + 1 + odd;\n  };\n\n  FFTM.prototype.conjugate = function conjugate (rws, iws, N) {\n    if (N <= 1) return;\n\n    for (var i = 0; i < N / 2; i++) {\n      var t = rws[i];\n\n      rws[i] = rws[N - i - 1];\n      rws[N - i - 1] = t;\n\n      t = iws[i];\n\n      iws[i] = -iws[N - i - 1];\n      iws[N - i - 1] = -t;\n    }\n  };\n\n  FFTM.prototype.normalize13b = function normalize13b (ws, N) {\n    var carry = 0;\n    for (var i = 0; i < N / 2; i++) {\n      var w = Math.round(ws[2 * i + 1] / N) * 0x2000 +\n        Math.round(ws[2 * i] / N) +\n        carry;\n\n      ws[i] = w & 0x3ffffff;\n\n      if (w < 0x4000000) {\n        carry = 0;\n      } else {\n        carry = w / 0x4000000 | 0;\n      }\n    }\n\n    return ws;\n  };\n\n  FFTM.prototype.convert13b = function convert13b (ws, len, rws, N) {\n    var carry = 0;\n    for (var i = 0; i < len; i++) {\n      carry = carry + (ws[i] | 0);\n\n      rws[2 * i] = carry & 0x1fff; carry = carry >>> 13;\n      rws[2 * i + 1] = carry & 0x1fff; carry = carry >>> 13;\n    }\n\n    // Pad with zeroes\n    for (i = 2 * len; i < N; ++i) {\n      rws[i] = 0;\n    }\n\n    assert(carry === 0);\n    assert((carry & ~0x1fff) === 0);\n  };\n\n  FFTM.prototype.stub = function stub (N) {\n    var ph = new Array(N);\n    for (var i = 0; i < N; i++) {\n      ph[i] = 0;\n    }\n\n    return ph;\n  };\n\n  FFTM.prototype.mulp = function mulp (x, y, out) {\n    var N = 2 * this.guessLen13b(x.length, y.length);\n\n    var rbt = this.makeRBT(N);\n\n    var _ = this.stub(N);\n\n    var rws = new Array(N);\n    var rwst = new Array(N);\n    var iwst = new Array(N);\n\n    var nrws = new Array(N);\n    var nrwst = new Array(N);\n    var niwst = new Array(N);\n\n    var rmws = out.words;\n    rmws.length = N;\n\n    this.convert13b(x.words, x.length, rws, N);\n    this.convert13b(y.words, y.length, nrws, N);\n\n    this.transform(rws, _, rwst, iwst, N, rbt);\n    this.transform(nrws, _, nrwst, niwst, N, rbt);\n\n    for (var i = 0; i < N; i++) {\n      var rx = rwst[i] * nrwst[i] - iwst[i] * niwst[i];\n      iwst[i] = rwst[i] * niwst[i] + iwst[i] * nrwst[i];\n      rwst[i] = rx;\n    }\n\n    this.conjugate(rwst, iwst, N);\n    this.transform(rwst, iwst, rmws, _, N, rbt);\n    this.conjugate(rmws, _, N);\n    this.normalize13b(rmws, N);\n\n    out.negative = x.negative ^ y.negative;\n    out.length = x.length + y.length;\n    return out.strip();\n  };\n\n  // Multiply `this` by `num`\n  BN.prototype.mul = function mul (num) {\n    var out = new BN(null);\n    out.words = new Array(this.length + num.length);\n    return this.mulTo(num, out);\n  };\n\n  // Multiply employing FFT\n  BN.prototype.mulf = function mulf (num) {\n    var out = new BN(null);\n    out.words = new Array(this.length + num.length);\n    return jumboMulTo(this, num, out);\n  };\n\n  // In-place Multiplication\n  BN.prototype.imul = function imul (num) {\n    return this.clone().mulTo(num, this);\n  };\n\n  BN.prototype.imuln = function imuln (num) {\n    assert(typeof num === 'number');\n    assert(num < 0x4000000);\n\n    // Carry\n    var carry = 0;\n    for (var i = 0; i < this.length; i++) {\n      var w = (this.words[i] | 0) * num;\n      var lo = (w & 0x3ffffff) + (carry & 0x3ffffff);\n      carry >>= 26;\n      carry += (w / 0x4000000) | 0;\n      // NOTE: lo is 27bit maximum\n      carry += lo >>> 26;\n      this.words[i] = lo & 0x3ffffff;\n    }\n\n    if (carry !== 0) {\n      this.words[i] = carry;\n      this.length++;\n    }\n\n    return this;\n  };\n\n  BN.prototype.muln = function muln (num) {\n    return this.clone().imuln(num);\n  };\n\n  // `this` * `this`\n  BN.prototype.sqr = function sqr () {\n    return this.mul(this);\n  };\n\n  // `this` * `this` in-place\n  BN.prototype.isqr = function isqr () {\n    return this.imul(this.clone());\n  };\n\n  // Math.pow(`this`, `num`)\n  BN.prototype.pow = function pow (num) {\n    var w = toBitArray(num);\n    if (w.length === 0) return new BN(1);\n\n    // Skip leading zeroes\n    var res = this;\n    for (var i = 0; i < w.length; i++, res = res.sqr()) {\n      if (w[i] !== 0) break;\n    }\n\n    if (++i < w.length) {\n      for (var q = res.sqr(); i < w.length; i++, q = q.sqr()) {\n        if (w[i] === 0) continue;\n\n        res = res.mul(q);\n      }\n    }\n\n    return res;\n  };\n\n  // Shift-left in-place\n  BN.prototype.iushln = function iushln (bits) {\n    assert(typeof bits === 'number' && bits >= 0);\n    var r = bits % 26;\n    var s = (bits - r) / 26;\n    var carryMask = (0x3ffffff >>> (26 - r)) << (26 - r);\n    var i;\n\n    if (r !== 0) {\n      var carry = 0;\n\n      for (i = 0; i < this.length; i++) {\n        var newCarry = this.words[i] & carryMask;\n        var c = ((this.words[i] | 0) - newCarry) << r;\n        this.words[i] = c | carry;\n        carry = newCarry >>> (26 - r);\n      }\n\n      if (carry) {\n        this.words[i] = carry;\n        this.length++;\n      }\n    }\n\n    if (s !== 0) {\n      for (i = this.length - 1; i >= 0; i--) {\n        this.words[i + s] = this.words[i];\n      }\n\n      for (i = 0; i < s; i++) {\n        this.words[i] = 0;\n      }\n\n      this.length += s;\n    }\n\n    return this.strip();\n  };\n\n  BN.prototype.ishln = function ishln (bits) {\n    // TODO(indutny): implement me\n    assert(this.negative === 0);\n    return this.iushln(bits);\n  };\n\n  // Shift-right in-place\n  // NOTE: `hint` is a lowest bit before trailing zeroes\n  // NOTE: if `extended` is present - it will be filled with destroyed bits\n  BN.prototype.iushrn = function iushrn (bits, hint, extended) {\n    assert(typeof bits === 'number' && bits >= 0);\n    var h;\n    if (hint) {\n      h = (hint - (hint % 26)) / 26;\n    } else {\n      h = 0;\n    }\n\n    var r = bits % 26;\n    var s = Math.min((bits - r) / 26, this.length);\n    var mask = 0x3ffffff ^ ((0x3ffffff >>> r) << r);\n    var maskedWords = extended;\n\n    h -= s;\n    h = Math.max(0, h);\n\n    // Extended mode, copy masked part\n    if (maskedWords) {\n      for (var i = 0; i < s; i++) {\n        maskedWords.words[i] = this.words[i];\n      }\n      maskedWords.length = s;\n    }\n\n    if (s === 0) {\n      // No-op, we should not move anything at all\n    } else if (this.length > s) {\n      this.length -= s;\n      for (i = 0; i < this.length; i++) {\n        this.words[i] = this.words[i + s];\n      }\n    } else {\n      this.words[0] = 0;\n      this.length = 1;\n    }\n\n    var carry = 0;\n    for (i = this.length - 1; i >= 0 && (carry !== 0 || i >= h); i--) {\n      var word = this.words[i] | 0;\n      this.words[i] = (carry << (26 - r)) | (word >>> r);\n      carry = word & mask;\n    }\n\n    // Push carried bits as a mask\n    if (maskedWords && carry !== 0) {\n      maskedWords.words[maskedWords.length++] = carry;\n    }\n\n    if (this.length === 0) {\n      this.words[0] = 0;\n      this.length = 1;\n    }\n\n    return this.strip();\n  };\n\n  BN.prototype.ishrn = function ishrn (bits, hint, extended) {\n    // TODO(indutny): implement me\n    assert(this.negative === 0);\n    return this.iushrn(bits, hint, extended);\n  };\n\n  // Shift-left\n  BN.prototype.shln = function shln (bits) {\n    return this.clone().ishln(bits);\n  };\n\n  BN.prototype.ushln = function ushln (bits) {\n    return this.clone().iushln(bits);\n  };\n\n  // Shift-right\n  BN.prototype.shrn = function shrn (bits) {\n    return this.clone().ishrn(bits);\n  };\n\n  BN.prototype.ushrn = function ushrn (bits) {\n    return this.clone().iushrn(bits);\n  };\n\n  // Test if n bit is set\n  BN.prototype.testn = function testn (bit) {\n    assert(typeof bit === 'number' && bit >= 0);\n    var r = bit % 26;\n    var s = (bit - r) / 26;\n    var q = 1 << r;\n\n    // Fast case: bit is much higher than all existing words\n    if (this.length <= s) return false;\n\n    // Check bit and return\n    var w = this.words[s];\n\n    return !!(w & q);\n  };\n\n  // Return only lowers bits of number (in-place)\n  BN.prototype.imaskn = function imaskn (bits) {\n    assert(typeof bits === 'number' && bits >= 0);\n    var r = bits % 26;\n    var s = (bits - r) / 26;\n\n    assert(this.negative === 0, 'imaskn works only with positive numbers');\n\n    if (this.length <= s) {\n      return this;\n    }\n\n    if (r !== 0) {\n      s++;\n    }\n    this.length = Math.min(s, this.length);\n\n    if (r !== 0) {\n      var mask = 0x3ffffff ^ ((0x3ffffff >>> r) << r);\n      this.words[this.length - 1] &= mask;\n    }\n\n    return this.strip();\n  };\n\n  // Return only lowers bits of number\n  BN.prototype.maskn = function maskn (bits) {\n    return this.clone().imaskn(bits);\n  };\n\n  // Add plain number `num` to `this`\n  BN.prototype.iaddn = function iaddn (num) {\n    assert(typeof num === 'number');\n    assert(num < 0x4000000);\n    if (num < 0) return this.isubn(-num);\n\n    // Possible sign change\n    if (this.negative !== 0) {\n      if (this.length === 1 && (this.words[0] | 0) < num) {\n        this.words[0] = num - (this.words[0] | 0);\n        this.negative = 0;\n        return this;\n      }\n\n      this.negative = 0;\n      this.isubn(num);\n      this.negative = 1;\n      return this;\n    }\n\n    // Add without checks\n    return this._iaddn(num);\n  };\n\n  BN.prototype._iaddn = function _iaddn (num) {\n    this.words[0] += num;\n\n    // Carry\n    for (var i = 0; i < this.length && this.words[i] >= 0x4000000; i++) {\n      this.words[i] -= 0x4000000;\n      if (i === this.length - 1) {\n        this.words[i + 1] = 1;\n      } else {\n        this.words[i + 1]++;\n      }\n    }\n    this.length = Math.max(this.length, i + 1);\n\n    return this;\n  };\n\n  // Subtract plain number `num` from `this`\n  BN.prototype.isubn = function isubn (num) {\n    assert(typeof num === 'number');\n    assert(num < 0x4000000);\n    if (num < 0) return this.iaddn(-num);\n\n    if (this.negative !== 0) {\n      this.negative = 0;\n      this.iaddn(num);\n      this.negative = 1;\n      return this;\n    }\n\n    this.words[0] -= num;\n\n    if (this.length === 1 && this.words[0] < 0) {\n      this.words[0] = -this.words[0];\n      this.negative = 1;\n    } else {\n      // Carry\n      for (var i = 0; i < this.length && this.words[i] < 0; i++) {\n        this.words[i] += 0x4000000;\n        this.words[i + 1] -= 1;\n      }\n    }\n\n    return this.strip();\n  };\n\n  BN.prototype.addn = function addn (num) {\n    return this.clone().iaddn(num);\n  };\n\n  BN.prototype.subn = function subn (num) {\n    return this.clone().isubn(num);\n  };\n\n  BN.prototype.iabs = function iabs () {\n    this.negative = 0;\n\n    return this;\n  };\n\n  BN.prototype.abs = function abs () {\n    return this.clone().iabs();\n  };\n\n  BN.prototype._ishlnsubmul = function _ishlnsubmul (num, mul, shift) {\n    var len = num.length + shift;\n    var i;\n\n    this._expand(len);\n\n    var w;\n    var carry = 0;\n    for (i = 0; i < num.length; i++) {\n      w = (this.words[i + shift] | 0) + carry;\n      var right = (num.words[i] | 0) * mul;\n      w -= right & 0x3ffffff;\n      carry = (w >> 26) - ((right / 0x4000000) | 0);\n      this.words[i + shift] = w & 0x3ffffff;\n    }\n    for (; i < this.length - shift; i++) {\n      w = (this.words[i + shift] | 0) + carry;\n      carry = w >> 26;\n      this.words[i + shift] = w & 0x3ffffff;\n    }\n\n    if (carry === 0) return this.strip();\n\n    // Subtraction overflow\n    assert(carry === -1);\n    carry = 0;\n    for (i = 0; i < this.length; i++) {\n      w = -(this.words[i] | 0) + carry;\n      carry = w >> 26;\n      this.words[i] = w & 0x3ffffff;\n    }\n    this.negative = 1;\n\n    return this.strip();\n  };\n\n  BN.prototype._wordDiv = function _wordDiv (num, mode) {\n    var shift = this.length - num.length;\n\n    var a = this.clone();\n    var b = num;\n\n    // Normalize\n    var bhi = b.words[b.length - 1] | 0;\n    var bhiBits = this._countBits(bhi);\n    shift = 26 - bhiBits;\n    if (shift !== 0) {\n      b = b.ushln(shift);\n      a.iushln(shift);\n      bhi = b.words[b.length - 1] | 0;\n    }\n\n    // Initialize quotient\n    var m = a.length - b.length;\n    var q;\n\n    if (mode !== 'mod') {\n      q = new BN(null);\n      q.length = m + 1;\n      q.words = new Array(q.length);\n      for (var i = 0; i < q.length; i++) {\n        q.words[i] = 0;\n      }\n    }\n\n    var diff = a.clone()._ishlnsubmul(b, 1, m);\n    if (diff.negative === 0) {\n      a = diff;\n      if (q) {\n        q.words[m] = 1;\n      }\n    }\n\n    for (var j = m - 1; j >= 0; j--) {\n      var qj = (a.words[b.length + j] | 0) * 0x4000000 +\n        (a.words[b.length + j - 1] | 0);\n\n      // NOTE: (qj / bhi) is (0x3ffffff * 0x4000000 + 0x3ffffff) / 0x2000000 max\n      // (0x7ffffff)\n      qj = Math.min((qj / bhi) | 0, 0x3ffffff);\n\n      a._ishlnsubmul(b, qj, j);\n      while (a.negative !== 0) {\n        qj--;\n        a.negative = 0;\n        a._ishlnsubmul(b, 1, j);\n        if (!a.isZero()) {\n          a.negative ^= 1;\n        }\n      }\n      if (q) {\n        q.words[j] = qj;\n      }\n    }\n    if (q) {\n      q.strip();\n    }\n    a.strip();\n\n    // Denormalize\n    if (mode !== 'div' && shift !== 0) {\n      a.iushrn(shift);\n    }\n\n    return {\n      div: q || null,\n      mod: a\n    };\n  };\n\n  // NOTE: 1) `mode` can be set to `mod` to request mod only,\n  //       to `div` to request div only, or be absent to\n  //       request both div & mod\n  //       2) `positive` is true if unsigned mod is requested\n  BN.prototype.divmod = function divmod (num, mode, positive) {\n    assert(!num.isZero());\n\n    if (this.isZero()) {\n      return {\n        div: new BN(0),\n        mod: new BN(0)\n      };\n    }\n\n    var div, mod, res;\n    if (this.negative !== 0 && num.negative === 0) {\n      res = this.neg().divmod(num, mode);\n\n      if (mode !== 'mod') {\n        div = res.div.neg();\n      }\n\n      if (mode !== 'div') {\n        mod = res.mod.neg();\n        if (positive && mod.negative !== 0) {\n          mod.iadd(num);\n        }\n      }\n\n      return {\n        div: div,\n        mod: mod\n      };\n    }\n\n    if (this.negative === 0 && num.negative !== 0) {\n      res = this.divmod(num.neg(), mode);\n\n      if (mode !== 'mod') {\n        div = res.div.neg();\n      }\n\n      return {\n        div: div,\n        mod: res.mod\n      };\n    }\n\n    if ((this.negative & num.negative) !== 0) {\n      res = this.neg().divmod(num.neg(), mode);\n\n      if (mode !== 'div') {\n        mod = res.mod.neg();\n        if (positive && mod.negative !== 0) {\n          mod.isub(num);\n        }\n      }\n\n      return {\n        div: res.div,\n        mod: mod\n      };\n    }\n\n    // Both numbers are positive at this point\n\n    // Strip both numbers to approximate shift value\n    if (num.length > this.length || this.cmp(num) < 0) {\n      return {\n        div: new BN(0),\n        mod: this\n      };\n    }\n\n    // Very short reduction\n    if (num.length === 1) {\n      if (mode === 'div') {\n        return {\n          div: this.divn(num.words[0]),\n          mod: null\n        };\n      }\n\n      if (mode === 'mod') {\n        return {\n          div: null,\n          mod: new BN(this.modn(num.words[0]))\n        };\n      }\n\n      return {\n        div: this.divn(num.words[0]),\n        mod: new BN(this.modn(num.words[0]))\n      };\n    }\n\n    return this._wordDiv(num, mode);\n  };\n\n  // Find `this` / `num`\n  BN.prototype.div = function div (num) {\n    return this.divmod(num, 'div', false).div;\n  };\n\n  // Find `this` % `num`\n  BN.prototype.mod = function mod (num) {\n    return this.divmod(num, 'mod', false).mod;\n  };\n\n  BN.prototype.umod = function umod (num) {\n    return this.divmod(num, 'mod', true).mod;\n  };\n\n  // Find Round(`this` / `num`)\n  BN.prototype.divRound = function divRound (num) {\n    var dm = this.divmod(num);\n\n    // Fast case - exact division\n    if (dm.mod.isZero()) return dm.div;\n\n    var mod = dm.div.negative !== 0 ? dm.mod.isub(num) : dm.mod;\n\n    var half = num.ushrn(1);\n    var r2 = num.andln(1);\n    var cmp = mod.cmp(half);\n\n    // Round down\n    if (cmp < 0 || r2 === 1 && cmp === 0) return dm.div;\n\n    // Round up\n    return dm.div.negative !== 0 ? dm.div.isubn(1) : dm.div.iaddn(1);\n  };\n\n  BN.prototype.modn = function modn (num) {\n    assert(num <= 0x3ffffff);\n    var p = (1 << 26) % num;\n\n    var acc = 0;\n    for (var i = this.length - 1; i >= 0; i--) {\n      acc = (p * acc + (this.words[i] | 0)) % num;\n    }\n\n    return acc;\n  };\n\n  // In-place division by number\n  BN.prototype.idivn = function idivn (num) {\n    assert(num <= 0x3ffffff);\n\n    var carry = 0;\n    for (var i = this.length - 1; i >= 0; i--) {\n      var w = (this.words[i] | 0) + carry * 0x4000000;\n      this.words[i] = (w / num) | 0;\n      carry = w % num;\n    }\n\n    return this.strip();\n  };\n\n  BN.prototype.divn = function divn (num) {\n    return this.clone().idivn(num);\n  };\n\n  BN.prototype.egcd = function egcd (p) {\n    assert(p.negative === 0);\n    assert(!p.isZero());\n\n    var x = this;\n    var y = p.clone();\n\n    if (x.negative !== 0) {\n      x = x.umod(p);\n    } else {\n      x = x.clone();\n    }\n\n    // A * x + B * y = x\n    var A = new BN(1);\n    var B = new BN(0);\n\n    // C * x + D * y = y\n    var C = new BN(0);\n    var D = new BN(1);\n\n    var g = 0;\n\n    while (x.isEven() && y.isEven()) {\n      x.iushrn(1);\n      y.iushrn(1);\n      ++g;\n    }\n\n    var yp = y.clone();\n    var xp = x.clone();\n\n    while (!x.isZero()) {\n      for (var i = 0, im = 1; (x.words[0] & im) === 0 && i < 26; ++i, im <<= 1);\n      if (i > 0) {\n        x.iushrn(i);\n        while (i-- > 0) {\n          if (A.isOdd() || B.isOdd()) {\n            A.iadd(yp);\n            B.isub(xp);\n          }\n\n          A.iushrn(1);\n          B.iushrn(1);\n        }\n      }\n\n      for (var j = 0, jm = 1; (y.words[0] & jm) === 0 && j < 26; ++j, jm <<= 1);\n      if (j > 0) {\n        y.iushrn(j);\n        while (j-- > 0) {\n          if (C.isOdd() || D.isOdd()) {\n            C.iadd(yp);\n            D.isub(xp);\n          }\n\n          C.iushrn(1);\n          D.iushrn(1);\n        }\n      }\n\n      if (x.cmp(y) >= 0) {\n        x.isub(y);\n        A.isub(C);\n        B.isub(D);\n      } else {\n        y.isub(x);\n        C.isub(A);\n        D.isub(B);\n      }\n    }\n\n    return {\n      a: C,\n      b: D,\n      gcd: y.iushln(g)\n    };\n  };\n\n  // This is reduced incarnation of the binary EEA\n  // above, designated to invert members of the\n  // _prime_ fields F(p) at a maximal speed\n  BN.prototype._invmp = function _invmp (p) {\n    assert(p.negative === 0);\n    assert(!p.isZero());\n\n    var a = this;\n    var b = p.clone();\n\n    if (a.negative !== 0) {\n      a = a.umod(p);\n    } else {\n      a = a.clone();\n    }\n\n    var x1 = new BN(1);\n    var x2 = new BN(0);\n\n    var delta = b.clone();\n\n    while (a.cmpn(1) > 0 && b.cmpn(1) > 0) {\n      for (var i = 0, im = 1; (a.words[0] & im) === 0 && i < 26; ++i, im <<= 1);\n      if (i > 0) {\n        a.iushrn(i);\n        while (i-- > 0) {\n          if (x1.isOdd()) {\n            x1.iadd(delta);\n          }\n\n          x1.iushrn(1);\n        }\n      }\n\n      for (var j = 0, jm = 1; (b.words[0] & jm) === 0 && j < 26; ++j, jm <<= 1);\n      if (j > 0) {\n        b.iushrn(j);\n        while (j-- > 0) {\n          if (x2.isOdd()) {\n            x2.iadd(delta);\n          }\n\n          x2.iushrn(1);\n        }\n      }\n\n      if (a.cmp(b) >= 0) {\n        a.isub(b);\n        x1.isub(x2);\n      } else {\n        b.isub(a);\n        x2.isub(x1);\n      }\n    }\n\n    var res;\n    if (a.cmpn(1) === 0) {\n      res = x1;\n    } else {\n      res = x2;\n    }\n\n    if (res.cmpn(0) < 0) {\n      res.iadd(p);\n    }\n\n    return res;\n  };\n\n  BN.prototype.gcd = function gcd (num) {\n    if (this.isZero()) return num.abs();\n    if (num.isZero()) return this.abs();\n\n    var a = this.clone();\n    var b = num.clone();\n    a.negative = 0;\n    b.negative = 0;\n\n    // Remove common factor of two\n    for (var shift = 0; a.isEven() && b.isEven(); shift++) {\n      a.iushrn(1);\n      b.iushrn(1);\n    }\n\n    do {\n      while (a.isEven()) {\n        a.iushrn(1);\n      }\n      while (b.isEven()) {\n        b.iushrn(1);\n      }\n\n      var r = a.cmp(b);\n      if (r < 0) {\n        // Swap `a` and `b` to make `a` always bigger than `b`\n        var t = a;\n        a = b;\n        b = t;\n      } else if (r === 0 || b.cmpn(1) === 0) {\n        break;\n      }\n\n      a.isub(b);\n    } while (true);\n\n    return b.iushln(shift);\n  };\n\n  // Invert number in the field F(num)\n  BN.prototype.invm = function invm (num) {\n    return this.egcd(num).a.umod(num);\n  };\n\n  BN.prototype.isEven = function isEven () {\n    return (this.words[0] & 1) === 0;\n  };\n\n  BN.prototype.isOdd = function isOdd () {\n    return (this.words[0] & 1) === 1;\n  };\n\n  // And first word and num\n  BN.prototype.andln = function andln (num) {\n    return this.words[0] & num;\n  };\n\n  // Increment at the bit position in-line\n  BN.prototype.bincn = function bincn (bit) {\n    assert(typeof bit === 'number');\n    var r = bit % 26;\n    var s = (bit - r) / 26;\n    var q = 1 << r;\n\n    // Fast case: bit is much higher than all existing words\n    if (this.length <= s) {\n      this._expand(s + 1);\n      this.words[s] |= q;\n      return this;\n    }\n\n    // Add bit and propagate, if needed\n    var carry = q;\n    for (var i = s; carry !== 0 && i < this.length; i++) {\n      var w = this.words[i] | 0;\n      w += carry;\n      carry = w >>> 26;\n      w &= 0x3ffffff;\n      this.words[i] = w;\n    }\n    if (carry !== 0) {\n      this.words[i] = carry;\n      this.length++;\n    }\n    return this;\n  };\n\n  BN.prototype.isZero = function isZero () {\n    return this.length === 1 && this.words[0] === 0;\n  };\n\n  BN.prototype.cmpn = function cmpn (num) {\n    var negative = num < 0;\n\n    if (this.negative !== 0 && !negative) return -1;\n    if (this.negative === 0 && negative) return 1;\n\n    this.strip();\n\n    var res;\n    if (this.length > 1) {\n      res = 1;\n    } else {\n      if (negative) {\n        num = -num;\n      }\n\n      assert(num <= 0x3ffffff, 'Number is too big');\n\n      var w = this.words[0] | 0;\n      res = w === num ? 0 : w < num ? -1 : 1;\n    }\n    if (this.negative !== 0) return -res | 0;\n    return res;\n  };\n\n  // Compare two numbers and return:\n  // 1 - if `this` > `num`\n  // 0 - if `this` == `num`\n  // -1 - if `this` < `num`\n  BN.prototype.cmp = function cmp (num) {\n    if (this.negative !== 0 && num.negative === 0) return -1;\n    if (this.negative === 0 && num.negative !== 0) return 1;\n\n    var res = this.ucmp(num);\n    if (this.negative !== 0) return -res | 0;\n    return res;\n  };\n\n  // Unsigned comparison\n  BN.prototype.ucmp = function ucmp (num) {\n    // At this point both numbers have the same sign\n    if (this.length > num.length) return 1;\n    if (this.length < num.length) return -1;\n\n    var res = 0;\n    for (var i = this.length - 1; i >= 0; i--) {\n      var a = this.words[i] | 0;\n      var b = num.words[i] | 0;\n\n      if (a === b) continue;\n      if (a < b) {\n        res = -1;\n      } else if (a > b) {\n        res = 1;\n      }\n      break;\n    }\n    return res;\n  };\n\n  BN.prototype.gtn = function gtn (num) {\n    return this.cmpn(num) === 1;\n  };\n\n  BN.prototype.gt = function gt (num) {\n    return this.cmp(num) === 1;\n  };\n\n  BN.prototype.gten = function gten (num) {\n    return this.cmpn(num) >= 0;\n  };\n\n  BN.prototype.gte = function gte (num) {\n    return this.cmp(num) >= 0;\n  };\n\n  BN.prototype.ltn = function ltn (num) {\n    return this.cmpn(num) === -1;\n  };\n\n  BN.prototype.lt = function lt (num) {\n    return this.cmp(num) === -1;\n  };\n\n  BN.prototype.lten = function lten (num) {\n    return this.cmpn(num) <= 0;\n  };\n\n  BN.prototype.lte = function lte (num) {\n    return this.cmp(num) <= 0;\n  };\n\n  BN.prototype.eqn = function eqn (num) {\n    return this.cmpn(num) === 0;\n  };\n\n  BN.prototype.eq = function eq (num) {\n    return this.cmp(num) === 0;\n  };\n\n  //\n  // A reduce context, could be using montgomery or something better, depending\n  // on the `m` itself.\n  //\n  BN.red = function red (num) {\n    return new Red(num);\n  };\n\n  BN.prototype.toRed = function toRed (ctx) {\n    assert(!this.red, 'Already a number in reduction context');\n    assert(this.negative === 0, 'red works only with positives');\n    return ctx.convertTo(this)._forceRed(ctx);\n  };\n\n  BN.prototype.fromRed = function fromRed () {\n    assert(this.red, 'fromRed works only with numbers in reduction context');\n    return this.red.convertFrom(this);\n  };\n\n  BN.prototype._forceRed = function _forceRed (ctx) {\n    this.red = ctx;\n    return this;\n  };\n\n  BN.prototype.forceRed = function forceRed (ctx) {\n    assert(!this.red, 'Already a number in reduction context');\n    return this._forceRed(ctx);\n  };\n\n  BN.prototype.redAdd = function redAdd (num) {\n    assert(this.red, 'redAdd works only with red numbers');\n    return this.red.add(this, num);\n  };\n\n  BN.prototype.redIAdd = function redIAdd (num) {\n    assert(this.red, 'redIAdd works only with red numbers');\n    return this.red.iadd(this, num);\n  };\n\n  BN.prototype.redSub = function redSub (num) {\n    assert(this.red, 'redSub works only with red numbers');\n    return this.red.sub(this, num);\n  };\n\n  BN.prototype.redISub = function redISub (num) {\n    assert(this.red, 'redISub works only with red numbers');\n    return this.red.isub(this, num);\n  };\n\n  BN.prototype.redShl = function redShl (num) {\n    assert(this.red, 'redShl works only with red numbers');\n    return this.red.shl(this, num);\n  };\n\n  BN.prototype.redMul = function redMul (num) {\n    assert(this.red, 'redMul works only with red numbers');\n    this.red._verify2(this, num);\n    return this.red.mul(this, num);\n  };\n\n  BN.prototype.redIMul = function redIMul (num) {\n    assert(this.red, 'redMul works only with red numbers');\n    this.red._verify2(this, num);\n    return this.red.imul(this, num);\n  };\n\n  BN.prototype.redSqr = function redSqr () {\n    assert(this.red, 'redSqr works only with red numbers');\n    this.red._verify1(this);\n    return this.red.sqr(this);\n  };\n\n  BN.prototype.redISqr = function redISqr () {\n    assert(this.red, 'redISqr works only with red numbers');\n    this.red._verify1(this);\n    return this.red.isqr(this);\n  };\n\n  // Square root over p\n  BN.prototype.redSqrt = function redSqrt () {\n    assert(this.red, 'redSqrt works only with red numbers');\n    this.red._verify1(this);\n    return this.red.sqrt(this);\n  };\n\n  BN.prototype.redInvm = function redInvm () {\n    assert(this.red, 'redInvm works only with red numbers');\n    this.red._verify1(this);\n    return this.red.invm(this);\n  };\n\n  // Return negative clone of `this` % `red modulo`\n  BN.prototype.redNeg = function redNeg () {\n    assert(this.red, 'redNeg works only with red numbers');\n    this.red._verify1(this);\n    return this.red.neg(this);\n  };\n\n  BN.prototype.redPow = function redPow (num) {\n    assert(this.red && !num.red, 'redPow(normalNum)');\n    this.red._verify1(this);\n    return this.red.pow(this, num);\n  };\n\n  // Prime numbers with efficient reduction\n  var primes = {\n    k256: null,\n    p224: null,\n    p192: null,\n    p25519: null\n  };\n\n  // Pseudo-Mersenne prime\n  function MPrime (name, p) {\n    // P = 2 ^ N - K\n    this.name = name;\n    this.p = new BN(p, 16);\n    this.n = this.p.bitLength();\n    this.k = new BN(1).iushln(this.n).isub(this.p);\n\n    this.tmp = this._tmp();\n  }\n\n  MPrime.prototype._tmp = function _tmp () {\n    var tmp = new BN(null);\n    tmp.words = new Array(Math.ceil(this.n / 13));\n    return tmp;\n  };\n\n  MPrime.prototype.ireduce = function ireduce (num) {\n    // Assumes that `num` is less than `P^2`\n    // num = HI * (2 ^ N - K) + HI * K + LO = HI * K + LO (mod P)\n    var r = num;\n    var rlen;\n\n    do {\n      this.split(r, this.tmp);\n      r = this.imulK(r);\n      r = r.iadd(this.tmp);\n      rlen = r.bitLength();\n    } while (rlen > this.n);\n\n    var cmp = rlen < this.n ? -1 : r.ucmp(this.p);\n    if (cmp === 0) {\n      r.words[0] = 0;\n      r.length = 1;\n    } else if (cmp > 0) {\n      r.isub(this.p);\n    } else {\n      if (r.strip !== undefined) {\n        // r is BN v4 instance\n        r.strip();\n      } else {\n        // r is BN v5 instance\n        r._strip();\n      }\n    }\n\n    return r;\n  };\n\n  MPrime.prototype.split = function split (input, out) {\n    input.iushrn(this.n, 0, out);\n  };\n\n  MPrime.prototype.imulK = function imulK (num) {\n    return num.imul(this.k);\n  };\n\n  function K256 () {\n    MPrime.call(\n      this,\n      'k256',\n      'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffe fffffc2f');\n  }\n  inherits(K256, MPrime);\n\n  K256.prototype.split = function split (input, output) {\n    // 256 = 9 * 26 + 22\n    var mask = 0x3fffff;\n\n    var outLen = Math.min(input.length, 9);\n    for (var i = 0; i < outLen; i++) {\n      output.words[i] = input.words[i];\n    }\n    output.length = outLen;\n\n    if (input.length <= 9) {\n      input.words[0] = 0;\n      input.length = 1;\n      return;\n    }\n\n    // Shift by 9 limbs\n    var prev = input.words[9];\n    output.words[output.length++] = prev & mask;\n\n    for (i = 10; i < input.length; i++) {\n      var next = input.words[i] | 0;\n      input.words[i - 10] = ((next & mask) << 4) | (prev >>> 22);\n      prev = next;\n    }\n    prev >>>= 22;\n    input.words[i - 10] = prev;\n    if (prev === 0 && input.length > 10) {\n      input.length -= 10;\n    } else {\n      input.length -= 9;\n    }\n  };\n\n  K256.prototype.imulK = function imulK (num) {\n    // K = 0x1000003d1 = [ 0x40, 0x3d1 ]\n    num.words[num.length] = 0;\n    num.words[num.length + 1] = 0;\n    num.length += 2;\n\n    // bounded at: 0x40 * 0x3ffffff + 0x3d0 = 0x100000390\n    var lo = 0;\n    for (var i = 0; i < num.length; i++) {\n      var w = num.words[i] | 0;\n      lo += w * 0x3d1;\n      num.words[i] = lo & 0x3ffffff;\n      lo = w * 0x40 + ((lo / 0x4000000) | 0);\n    }\n\n    // Fast length reduction\n    if (num.words[num.length - 1] === 0) {\n      num.length--;\n      if (num.words[num.length - 1] === 0) {\n        num.length--;\n      }\n    }\n    return num;\n  };\n\n  function P224 () {\n    MPrime.call(\n      this,\n      'p224',\n      'ffffffff ffffffff ffffffff ffffffff 00000000 00000000 00000001');\n  }\n  inherits(P224, MPrime);\n\n  function P192 () {\n    MPrime.call(\n      this,\n      'p192',\n      'ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff');\n  }\n  inherits(P192, MPrime);\n\n  function P25519 () {\n    // 2 ^ 255 - 19\n    MPrime.call(\n      this,\n      '25519',\n      '7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed');\n  }\n  inherits(P25519, MPrime);\n\n  P25519.prototype.imulK = function imulK (num) {\n    // K = 0x13\n    var carry = 0;\n    for (var i = 0; i < num.length; i++) {\n      var hi = (num.words[i] | 0) * 0x13 + carry;\n      var lo = hi & 0x3ffffff;\n      hi >>>= 26;\n\n      num.words[i] = lo;\n      carry = hi;\n    }\n    if (carry !== 0) {\n      num.words[num.length++] = carry;\n    }\n    return num;\n  };\n\n  // Exported mostly for testing purposes, use plain name instead\n  BN._prime = function prime (name) {\n    // Cached version of prime\n    if (primes[name]) return primes[name];\n\n    var prime;\n    if (name === 'k256') {\n      prime = new K256();\n    } else if (name === 'p224') {\n      prime = new P224();\n    } else if (name === 'p192') {\n      prime = new P192();\n    } else if (name === 'p25519') {\n      prime = new P25519();\n    } else {\n      throw new Error('Unknown prime ' + name);\n    }\n    primes[name] = prime;\n\n    return prime;\n  };\n\n  //\n  // Base reduction engine\n  //\n  function Red (m) {\n    if (typeof m === 'string') {\n      var prime = BN._prime(m);\n      this.m = prime.p;\n      this.prime = prime;\n    } else {\n      assert(m.gtn(1), 'modulus must be greater than 1');\n      this.m = m;\n      this.prime = null;\n    }\n  }\n\n  Red.prototype._verify1 = function _verify1 (a) {\n    assert(a.negative === 0, 'red works only with positives');\n    assert(a.red, 'red works only with red numbers');\n  };\n\n  Red.prototype._verify2 = function _verify2 (a, b) {\n    assert((a.negative | b.negative) === 0, 'red works only with positives');\n    assert(a.red && a.red === b.red,\n      'red works only with red numbers');\n  };\n\n  Red.prototype.imod = function imod (a) {\n    if (this.prime) return this.prime.ireduce(a)._forceRed(this);\n    return a.umod(this.m)._forceRed(this);\n  };\n\n  Red.prototype.neg = function neg (a) {\n    if (a.isZero()) {\n      return a.clone();\n    }\n\n    return this.m.sub(a)._forceRed(this);\n  };\n\n  Red.prototype.add = function add (a, b) {\n    this._verify2(a, b);\n\n    var res = a.add(b);\n    if (res.cmp(this.m) >= 0) {\n      res.isub(this.m);\n    }\n    return res._forceRed(this);\n  };\n\n  Red.prototype.iadd = function iadd (a, b) {\n    this._verify2(a, b);\n\n    var res = a.iadd(b);\n    if (res.cmp(this.m) >= 0) {\n      res.isub(this.m);\n    }\n    return res;\n  };\n\n  Red.prototype.sub = function sub (a, b) {\n    this._verify2(a, b);\n\n    var res = a.sub(b);\n    if (res.cmpn(0) < 0) {\n      res.iadd(this.m);\n    }\n    return res._forceRed(this);\n  };\n\n  Red.prototype.isub = function isub (a, b) {\n    this._verify2(a, b);\n\n    var res = a.isub(b);\n    if (res.cmpn(0) < 0) {\n      res.iadd(this.m);\n    }\n    return res;\n  };\n\n  Red.prototype.shl = function shl (a, num) {\n    this._verify1(a);\n    return this.imod(a.ushln(num));\n  };\n\n  Red.prototype.imul = function imul (a, b) {\n    this._verify2(a, b);\n    return this.imod(a.imul(b));\n  };\n\n  Red.prototype.mul = function mul (a, b) {\n    this._verify2(a, b);\n    return this.imod(a.mul(b));\n  };\n\n  Red.prototype.isqr = function isqr (a) {\n    return this.imul(a, a.clone());\n  };\n\n  Red.prototype.sqr = function sqr (a) {\n    return this.mul(a, a);\n  };\n\n  Red.prototype.sqrt = function sqrt (a) {\n    if (a.isZero()) return a.clone();\n\n    var mod3 = this.m.andln(3);\n    assert(mod3 % 2 === 1);\n\n    // Fast case\n    if (mod3 === 3) {\n      var pow = this.m.add(new BN(1)).iushrn(2);\n      return this.pow(a, pow);\n    }\n\n    // Tonelli-Shanks algorithm (Totally unoptimized and slow)\n    //\n    // Find Q and S, that Q * 2 ^ S = (P - 1)\n    var q = this.m.subn(1);\n    var s = 0;\n    while (!q.isZero() && q.andln(1) === 0) {\n      s++;\n      q.iushrn(1);\n    }\n    assert(!q.isZero());\n\n    var one = new BN(1).toRed(this);\n    var nOne = one.redNeg();\n\n    // Find quadratic non-residue\n    // NOTE: Max is such because of generalized Riemann hypothesis.\n    var lpow = this.m.subn(1).iushrn(1);\n    var z = this.m.bitLength();\n    z = new BN(2 * z * z).toRed(this);\n\n    while (this.pow(z, lpow).cmp(nOne) !== 0) {\n      z.redIAdd(nOne);\n    }\n\n    var c = this.pow(z, q);\n    var r = this.pow(a, q.addn(1).iushrn(1));\n    var t = this.pow(a, q);\n    var m = s;\n    while (t.cmp(one) !== 0) {\n      var tmp = t;\n      for (var i = 0; tmp.cmp(one) !== 0; i++) {\n        tmp = tmp.redSqr();\n      }\n      assert(i < m);\n      var b = this.pow(c, new BN(1).iushln(m - i - 1));\n\n      r = r.redMul(b);\n      c = b.redSqr();\n      t = t.redMul(c);\n      m = i;\n    }\n\n    return r;\n  };\n\n  Red.prototype.invm = function invm (a) {\n    var inv = a._invmp(this.m);\n    if (inv.negative !== 0) {\n      inv.negative = 0;\n      return this.imod(inv).redNeg();\n    } else {\n      return this.imod(inv);\n    }\n  };\n\n  Red.prototype.pow = function pow (a, num) {\n    if (num.isZero()) return new BN(1).toRed(this);\n    if (num.cmpn(1) === 0) return a.clone();\n\n    var windowSize = 4;\n    var wnd = new Array(1 << windowSize);\n    wnd[0] = new BN(1).toRed(this);\n    wnd[1] = a;\n    for (var i = 2; i < wnd.length; i++) {\n      wnd[i] = this.mul(wnd[i - 1], a);\n    }\n\n    var res = wnd[0];\n    var current = 0;\n    var currentLen = 0;\n    var start = num.bitLength() % 26;\n    if (start === 0) {\n      start = 26;\n    }\n\n    for (i = num.length - 1; i >= 0; i--) {\n      var word = num.words[i];\n      for (var j = start - 1; j >= 0; j--) {\n        var bit = (word >> j) & 1;\n        if (res !== wnd[0]) {\n          res = this.sqr(res);\n        }\n\n        if (bit === 0 && current === 0) {\n          currentLen = 0;\n          continue;\n        }\n\n        current <<= 1;\n        current |= bit;\n        currentLen++;\n        if (currentLen !== windowSize && (i !== 0 || j !== 0)) continue;\n\n        res = this.mul(res, wnd[current]);\n        currentLen = 0;\n        current = 0;\n      }\n      start = 26;\n    }\n\n    return res;\n  };\n\n  Red.prototype.convertTo = function convertTo (num) {\n    var r = num.umod(this.m);\n\n    return r === num ? r.clone() : r;\n  };\n\n  Red.prototype.convertFrom = function convertFrom (num) {\n    var res = num.clone();\n    res.red = null;\n    return res;\n  };\n\n  //\n  // Montgomery method engine\n  //\n\n  BN.mont = function mont (num) {\n    return new Mont(num);\n  };\n\n  function Mont (m) {\n    Red.call(this, m);\n\n    this.shift = this.m.bitLength();\n    if (this.shift % 26 !== 0) {\n      this.shift += 26 - (this.shift % 26);\n    }\n\n    this.r = new BN(1).iushln(this.shift);\n    this.r2 = this.imod(this.r.sqr());\n    this.rinv = this.r._invmp(this.m);\n\n    this.minv = this.rinv.mul(this.r).isubn(1).div(this.m);\n    this.minv = this.minv.umod(this.r);\n    this.minv = this.r.sub(this.minv);\n  }\n  inherits(Mont, Red);\n\n  Mont.prototype.convertTo = function convertTo (num) {\n    return this.imod(num.ushln(this.shift));\n  };\n\n  Mont.prototype.convertFrom = function convertFrom (num) {\n    var r = this.imod(num.mul(this.rinv));\n    r.red = null;\n    return r;\n  };\n\n  Mont.prototype.imul = function imul (a, b) {\n    if (a.isZero() || b.isZero()) {\n      a.words[0] = 0;\n      a.length = 1;\n      return a;\n    }\n\n    var t = a.imul(b);\n    var c = t.maskn(this.shift).mul(this.minv).imaskn(this.shift).mul(this.m);\n    var u = t.isub(c).iushrn(this.shift);\n    var res = u;\n\n    if (u.cmp(this.m) >= 0) {\n      res = u.isub(this.m);\n    } else if (u.cmpn(0) < 0) {\n      res = u.iadd(this.m);\n    }\n\n    return res._forceRed(this);\n  };\n\n  Mont.prototype.mul = function mul (a, b) {\n    if (a.isZero() || b.isZero()) return new BN(0)._forceRed(this);\n\n    var t = a.mul(b);\n    var c = t.maskn(this.shift).mul(this.minv).imaskn(this.shift).mul(this.m);\n    var u = t.isub(c).iushrn(this.shift);\n    var res = u;\n    if (u.cmp(this.m) >= 0) {\n      res = u.isub(this.m);\n    } else if (u.cmpn(0) < 0) {\n      res = u.iadd(this.m);\n    }\n\n    return res._forceRed(this);\n  };\n\n  Mont.prototype.invm = function invm (a) {\n    // (AR)^-1 * R^2 = (A^-1 * R^-1) * R^2 = A^-1 * R\n    var res = this.imod(a._invmp(this.m).mul(this.r2));\n    return res._forceRed(this);\n  };\n})(typeof module === 'undefined' || module, this);\n","// false -> Array#indexOf\n// true  -> Array#includes\nvar toIObject = require('./_to-iobject');\nvar toLength = require('./_to-length');\nvar toAbsoluteIndex = require('./_to-absolute-index');\nmodule.exports = function (IS_INCLUDES) {\n  return function ($this, el, fromIndex) {\n    var O = toIObject($this);\n    var length = toLength(O.length);\n    var index = toAbsoluteIndex(fromIndex, length);\n    var value;\n    // Array#includes uses SameValueZero equality algorithm\n    // eslint-disable-next-line no-self-compare\n    if (IS_INCLUDES && el != el) while (length > index) {\n      value = O[index++];\n      // eslint-disable-next-line no-self-compare\n      if (value != value) return true;\n    // Array#indexOf ignores holes, Array#includes - not\n    } else for (;length > index; index++) if (IS_INCLUDES || index in O) {\n      if (O[index] === el) return IS_INCLUDES || index || 0;\n    } return !IS_INCLUDES && -1;\n  };\n};\n","module.exports = { \"default\": require(\"core-js/library/fn/object/assign\"), __esModule: true };","\"use strict\";\n\nexports.__esModule = true;\n\nvar _assign = require(\"../core-js/object/assign\");\n\nvar _assign2 = _interopRequireDefault(_assign);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nexports.default = _assign2.default || function (target) {\n  for (var i = 1; i < arguments.length; i++) {\n    var source = arguments[i];\n\n    for (var key in source) {\n      if (Object.prototype.hasOwnProperty.call(source, key)) {\n        target[key] = source[key];\n      }\n    }\n  }\n\n  return target;\n};","'use strict'\n// base-x encoding / decoding\n// Copyright (c) 2018 base-x contributors\n// Copyright (c) 2014-2018 The Bitcoin Core developers (base58.cpp)\n// Distributed under the MIT software license, see the accompanying\n// file LICENSE or http://www.opensource.org/licenses/mit-license.php.\n// @ts-ignore\nvar _Buffer = require('safe-buffer').Buffer\nfunction base (ALPHABET) {\n  if (ALPHABET.length >= 255) { throw new TypeError('Alphabet too long') }\n  var BASE_MAP = new Uint8Array(256)\n  for (var j = 0; j < BASE_MAP.length; j++) {\n    BASE_MAP[j] = 255\n  }\n  for (var i = 0; i < ALPHABET.length; i++) {\n    var x = ALPHABET.charAt(i)\n    var xc = x.charCodeAt(0)\n    if (BASE_MAP[xc] !== 255) { throw new TypeError(x + ' is ambiguous') }\n    BASE_MAP[xc] = i\n  }\n  var BASE = ALPHABET.length\n  var LEADER = ALPHABET.charAt(0)\n  var FACTOR = Math.log(BASE) / Math.log(256) // log(BASE) / log(256), rounded up\n  var iFACTOR = Math.log(256) / Math.log(BASE) // log(256) / log(BASE), rounded up\n  function encode (source) {\n    if (Array.isArray(source) || source instanceof Uint8Array) { source = _Buffer.from(source) }\n    if (!_Buffer.isBuffer(source)) { throw new TypeError('Expected Buffer') }\n    if (source.length === 0) { return '' }\n        // Skip & count leading zeroes.\n    var zeroes = 0\n    var length = 0\n    var pbegin = 0\n    var pend = source.length\n    while (pbegin !== pend && source[pbegin] === 0) {\n      pbegin++\n      zeroes++\n    }\n        // Allocate enough space in big-endian base58 representation.\n    var size = ((pend - pbegin) * iFACTOR + 1) >>> 0\n    var b58 = new Uint8Array(size)\n        // Process the bytes.\n    while (pbegin !== pend) {\n      var carry = source[pbegin]\n            // Apply \"b58 = b58 * 256 + ch\".\n      var i = 0\n      for (var it1 = size - 1; (carry !== 0 || i < length) && (it1 !== -1); it1--, i++) {\n        carry += (256 * b58[it1]) >>> 0\n        b58[it1] = (carry % BASE) >>> 0\n        carry = (carry / BASE) >>> 0\n      }\n      if (carry !== 0) { throw new Error('Non-zero carry') }\n      length = i\n      pbegin++\n    }\n        // Skip leading zeroes in base58 result.\n    var it2 = size - length\n    while (it2 !== size && b58[it2] === 0) {\n      it2++\n    }\n        // Translate the result into a string.\n    var str = LEADER.repeat(zeroes)\n    for (; it2 < size; ++it2) { str += ALPHABET.charAt(b58[it2]) }\n    return str\n  }\n  function decodeUnsafe (source) {\n    if (typeof source !== 'string') { throw new TypeError('Expected String') }\n    if (source.length === 0) { return _Buffer.alloc(0) }\n    var psz = 0\n        // Skip and count leading '1's.\n    var zeroes = 0\n    var length = 0\n    while (source[psz] === LEADER) {\n      zeroes++\n      psz++\n    }\n        // Allocate enough space in big-endian base256 representation.\n    var size = (((source.length - psz) * FACTOR) + 1) >>> 0 // log(58) / log(256), rounded up.\n    var b256 = new Uint8Array(size)\n        // Process the characters.\n    while (source[psz]) {\n            // Decode character\n      var carry = BASE_MAP[source.charCodeAt(psz)]\n            // Invalid character\n      if (carry === 255) { return }\n      var i = 0\n      for (var it3 = size - 1; (carry !== 0 || i < length) && (it3 !== -1); it3--, i++) {\n        carry += (BASE * b256[it3]) >>> 0\n        b256[it3] = (carry % 256) >>> 0\n        carry = (carry / 256) >>> 0\n      }\n      if (carry !== 0) { throw new Error('Non-zero carry') }\n      length = i\n      psz++\n    }\n        // Skip leading zeroes in b256.\n    var it4 = size - length\n    while (it4 !== size && b256[it4] === 0) {\n      it4++\n    }\n    var vch = _Buffer.allocUnsafe(zeroes + (size - it4))\n    vch.fill(0x00, 0, zeroes)\n    var j = zeroes\n    while (it4 !== size) {\n      vch[j++] = b256[it4++]\n    }\n    return vch\n  }\n  function decode (string) {\n    var buffer = decodeUnsafe(string)\n    if (buffer) { return buffer }\n    throw new Error('Non-base' + BASE + ' character')\n  }\n  return {\n    encode: encode,\n    decodeUnsafe: decodeUnsafe,\n    decode: decode\n  }\n}\nmodule.exports = base\n","module.exports = { \"default\": require(\"core-js/library/fn/object/define-property\"), __esModule: true };","'use strict';\nvar $defineProperty = require('./_object-dp');\nvar createDesc = require('./_property-desc');\n\nmodule.exports = function (object, index, value) {\n  if (index in object) $defineProperty.f(object, index, createDesc(0, value));\n  else object[index] = value;\n};\n","module.exports = function (exec) {\n  try {\n    return !!exec();\n  } catch (e) {\n    return true;\n  }\n};\n","var pIE = require('./_object-pie');\nvar createDesc = require('./_property-desc');\nvar toIObject = require('./_to-iobject');\nvar toPrimitive = require('./_to-primitive');\nvar has = require('./_has');\nvar IE8_DOM_DEFINE = require('./_ie8-dom-define');\nvar gOPD = Object.getOwnPropertyDescriptor;\n\nexports.f = require('./_descriptors') ? gOPD : function getOwnPropertyDescriptor(O, P) {\n  O = toIObject(O);\n  P = toPrimitive(P, true);\n  if (IE8_DOM_DEFINE) try {\n    return gOPD(O, P);\n  } catch (e) { /* empty */ }\n  if (has(O, P)) return createDesc(!pIE.f.call(O, P), O[P]);\n};\n","var toString = {}.toString;\n\nmodule.exports = function (it) {\n  return toString.call(it).slice(8, -1);\n};\n","require('./_wks-define')('observable');\n","// 7.2.2 IsArray(argument)\nvar cof = require('./_cof');\nmodule.exports = Array.isArray || function isArray(arg) {\n  return cof(arg) == 'Array';\n};\n","require('../../modules/es6.string.iterator');\nrequire('../../modules/web.dom.iterable');\nmodule.exports = require('../../modules/_wks-ext').f('iterator');\n","var global = require('./_global');\nvar core = require('./_core');\nvar ctx = require('./_ctx');\nvar hide = require('./_hide');\nvar has = require('./_has');\nvar PROTOTYPE = 'prototype';\n\nvar $export = function (type, name, source) {\n  var IS_FORCED = type & $export.F;\n  var IS_GLOBAL = type & $export.G;\n  var IS_STATIC = type & $export.S;\n  var IS_PROTO = type & $export.P;\n  var IS_BIND = type & $export.B;\n  var IS_WRAP = type & $export.W;\n  var exports = IS_GLOBAL ? core : core[name] || (core[name] = {});\n  var expProto = exports[PROTOTYPE];\n  var target = IS_GLOBAL ? global : IS_STATIC ? global[name] : (global[name] || {})[PROTOTYPE];\n  var key, own, out;\n  if (IS_GLOBAL) source = name;\n  for (key in source) {\n    // contains in native\n    own = !IS_FORCED && target && target[key] !== undefined;\n    if (own && has(exports, key)) continue;\n    // export native or passed\n    out = own ? target[key] : source[key];\n    // prevent global pollution for namespaces\n    exports[key] = IS_GLOBAL && typeof target[key] != 'function' ? source[key]\n    // bind timers to global for call from export context\n    : IS_BIND && own ? ctx(out, global)\n    // wrap global constructors for prevent change them in library\n    : IS_WRAP && target[key] == out ? (function (C) {\n      var F = function (a, b, c) {\n        if (this instanceof C) {\n          switch (arguments.length) {\n            case 0: return new C();\n            case 1: return new C(a);\n            case 2: return new C(a, b);\n          } return new C(a, b, c);\n        } return C.apply(this, arguments);\n      };\n      F[PROTOTYPE] = C[PROTOTYPE];\n      return F;\n    // make static versions for prototype methods\n    })(out) : IS_PROTO && typeof out == 'function' ? ctx(Function.call, out) : out;\n    // export proto methods to core.%CONSTRUCTOR%.methods.%NAME%\n    if (IS_PROTO) {\n      (exports.virtual || (exports.virtual = {}))[key] = out;\n      // export proto methods to core.%CONSTRUCTOR%.prototype.%NAME%\n      if (type & $export.R && expProto && !expProto[key]) hide(expProto, key, out);\n    }\n  }\n};\n// type bitmap\n$export.F = 1;   // forced\n$export.G = 2;   // global\n$export.S = 4;   // static\n$export.P = 8;   // proto\n$export.B = 16;  // bind\n$export.W = 32;  // wrap\n$export.U = 64;  // safe\n$export.R = 128; // real proto method for `library`\nmodule.exports = $export;\n","var core = module.exports = { version: '2.6.12' };\nif (typeof __e == 'number') __e = core; // eslint-disable-line no-undef\n","\"use strict\";\n\nexports.__esModule = true;\n\nvar _defineProperty = require(\"../core-js/object/define-property\");\n\nvar _defineProperty2 = _interopRequireDefault(_defineProperty);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nexports.default = function () {\n  function defineProperties(target, props) {\n    for (var i = 0; i < props.length; i++) {\n      var descriptor = props[i];\n      descriptor.enumerable = descriptor.enumerable || false;\n      descriptor.configurable = true;\n      if (\"value\" in descriptor) descriptor.writable = true;\n      (0, _defineProperty2.default)(target, descriptor.key, descriptor);\n    }\n  }\n\n  return function (Constructor, protoProps, staticProps) {\n    if (protoProps) defineProperties(Constructor.prototype, protoProps);\n    if (staticProps) defineProperties(Constructor, staticProps);\n    return Constructor;\n  };\n}();","var shared = require('./_shared')('keys');\nvar uid = require('./_uid');\nmodule.exports = function (key) {\n  return shared[key] || (shared[key] = uid(key));\n};\n","\"use strict\";\n\nexports.__esModule = true;\n\nvar _defineProperty = require(\"../core-js/object/define-property\");\n\nvar _defineProperty2 = _interopRequireDefault(_defineProperty);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nexports.default = function (obj, key, value) {\n  if (key in obj) {\n    (0, _defineProperty2.default)(obj, key, {\n      value: value,\n      enumerable: true,\n      configurable: true,\n      writable: true\n    });\n  } else {\n    obj[key] = value;\n  }\n\n  return obj;\n};","// 19.1.2.7 / 15.2.3.4 Object.getOwnPropertyNames(O)\nvar $keys = require('./_object-keys-internal');\nvar hiddenKeys = require('./_enum-bug-keys').concat('length', 'prototype');\n\nexports.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) {\n  return $keys(O, hiddenKeys);\n};\n","require('./es6.array.iterator');\nvar global = require('./_global');\nvar hide = require('./_hide');\nvar Iterators = require('./_iterators');\nvar TO_STRING_TAG = require('./_wks')('toStringTag');\n\nvar DOMIterables = ('CSSRuleList,CSSStyleDeclaration,CSSValueList,ClientRectList,DOMRectList,DOMStringList,' +\n  'DOMTokenList,DataTransferItemList,FileList,HTMLAllCollection,HTMLCollection,HTMLFormElement,HTMLSelectElement,' +\n  'MediaList,MimeTypeArray,NamedNodeMap,NodeList,PaintRequestList,Plugin,PluginArray,SVGLengthList,SVGNumberList,' +\n  'SVGPathSegList,SVGPointList,SVGStringList,SVGTransformList,SourceBufferList,StyleSheetList,TextTrackCueList,' +\n  'TextTrackList,TouchList').split(',');\n\nfor (var i = 0; i < DOMIterables.length; i++) {\n  var NAME = DOMIterables[i];\n  var Collection = global[NAME];\n  var proto = Collection && Collection.prototype;\n  if (proto && !proto[TO_STRING_TAG]) hide(proto, TO_STRING_TAG, NAME);\n  Iterators[NAME] = Iterators.Array;\n}\n","'use strict';\nvar addToUnscopables = require('./_add-to-unscopables');\nvar step = require('./_iter-step');\nvar Iterators = require('./_iterators');\nvar toIObject = require('./_to-iobject');\n\n// 22.1.3.4 Array.prototype.entries()\n// 22.1.3.13 Array.prototype.keys()\n// 22.1.3.29 Array.prototype.values()\n// 22.1.3.30 Array.prototype[@@iterator]()\nmodule.exports = require('./_iter-define')(Array, 'Array', function (iterated, kind) {\n  this._t = toIObject(iterated); // target\n  this._i = 0;                   // next index\n  this._k = kind;                // kind\n// 22.1.5.2.1 %ArrayIteratorPrototype%.next()\n}, function () {\n  var O = this._t;\n  var kind = this._k;\n  var index = this._i++;\n  if (!O || index >= O.length) {\n    this._t = undefined;\n    return step(1);\n  }\n  if (kind == 'keys') return step(0, index);\n  if (kind == 'values') return step(0, O[index]);\n  return step(0, [index, O[index]]);\n}, 'values');\n\n// argumentsList[@@iterator] is %ArrayProto_values% (9.4.4.6, 9.4.4.7)\nIterators.Arguments = Iterators.Array;\n\naddToUnscopables('keys');\naddToUnscopables('values');\naddToUnscopables('entries');\n","'use strict';\n// ECMAScript 6 symbols shim\nvar global = require('./_global');\nvar has = require('./_has');\nvar DESCRIPTORS = require('./_descriptors');\nvar $export = require('./_export');\nvar redefine = require('./_redefine');\nvar META = require('./_meta').KEY;\nvar $fails = require('./_fails');\nvar shared = require('./_shared');\nvar setToStringTag = require('./_set-to-string-tag');\nvar uid = require('./_uid');\nvar wks = require('./_wks');\nvar wksExt = require('./_wks-ext');\nvar wksDefine = require('./_wks-define');\nvar enumKeys = require('./_enum-keys');\nvar isArray = require('./_is-array');\nvar anObject = require('./_an-object');\nvar isObject = require('./_is-object');\nvar toObject = require('./_to-object');\nvar toIObject = require('./_to-iobject');\nvar toPrimitive = require('./_to-primitive');\nvar createDesc = require('./_property-desc');\nvar _create = require('./_object-create');\nvar gOPNExt = require('./_object-gopn-ext');\nvar $GOPD = require('./_object-gopd');\nvar $GOPS = require('./_object-gops');\nvar $DP = require('./_object-dp');\nvar $keys = require('./_object-keys');\nvar gOPD = $GOPD.f;\nvar dP = $DP.f;\nvar gOPN = gOPNExt.f;\nvar $Symbol = global.Symbol;\nvar $JSON = global.JSON;\nvar _stringify = $JSON && $JSON.stringify;\nvar PROTOTYPE = 'prototype';\nvar HIDDEN = wks('_hidden');\nvar TO_PRIMITIVE = wks('toPrimitive');\nvar isEnum = {}.propertyIsEnumerable;\nvar SymbolRegistry = shared('symbol-registry');\nvar AllSymbols = shared('symbols');\nvar OPSymbols = shared('op-symbols');\nvar ObjectProto = Object[PROTOTYPE];\nvar USE_NATIVE = typeof $Symbol == 'function' && !!$GOPS.f;\nvar QObject = global.QObject;\n// Don't use setters in Qt Script, https://github.com/zloirock/core-js/issues/173\nvar setter = !QObject || !QObject[PROTOTYPE] || !QObject[PROTOTYPE].findChild;\n\n// fallback for old Android, https://code.google.com/p/v8/issues/detail?id=687\nvar setSymbolDesc = DESCRIPTORS && $fails(function () {\n  return _create(dP({}, 'a', {\n    get: function () { return dP(this, 'a', { value: 7 }).a; }\n  })).a != 7;\n}) ? function (it, key, D) {\n  var protoDesc = gOPD(ObjectProto, key);\n  if (protoDesc) delete ObjectProto[key];\n  dP(it, key, D);\n  if (protoDesc && it !== ObjectProto) dP(ObjectProto, key, protoDesc);\n} : dP;\n\nvar wrap = function (tag) {\n  var sym = AllSymbols[tag] = _create($Symbol[PROTOTYPE]);\n  sym._k = tag;\n  return sym;\n};\n\nvar isSymbol = USE_NATIVE && typeof $Symbol.iterator == 'symbol' ? function (it) {\n  return typeof it == 'symbol';\n} : function (it) {\n  return it instanceof $Symbol;\n};\n\nvar $defineProperty = function defineProperty(it, key, D) {\n  if (it === ObjectProto) $defineProperty(OPSymbols, key, D);\n  anObject(it);\n  key = toPrimitive(key, true);\n  anObject(D);\n  if (has(AllSymbols, key)) {\n    if (!D.enumerable) {\n      if (!has(it, HIDDEN)) dP(it, HIDDEN, createDesc(1, {}));\n      it[HIDDEN][key] = true;\n    } else {\n      if (has(it, HIDDEN) && it[HIDDEN][key]) it[HIDDEN][key] = false;\n      D = _create(D, { enumerable: createDesc(0, false) });\n    } return setSymbolDesc(it, key, D);\n  } return dP(it, key, D);\n};\nvar $defineProperties = function defineProperties(it, P) {\n  anObject(it);\n  var keys = enumKeys(P = toIObject(P));\n  var i = 0;\n  var l = keys.length;\n  var key;\n  while (l > i) $defineProperty(it, key = keys[i++], P[key]);\n  return it;\n};\nvar $create = function create(it, P) {\n  return P === undefined ? _create(it) : $defineProperties(_create(it), P);\n};\nvar $propertyIsEnumerable = function propertyIsEnumerable(key) {\n  var E = isEnum.call(this, key = toPrimitive(key, true));\n  if (this === ObjectProto && has(AllSymbols, key) && !has(OPSymbols, key)) return false;\n  return E || !has(this, key) || !has(AllSymbols, key) || has(this, HIDDEN) && this[HIDDEN][key] ? E : true;\n};\nvar $getOwnPropertyDescriptor = function getOwnPropertyDescriptor(it, key) {\n  it = toIObject(it);\n  key = toPrimitive(key, true);\n  if (it === ObjectProto && has(AllSymbols, key) && !has(OPSymbols, key)) return;\n  var D = gOPD(it, key);\n  if (D && has(AllSymbols, key) && !(has(it, HIDDEN) && it[HIDDEN][key])) D.enumerable = true;\n  return D;\n};\nvar $getOwnPropertyNames = function getOwnPropertyNames(it) {\n  var names = gOPN(toIObject(it));\n  var result = [];\n  var i = 0;\n  var key;\n  while (names.length > i) {\n    if (!has(AllSymbols, key = names[i++]) && key != HIDDEN && key != META) result.push(key);\n  } return result;\n};\nvar $getOwnPropertySymbols = function getOwnPropertySymbols(it) {\n  var IS_OP = it === ObjectProto;\n  var names = gOPN(IS_OP ? OPSymbols : toIObject(it));\n  var result = [];\n  var i = 0;\n  var key;\n  while (names.length > i) {\n    if (has(AllSymbols, key = names[i++]) && (IS_OP ? has(ObjectProto, key) : true)) result.push(AllSymbols[key]);\n  } return result;\n};\n\n// 19.4.1.1 Symbol([description])\nif (!USE_NATIVE) {\n  $Symbol = function Symbol() {\n    if (this instanceof $Symbol) throw TypeError('Symbol is not a constructor!');\n    var tag = uid(arguments.length > 0 ? arguments[0] : undefined);\n    var $set = function (value) {\n      if (this === ObjectProto) $set.call(OPSymbols, value);\n      if (has(this, HIDDEN) && has(this[HIDDEN], tag)) this[HIDDEN][tag] = false;\n      setSymbolDesc(this, tag, createDesc(1, value));\n    };\n    if (DESCRIPTORS && setter) setSymbolDesc(ObjectProto, tag, { configurable: true, set: $set });\n    return wrap(tag);\n  };\n  redefine($Symbol[PROTOTYPE], 'toString', function toString() {\n    return this._k;\n  });\n\n  $GOPD.f = $getOwnPropertyDescriptor;\n  $DP.f = $defineProperty;\n  require('./_object-gopn').f = gOPNExt.f = $getOwnPropertyNames;\n  require('./_object-pie').f = $propertyIsEnumerable;\n  $GOPS.f = $getOwnPropertySymbols;\n\n  if (DESCRIPTORS && !require('./_library')) {\n    redefine(ObjectProto, 'propertyIsEnumerable', $propertyIsEnumerable, true);\n  }\n\n  wksExt.f = function (name) {\n    return wrap(wks(name));\n  };\n}\n\n$export($export.G + $export.W + $export.F * !USE_NATIVE, { Symbol: $Symbol });\n\nfor (var es6Symbols = (\n  // 19.4.2.2, 19.4.2.3, 19.4.2.4, 19.4.2.6, 19.4.2.8, 19.4.2.9, 19.4.2.10, 19.4.2.11, 19.4.2.12, 19.4.2.13, 19.4.2.14\n  'hasInstance,isConcatSpreadable,iterator,match,replace,search,species,split,toPrimitive,toStringTag,unscopables'\n).split(','), j = 0; es6Symbols.length > j;)wks(es6Symbols[j++]);\n\nfor (var wellKnownSymbols = $keys(wks.store), k = 0; wellKnownSymbols.length > k;) wksDefine(wellKnownSymbols[k++]);\n\n$export($export.S + $export.F * !USE_NATIVE, 'Symbol', {\n  // 19.4.2.1 Symbol.for(key)\n  'for': function (key) {\n    return has(SymbolRegistry, key += '')\n      ? SymbolRegistry[key]\n      : SymbolRegistry[key] = $Symbol(key);\n  },\n  // 19.4.2.5 Symbol.keyFor(sym)\n  keyFor: function keyFor(sym) {\n    if (!isSymbol(sym)) throw TypeError(sym + ' is not a symbol!');\n    for (var key in SymbolRegistry) if (SymbolRegistry[key] === sym) return key;\n  },\n  useSetter: function () { setter = true; },\n  useSimple: function () { setter = false; }\n});\n\n$export($export.S + $export.F * !USE_NATIVE, 'Object', {\n  // 19.1.2.2 Object.create(O [, Properties])\n  create: $create,\n  // 19.1.2.4 Object.defineProperty(O, P, Attributes)\n  defineProperty: $defineProperty,\n  // 19.1.2.3 Object.defineProperties(O, Properties)\n  defineProperties: $defineProperties,\n  // 19.1.2.6 Object.getOwnPropertyDescriptor(O, P)\n  getOwnPropertyDescriptor: $getOwnPropertyDescriptor,\n  // 19.1.2.7 Object.getOwnPropertyNames(O)\n  getOwnPropertyNames: $getOwnPropertyNames,\n  // 19.1.2.8 Object.getOwnPropertySymbols(O)\n  getOwnPropertySymbols: $getOwnPropertySymbols\n});\n\n// Chrome 38 and 39 `Object.getOwnPropertySymbols` fails on primitives\n// https://bugs.chromium.org/p/v8/issues/detail?id=3443\nvar FAILS_ON_PRIMITIVES = $fails(function () { $GOPS.f(1); });\n\n$export($export.S + $export.F * FAILS_ON_PRIMITIVES, 'Object', {\n  getOwnPropertySymbols: function getOwnPropertySymbols(it) {\n    return $GOPS.f(toObject(it));\n  }\n});\n\n// 24.3.2 JSON.stringify(value [, replacer [, space]])\n$JSON && $export($export.S + $export.F * (!USE_NATIVE || $fails(function () {\n  var S = $Symbol();\n  // MS Edge converts symbol values to JSON as {}\n  // WebKit converts symbol values to JSON as null\n  // V8 throws on boxed symbols\n  return _stringify([S]) != '[null]' || _stringify({ a: S }) != '{}' || _stringify(Object(S)) != '{}';\n})), 'JSON', {\n  stringify: function stringify(it) {\n    var args = [it];\n    var i = 1;\n    var replacer, $replacer;\n    while (arguments.length > i) args.push(arguments[i++]);\n    $replacer = replacer = args[1];\n    if (!isObject(replacer) && it === undefined || isSymbol(it)) return; // IE8 returns string on undefined\n    if (!isArray(replacer)) replacer = function (key, value) {\n      if (typeof $replacer == 'function') value = $replacer.call(this, key, value);\n      if (!isSymbol(value)) return value;\n    };\n    args[1] = replacer;\n    return _stringify.apply($JSON, args);\n  }\n});\n\n// 19.4.3.4 Symbol.prototype[@@toPrimitive](hint)\n$Symbol[PROTOTYPE][TO_PRIMITIVE] || require('./_hide')($Symbol[PROTOTYPE], TO_PRIMITIVE, $Symbol[PROTOTYPE].valueOf);\n// 19.4.3.5 Symbol.prototype[@@toStringTag]\nsetToStringTag($Symbol, 'Symbol');\n// 20.2.1.9 Math[@@toStringTag]\nsetToStringTag(Math, 'Math', true);\n// 24.3.3 JSON[@@toStringTag]\nsetToStringTag(global.JSON, 'JSON', true);\n","// getting tag from 19.1.3.6 Object.prototype.toString()\nvar cof = require('./_cof');\nvar TAG = require('./_wks')('toStringTag');\n// ES3 wrong here\nvar ARG = cof(function () { return arguments; }()) == 'Arguments';\n\n// fallback for IE11 Script Access Denied error\nvar tryGet = function (it, key) {\n  try {\n    return it[key];\n  } catch (e) { /* empty */ }\n};\n\nmodule.exports = function (it) {\n  var O, T, B;\n  return it === undefined ? 'Undefined' : it === null ? 'Null'\n    // @@toStringTag case\n    : typeof (T = tryGet(O = Object(it), TAG)) == 'string' ? T\n    // builtinTag case\n    : ARG ? cof(O)\n    // ES3 arguments fallback\n    : (B = cof(O)) == 'Object' && typeof O.callee == 'function' ? 'Arguments' : B;\n};\n","// to indexed object, toObject with fallback for non-array-like ES3 strings\nvar IObject = require('./_iobject');\nvar defined = require('./_defined');\nmodule.exports = function (it) {\n  return IObject(defined(it));\n};\n","// check on default Array iterator\nvar Iterators = require('./_iterators');\nvar ITERATOR = require('./_wks')('iterator');\nvar ArrayProto = Array.prototype;\n\nmodule.exports = function (it) {\n  return it !== undefined && (Iterators.Array === it || ArrayProto[ITERATOR] === it);\n};\n","// 19.1.2.2 / 15.2.3.5 Object.create(O [, Properties])\nvar anObject = require('./_an-object');\nvar dPs = require('./_object-dps');\nvar enumBugKeys = require('./_enum-bug-keys');\nvar IE_PROTO = require('./_shared-key')('IE_PROTO');\nvar Empty = function () { /* empty */ };\nvar PROTOTYPE = 'prototype';\n\n// Create object with fake `null` prototype: use iframe Object with cleared prototype\nvar createDict = function () {\n  // Thrash, waste and sodomy: IE GC bug\n  var iframe = require('./_dom-create')('iframe');\n  var i = enumBugKeys.length;\n  var lt = '<';\n  var gt = '>';\n  var iframeDocument;\n  iframe.style.display = 'none';\n  require('./_html').appendChild(iframe);\n  iframe.src = 'javascript:'; // eslint-disable-line no-script-url\n  // createDict = iframe.contentWindow.Object;\n  // html.removeChild(iframe);\n  iframeDocument = iframe.contentWindow.document;\n  iframeDocument.open();\n  iframeDocument.write(lt + 'script' + gt + 'document.F=Object' + lt + '/script' + gt);\n  iframeDocument.close();\n  createDict = iframeDocument.F;\n  while (i--) delete createDict[PROTOTYPE][enumBugKeys[i]];\n  return createDict();\n};\n\nmodule.exports = Object.create || function create(O, Properties) {\n  var result;\n  if (O !== null) {\n    Empty[PROTOTYPE] = anObject(O);\n    result = new Empty();\n    Empty[PROTOTYPE] = null;\n    // add \"__proto__\" for Object.getPrototypeOf polyfill\n    result[IE_PROTO] = O;\n  } else result = createDict();\n  return Properties === undefined ? result : dPs(result, Properties);\n};\n","var isObject = require('./_is-object');\nmodule.exports = function (it) {\n  if (!isObject(it)) throw TypeError(it + ' is not an object!');\n  return it;\n};\n","module.exports = function (it) {\n  return typeof it === 'object' ? it !== null : typeof it === 'function';\n};\n","require('../modules/web.dom.iterable');\nrequire('../modules/es6.string.iterator');\nmodule.exports = require('../modules/core.is-iterable');\n","require('../modules/web.dom.iterable');\nrequire('../modules/es6.string.iterator');\nmodule.exports = require('../modules/core.get-iterator');\n","require('../../modules/es6.symbol');\nrequire('../../modules/es6.object.to-string');\nrequire('../../modules/es7.symbol.async-iterator');\nrequire('../../modules/es7.symbol.observable');\nmodule.exports = require('../../modules/_core').Symbol;\n","var dP = require('./_object-dp');\nvar anObject = require('./_an-object');\nvar getKeys = require('./_object-keys');\n\nmodule.exports = require('./_descriptors') ? Object.defineProperties : function defineProperties(O, Properties) {\n  anObject(O);\n  var keys = getKeys(Properties);\n  var length = keys.length;\n  var i = 0;\n  var P;\n  while (length > i) dP.f(O, P = keys[i++], Properties[P]);\n  return O;\n};\n","var ITERATOR = require('./_wks')('iterator');\nvar SAFE_CLOSING = false;\n\ntry {\n  var riter = [7][ITERATOR]();\n  riter['return'] = function () { SAFE_CLOSING = true; };\n  // eslint-disable-next-line no-throw-literal\n  Array.from(riter, function () { throw 2; });\n} catch (e) { /* empty */ }\n\nmodule.exports = function (exec, skipClosing) {\n  if (!skipClosing && !SAFE_CLOSING) return false;\n  var safe = false;\n  try {\n    var arr = [7];\n    var iter = arr[ITERATOR]();\n    iter.next = function () { return { done: safe = true }; };\n    arr[ITERATOR] = function () { return iter; };\n    exec(arr);\n  } catch (e) { /* empty */ }\n  return safe;\n};\n","\"use strict\";\n\nexports.__esModule = true;\n\nexports.default = function (instance, Constructor) {\n  if (!(instance instanceof Constructor)) {\n    throw new TypeError(\"Cannot call a class as a function\");\n  }\n};","module.exports = {};\n","var classof = require('./_classof');\nvar ITERATOR = require('./_wks')('iterator');\nvar Iterators = require('./_iterators');\nmodule.exports = require('./_core').isIterable = function (it) {\n  var O = Object(it);\n  return O[ITERATOR] !== undefined\n    || '@@iterator' in O\n    // eslint-disable-next-line no-prototype-builtins\n    || Iterators.hasOwnProperty(classof(O));\n};\n","var id = 0;\nvar px = Math.random();\nmodule.exports = function (key) {\n  return 'Symbol('.concat(key === undefined ? '' : key, ')_', (++id + px).toString(36));\n};\n","\"use strict\";\n\nexports.__esModule = true;\n\nexports.default = function (obj, keys) {\n  var target = {};\n\n  for (var i in obj) {\n    if (keys.indexOf(i) >= 0) continue;\n    if (!Object.prototype.hasOwnProperty.call(obj, i)) continue;\n    target[i] = obj[i];\n  }\n\n  return target;\n};",";(function (globalObject) {\r\n  'use strict';\r\n\r\n/*\r\n *      bignumber.js v9.0.2\r\n *      A JavaScript library for arbitrary-precision arithmetic.\r\n *      https://github.com/MikeMcl/bignumber.js\r\n *      Copyright (c) 2021 Michael Mclaughlin <M8ch88l@gmail.com>\r\n *      MIT Licensed.\r\n *\r\n *      BigNumber.prototype methods     |  BigNumber methods\r\n *                                      |\r\n *      absoluteValue            abs    |  clone\r\n *      comparedTo                      |  config               set\r\n *      decimalPlaces            dp     |      DECIMAL_PLACES\r\n *      dividedBy                div    |      ROUNDING_MODE\r\n *      dividedToIntegerBy       idiv   |      EXPONENTIAL_AT\r\n *      exponentiatedBy          pow    |      RANGE\r\n *      integerValue                    |      CRYPTO\r\n *      isEqualTo                eq     |      MODULO_MODE\r\n *      isFinite                        |      POW_PRECISION\r\n *      isGreaterThan            gt     |      FORMAT\r\n *      isGreaterThanOrEqualTo   gte    |      ALPHABET\r\n *      isInteger                       |  isBigNumber\r\n *      isLessThan               lt     |  maximum              max\r\n *      isLessThanOrEqualTo      lte    |  minimum              min\r\n *      isNaN                           |  random\r\n *      isNegative                      |  sum\r\n *      isPositive                      |\r\n *      isZero                          |\r\n *      minus                           |\r\n *      modulo                   mod    |\r\n *      multipliedBy             times  |\r\n *      negated                         |\r\n *      plus                            |\r\n *      precision                sd     |\r\n *      shiftedBy                       |\r\n *      squareRoot               sqrt   |\r\n *      toExponential                   |\r\n *      toFixed                         |\r\n *      toFormat                        |\r\n *      toFraction                      |\r\n *      toJSON                          |\r\n *      toNumber                        |\r\n *      toPrecision                     |\r\n *      toString                        |\r\n *      valueOf                         |\r\n *\r\n */\r\n\r\n\r\n  var BigNumber,\r\n    isNumeric = /^-?(?:\\d+(?:\\.\\d*)?|\\.\\d+)(?:e[+-]?\\d+)?$/i,\r\n    mathceil = Math.ceil,\r\n    mathfloor = Math.floor,\r\n\r\n    bignumberError = '[BigNumber Error] ',\r\n    tooManyDigits = bignumberError + 'Number primitive has more than 15 significant digits: ',\r\n\r\n    BASE = 1e14,\r\n    LOG_BASE = 14,\r\n    MAX_SAFE_INTEGER = 0x1fffffffffffff,         // 2^53 - 1\r\n    // MAX_INT32 = 0x7fffffff,                   // 2^31 - 1\r\n    POWS_TEN = [1, 10, 100, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, 1e10, 1e11, 1e12, 1e13],\r\n    SQRT_BASE = 1e7,\r\n\r\n    // EDITABLE\r\n    // The limit on the value of DECIMAL_PLACES, TO_EXP_NEG, TO_EXP_POS, MIN_EXP, MAX_EXP, and\r\n    // the arguments to toExponential, toFixed, toFormat, and toPrecision.\r\n    MAX = 1E9;                                   // 0 to MAX_INT32\r\n\r\n\r\n  /*\r\n   * Create and return a BigNumber constructor.\r\n   */\r\n  function clone(configObject) {\r\n    var div, convertBase, parseNumeric,\r\n      P = BigNumber.prototype = { constructor: BigNumber, toString: null, valueOf: null },\r\n      ONE = new BigNumber(1),\r\n\r\n\r\n      //----------------------------- EDITABLE CONFIG DEFAULTS -------------------------------\r\n\r\n\r\n      // The default values below must be integers within the inclusive ranges stated.\r\n      // The values can also be changed at run-time using BigNumber.set.\r\n\r\n      // The maximum number of decimal places for operations involving division.\r\n      DECIMAL_PLACES = 20,                     // 0 to MAX\r\n\r\n      // The rounding mode used when rounding to the above decimal places, and when using\r\n      // toExponential, toFixed, toFormat and toPrecision, and round (default value).\r\n      // UP         0 Away from zero.\r\n      // DOWN       1 Towards zero.\r\n      // CEIL       2 Towards +Infinity.\r\n      // FLOOR      3 Towards -Infinity.\r\n      // HALF_UP    4 Towards nearest neighbour. If equidistant, up.\r\n      // HALF_DOWN  5 Towards nearest neighbour. If equidistant, down.\r\n      // HALF_EVEN  6 Towards nearest neighbour. If equidistant, towards even neighbour.\r\n      // HALF_CEIL  7 Towards nearest neighbour. If equidistant, towards +Infinity.\r\n      // HALF_FLOOR 8 Towards nearest neighbour. If equidistant, towards -Infinity.\r\n      ROUNDING_MODE = 4,                       // 0 to 8\r\n\r\n      // EXPONENTIAL_AT : [TO_EXP_NEG , TO_EXP_POS]\r\n\r\n      // The exponent value at and beneath which toString returns exponential notation.\r\n      // Number type: -7\r\n      TO_EXP_NEG = -7,                         // 0 to -MAX\r\n\r\n      // The exponent value at and above which toString returns exponential notation.\r\n      // Number type: 21\r\n      TO_EXP_POS = 21,                         // 0 to MAX\r\n\r\n      // RANGE : [MIN_EXP, MAX_EXP]\r\n\r\n      // The minimum exponent value, beneath which underflow to zero occurs.\r\n      // Number type: -324  (5e-324)\r\n      MIN_EXP = -1e7,                          // -1 to -MAX\r\n\r\n      // The maximum exponent value, above which overflow to Infinity occurs.\r\n      // Number type:  308  (1.7976931348623157e+308)\r\n      // For MAX_EXP > 1e7, e.g. new BigNumber('1e100000000').plus(1) may be slow.\r\n      MAX_EXP = 1e7,                           // 1 to MAX\r\n\r\n      // Whether to use cryptographically-secure random number generation, if available.\r\n      CRYPTO = false,                          // true or false\r\n\r\n      // The modulo mode used when calculating the modulus: a mod n.\r\n      // The quotient (q = a / n) is calculated according to the corresponding rounding mode.\r\n      // The remainder (r) is calculated as: r = a - n * q.\r\n      //\r\n      // UP        0 The remainder is positive if the dividend is negative, else is negative.\r\n      // DOWN      1 The remainder has the same sign as the dividend.\r\n      //             This modulo mode is commonly known as 'truncated division' and is\r\n      //             equivalent to (a % n) in JavaScript.\r\n      // FLOOR     3 The remainder has the same sign as the divisor (Python %).\r\n      // HALF_EVEN 6 This modulo mode implements the IEEE 754 remainder function.\r\n      // EUCLID    9 Euclidian division. q = sign(n) * floor(a / abs(n)).\r\n      //             The remainder is always positive.\r\n      //\r\n      // The truncated division, floored division, Euclidian division and IEEE 754 remainder\r\n      // modes are commonly used for the modulus operation.\r\n      // Although the other rounding modes can also be used, they may not give useful results.\r\n      MODULO_MODE = 1,                         // 0 to 9\r\n\r\n      // The maximum number of significant digits of the result of the exponentiatedBy operation.\r\n      // If POW_PRECISION is 0, there will be unlimited significant digits.\r\n      POW_PRECISION = 0,                       // 0 to MAX\r\n\r\n      // The format specification used by the BigNumber.prototype.toFormat method.\r\n      FORMAT = {\r\n        prefix: '',\r\n        groupSize: 3,\r\n        secondaryGroupSize: 0,\r\n        groupSeparator: ',',\r\n        decimalSeparator: '.',\r\n        fractionGroupSize: 0,\r\n        fractionGroupSeparator: '\\xA0',        // non-breaking space\r\n        suffix: ''\r\n      },\r\n\r\n      // The alphabet used for base conversion. It must be at least 2 characters long, with no '+',\r\n      // '-', '.', whitespace, or repeated character.\r\n      // '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ$_'\r\n      ALPHABET = '0123456789abcdefghijklmnopqrstuvwxyz',\r\n      alphabetHasNormalDecimalDigits = true;\r\n\r\n\r\n    //------------------------------------------------------------------------------------------\r\n\r\n\r\n    // CONSTRUCTOR\r\n\r\n\r\n    /*\r\n     * The BigNumber constructor and exported function.\r\n     * Create and return a new instance of a BigNumber object.\r\n     *\r\n     * v {number|string|BigNumber} A numeric value.\r\n     * [b] {number} The base of v. Integer, 2 to ALPHABET.length inclusive.\r\n     */\r\n    function BigNumber(v, b) {\r\n      var alphabet, c, caseChanged, e, i, isNum, len, str,\r\n        x = this;\r\n\r\n      // Enable constructor call without `new`.\r\n      if (!(x instanceof BigNumber)) return new BigNumber(v, b);\r\n\r\n      if (b == null) {\r\n\r\n        if (v && v._isBigNumber === true) {\r\n          x.s = v.s;\r\n\r\n          if (!v.c || v.e > MAX_EXP) {\r\n            x.c = x.e = null;\r\n          } else if (v.e < MIN_EXP) {\r\n            x.c = [x.e = 0];\r\n          } else {\r\n            x.e = v.e;\r\n            x.c = v.c.slice();\r\n          }\r\n\r\n          return;\r\n        }\r\n\r\n        if ((isNum = typeof v == 'number') && v * 0 == 0) {\r\n\r\n          // Use `1 / n` to handle minus zero also.\r\n          x.s = 1 / v < 0 ? (v = -v, -1) : 1;\r\n\r\n          // Fast path for integers, where n < 2147483648 (2**31).\r\n          if (v === ~~v) {\r\n            for (e = 0, i = v; i >= 10; i /= 10, e++);\r\n\r\n            if (e > MAX_EXP) {\r\n              x.c = x.e = null;\r\n            } else {\r\n              x.e = e;\r\n              x.c = [v];\r\n            }\r\n\r\n            return;\r\n          }\r\n\r\n          str = String(v);\r\n        } else {\r\n\r\n          if (!isNumeric.test(str = String(v))) return parseNumeric(x, str, isNum);\r\n\r\n          x.s = str.charCodeAt(0) == 45 ? (str = str.slice(1), -1) : 1;\r\n        }\r\n\r\n        // Decimal point?\r\n        if ((e = str.indexOf('.')) > -1) str = str.replace('.', '');\r\n\r\n        // Exponential form?\r\n        if ((i = str.search(/e/i)) > 0) {\r\n\r\n          // Determine exponent.\r\n          if (e < 0) e = i;\r\n          e += +str.slice(i + 1);\r\n          str = str.substring(0, i);\r\n        } else if (e < 0) {\r\n\r\n          // Integer.\r\n          e = str.length;\r\n        }\r\n\r\n      } else {\r\n\r\n        // '[BigNumber Error] Base {not a primitive number|not an integer|out of range}: {b}'\r\n        intCheck(b, 2, ALPHABET.length, 'Base');\r\n\r\n        // Allow exponential notation to be used with base 10 argument, while\r\n        // also rounding to DECIMAL_PLACES as with other bases.\r\n        if (b == 10 && alphabetHasNormalDecimalDigits) {\r\n          x = new BigNumber(v);\r\n          return round(x, DECIMAL_PLACES + x.e + 1, ROUNDING_MODE);\r\n        }\r\n\r\n        str = String(v);\r\n\r\n        if (isNum = typeof v == 'number') {\r\n\r\n          // Avoid potential interpretation of Infinity and NaN as base 44+ values.\r\n          if (v * 0 != 0) return parseNumeric(x, str, isNum, b);\r\n\r\n          x.s = 1 / v < 0 ? (str = str.slice(1), -1) : 1;\r\n\r\n          // '[BigNumber Error] Number primitive has more than 15 significant digits: {n}'\r\n          if (BigNumber.DEBUG && str.replace(/^0\\.0*|\\./, '').length > 15) {\r\n            throw Error\r\n             (tooManyDigits + v);\r\n          }\r\n        } else {\r\n          x.s = str.charCodeAt(0) === 45 ? (str = str.slice(1), -1) : 1;\r\n        }\r\n\r\n        alphabet = ALPHABET.slice(0, b);\r\n        e = i = 0;\r\n\r\n        // Check that str is a valid base b number.\r\n        // Don't use RegExp, so alphabet can contain special characters.\r\n        for (len = str.length; i < len; i++) {\r\n          if (alphabet.indexOf(c = str.charAt(i)) < 0) {\r\n            if (c == '.') {\r\n\r\n              // If '.' is not the first character and it has not be found before.\r\n              if (i > e) {\r\n                e = len;\r\n                continue;\r\n              }\r\n            } else if (!caseChanged) {\r\n\r\n              // Allow e.g. hexadecimal 'FF' as well as 'ff'.\r\n              if (str == str.toUpperCase() && (str = str.toLowerCase()) ||\r\n                  str == str.toLowerCase() && (str = str.toUpperCase())) {\r\n                caseChanged = true;\r\n                i = -1;\r\n                e = 0;\r\n                continue;\r\n              }\r\n            }\r\n\r\n            return parseNumeric(x, String(v), isNum, b);\r\n          }\r\n        }\r\n\r\n        // Prevent later check for length on converted number.\r\n        isNum = false;\r\n        str = convertBase(str, b, 10, x.s);\r\n\r\n        // Decimal point?\r\n        if ((e = str.indexOf('.')) > -1) str = str.replace('.', '');\r\n        else e = str.length;\r\n      }\r\n\r\n      // Determine leading zeros.\r\n      for (i = 0; str.charCodeAt(i) === 48; i++);\r\n\r\n      // Determine trailing zeros.\r\n      for (len = str.length; str.charCodeAt(--len) === 48;);\r\n\r\n      if (str = str.slice(i, ++len)) {\r\n        len -= i;\r\n\r\n        // '[BigNumber Error] Number primitive has more than 15 significant digits: {n}'\r\n        if (isNum && BigNumber.DEBUG &&\r\n          len > 15 && (v > MAX_SAFE_INTEGER || v !== mathfloor(v))) {\r\n            throw Error\r\n             (tooManyDigits + (x.s * v));\r\n        }\r\n\r\n         // Overflow?\r\n        if ((e = e - i - 1) > MAX_EXP) {\r\n\r\n          // Infinity.\r\n          x.c = x.e = null;\r\n\r\n        // Underflow?\r\n        } else if (e < MIN_EXP) {\r\n\r\n          // Zero.\r\n          x.c = [x.e = 0];\r\n        } else {\r\n          x.e = e;\r\n          x.c = [];\r\n\r\n          // Transform base\r\n\r\n          // e is the base 10 exponent.\r\n          // i is where to slice str to get the first element of the coefficient array.\r\n          i = (e + 1) % LOG_BASE;\r\n          if (e < 0) i += LOG_BASE;  // i < 1\r\n\r\n          if (i < len) {\r\n            if (i) x.c.push(+str.slice(0, i));\r\n\r\n            for (len -= LOG_BASE; i < len;) {\r\n              x.c.push(+str.slice(i, i += LOG_BASE));\r\n            }\r\n\r\n            i = LOG_BASE - (str = str.slice(i)).length;\r\n          } else {\r\n            i -= len;\r\n          }\r\n\r\n          for (; i--; str += '0');\r\n          x.c.push(+str);\r\n        }\r\n      } else {\r\n\r\n        // Zero.\r\n        x.c = [x.e = 0];\r\n      }\r\n    }\r\n\r\n\r\n    // CONSTRUCTOR PROPERTIES\r\n\r\n\r\n    BigNumber.clone = clone;\r\n\r\n    BigNumber.ROUND_UP = 0;\r\n    BigNumber.ROUND_DOWN = 1;\r\n    BigNumber.ROUND_CEIL = 2;\r\n    BigNumber.ROUND_FLOOR = 3;\r\n    BigNumber.ROUND_HALF_UP = 4;\r\n    BigNumber.ROUND_HALF_DOWN = 5;\r\n    BigNumber.ROUND_HALF_EVEN = 6;\r\n    BigNumber.ROUND_HALF_CEIL = 7;\r\n    BigNumber.ROUND_HALF_FLOOR = 8;\r\n    BigNumber.EUCLID = 9;\r\n\r\n\r\n    /*\r\n     * Configure infrequently-changing library-wide settings.\r\n     *\r\n     * Accept an object with the following optional properties (if the value of a property is\r\n     * a number, it must be an integer within the inclusive range stated):\r\n     *\r\n     *   DECIMAL_PLACES   {number}           0 to MAX\r\n     *   ROUNDING_MODE    {number}           0 to 8\r\n     *   EXPONENTIAL_AT   {number|number[]}  -MAX to MAX  or  [-MAX to 0, 0 to MAX]\r\n     *   RANGE            {number|number[]}  -MAX to MAX (not zero)  or  [-MAX to -1, 1 to MAX]\r\n     *   CRYPTO           {boolean}          true or false\r\n     *   MODULO_MODE      {number}           0 to 9\r\n     *   POW_PRECISION       {number}           0 to MAX\r\n     *   ALPHABET         {string}           A string of two or more unique characters which does\r\n     *                                       not contain '.'.\r\n     *   FORMAT           {object}           An object with some of the following properties:\r\n     *     prefix                 {string}\r\n     *     groupSize              {number}\r\n     *     secondaryGroupSize     {number}\r\n     *     groupSeparator         {string}\r\n     *     decimalSeparator       {string}\r\n     *     fractionGroupSize      {number}\r\n     *     fractionGroupSeparator {string}\r\n     *     suffix                 {string}\r\n     *\r\n     * (The values assigned to the above FORMAT object properties are not checked for validity.)\r\n     *\r\n     * E.g.\r\n     * BigNumber.config({ DECIMAL_PLACES : 20, ROUNDING_MODE : 4 })\r\n     *\r\n     * Ignore properties/parameters set to null or undefined, except for ALPHABET.\r\n     *\r\n     * Return an object with the properties current values.\r\n     */\r\n    BigNumber.config = BigNumber.set = function (obj) {\r\n      var p, v;\r\n\r\n      if (obj != null) {\r\n\r\n        if (typeof obj == 'object') {\r\n\r\n          // DECIMAL_PLACES {number} Integer, 0 to MAX inclusive.\r\n          // '[BigNumber Error] DECIMAL_PLACES {not a primitive number|not an integer|out of range}: {v}'\r\n          if (obj.hasOwnProperty(p = 'DECIMAL_PLACES')) {\r\n            v = obj[p];\r\n            intCheck(v, 0, MAX, p);\r\n            DECIMAL_PLACES = v;\r\n          }\r\n\r\n          // ROUNDING_MODE {number} Integer, 0 to 8 inclusive.\r\n          // '[BigNumber Error] ROUNDING_MODE {not a primitive number|not an integer|out of range}: {v}'\r\n          if (obj.hasOwnProperty(p = 'ROUNDING_MODE')) {\r\n            v = obj[p];\r\n            intCheck(v, 0, 8, p);\r\n            ROUNDING_MODE = v;\r\n          }\r\n\r\n          // EXPONENTIAL_AT {number|number[]}\r\n          // Integer, -MAX to MAX inclusive or\r\n          // [integer -MAX to 0 inclusive, 0 to MAX inclusive].\r\n          // '[BigNumber Error] EXPONENTIAL_AT {not a primitive number|not an integer|out of range}: {v}'\r\n          if (obj.hasOwnProperty(p = 'EXPONENTIAL_AT')) {\r\n            v = obj[p];\r\n            if (v && v.pop) {\r\n              intCheck(v[0], -MAX, 0, p);\r\n              intCheck(v[1], 0, MAX, p);\r\n              TO_EXP_NEG = v[0];\r\n              TO_EXP_POS = v[1];\r\n            } else {\r\n              intCheck(v, -MAX, MAX, p);\r\n              TO_EXP_NEG = -(TO_EXP_POS = v < 0 ? -v : v);\r\n            }\r\n          }\r\n\r\n          // RANGE {number|number[]} Non-zero integer, -MAX to MAX inclusive or\r\n          // [integer -MAX to -1 inclusive, integer 1 to MAX inclusive].\r\n          // '[BigNumber Error] RANGE {not a primitive number|not an integer|out of range|cannot be zero}: {v}'\r\n          if (obj.hasOwnProperty(p = 'RANGE')) {\r\n            v = obj[p];\r\n            if (v && v.pop) {\r\n              intCheck(v[0], -MAX, -1, p);\r\n              intCheck(v[1], 1, MAX, p);\r\n              MIN_EXP = v[0];\r\n              MAX_EXP = v[1];\r\n            } else {\r\n              intCheck(v, -MAX, MAX, p);\r\n              if (v) {\r\n                MIN_EXP = -(MAX_EXP = v < 0 ? -v : v);\r\n              } else {\r\n                throw Error\r\n                 (bignumberError + p + ' cannot be zero: ' + v);\r\n              }\r\n            }\r\n          }\r\n\r\n          // CRYPTO {boolean} true or false.\r\n          // '[BigNumber Error] CRYPTO not true or false: {v}'\r\n          // '[BigNumber Error] crypto unavailable'\r\n          if (obj.hasOwnProperty(p = 'CRYPTO')) {\r\n            v = obj[p];\r\n            if (v === !!v) {\r\n              if (v) {\r\n                if (typeof crypto != 'undefined' && crypto &&\r\n                 (crypto.getRandomValues || crypto.randomBytes)) {\r\n                  CRYPTO = v;\r\n                } else {\r\n                  CRYPTO = !v;\r\n                  throw Error\r\n                   (bignumberError + 'crypto unavailable');\r\n                }\r\n              } else {\r\n                CRYPTO = v;\r\n              }\r\n            } else {\r\n              throw Error\r\n               (bignumberError + p + ' not true or false: ' + v);\r\n            }\r\n          }\r\n\r\n          // MODULO_MODE {number} Integer, 0 to 9 inclusive.\r\n          // '[BigNumber Error] MODULO_MODE {not a primitive number|not an integer|out of range}: {v}'\r\n          if (obj.hasOwnProperty(p = 'MODULO_MODE')) {\r\n            v = obj[p];\r\n            intCheck(v, 0, 9, p);\r\n            MODULO_MODE = v;\r\n          }\r\n\r\n          // POW_PRECISION {number} Integer, 0 to MAX inclusive.\r\n          // '[BigNumber Error] POW_PRECISION {not a primitive number|not an integer|out of range}: {v}'\r\n          if (obj.hasOwnProperty(p = 'POW_PRECISION')) {\r\n            v = obj[p];\r\n            intCheck(v, 0, MAX, p);\r\n            POW_PRECISION = v;\r\n          }\r\n\r\n          // FORMAT {object}\r\n          // '[BigNumber Error] FORMAT not an object: {v}'\r\n          if (obj.hasOwnProperty(p = 'FORMAT')) {\r\n            v = obj[p];\r\n            if (typeof v == 'object') FORMAT = v;\r\n            else throw Error\r\n             (bignumberError + p + ' not an object: ' + v);\r\n          }\r\n\r\n          // ALPHABET {string}\r\n          // '[BigNumber Error] ALPHABET invalid: {v}'\r\n          if (obj.hasOwnProperty(p = 'ALPHABET')) {\r\n            v = obj[p];\r\n\r\n            // Disallow if less than two characters,\r\n            // or if it contains '+', '-', '.', whitespace, or a repeated character.\r\n            if (typeof v == 'string' && !/^.?$|[+\\-.\\s]|(.).*\\1/.test(v)) {\r\n              alphabetHasNormalDecimalDigits = v.slice(0, 10) == '0123456789';\r\n              ALPHABET = v;\r\n            } else {\r\n              throw Error\r\n               (bignumberError + p + ' invalid: ' + v);\r\n            }\r\n          }\r\n\r\n        } else {\r\n\r\n          // '[BigNumber Error] Object expected: {v}'\r\n          throw Error\r\n           (bignumberError + 'Object expected: ' + obj);\r\n        }\r\n      }\r\n\r\n      return {\r\n        DECIMAL_PLACES: DECIMAL_PLACES,\r\n        ROUNDING_MODE: ROUNDING_MODE,\r\n        EXPONENTIAL_AT: [TO_EXP_NEG, TO_EXP_POS],\r\n        RANGE: [MIN_EXP, MAX_EXP],\r\n        CRYPTO: CRYPTO,\r\n        MODULO_MODE: MODULO_MODE,\r\n        POW_PRECISION: POW_PRECISION,\r\n        FORMAT: FORMAT,\r\n        ALPHABET: ALPHABET\r\n      };\r\n    };\r\n\r\n\r\n    /*\r\n     * Return true if v is a BigNumber instance, otherwise return false.\r\n     *\r\n     * If BigNumber.DEBUG is true, throw if a BigNumber instance is not well-formed.\r\n     *\r\n     * v {any}\r\n     *\r\n     * '[BigNumber Error] Invalid BigNumber: {v}'\r\n     */\r\n    BigNumber.isBigNumber = function (v) {\r\n      if (!v || v._isBigNumber !== true) return false;\r\n      if (!BigNumber.DEBUG) return true;\r\n\r\n      var i, n,\r\n        c = v.c,\r\n        e = v.e,\r\n        s = v.s;\r\n\r\n      out: if ({}.toString.call(c) == '[object Array]') {\r\n\r\n        if ((s === 1 || s === -1) && e >= -MAX && e <= MAX && e === mathfloor(e)) {\r\n\r\n          // If the first element is zero, the BigNumber value must be zero.\r\n          if (c[0] === 0) {\r\n            if (e === 0 && c.length === 1) return true;\r\n            break out;\r\n          }\r\n\r\n          // Calculate number of digits that c[0] should have, based on the exponent.\r\n          i = (e + 1) % LOG_BASE;\r\n          if (i < 1) i += LOG_BASE;\r\n\r\n          // Calculate number of digits of c[0].\r\n          //if (Math.ceil(Math.log(c[0] + 1) / Math.LN10) == i) {\r\n          if (String(c[0]).length == i) {\r\n\r\n            for (i = 0; i < c.length; i++) {\r\n              n = c[i];\r\n              if (n < 0 || n >= BASE || n !== mathfloor(n)) break out;\r\n            }\r\n\r\n            // Last element cannot be zero, unless it is the only element.\r\n            if (n !== 0) return true;\r\n          }\r\n        }\r\n\r\n      // Infinity/NaN\r\n      } else if (c === null && e === null && (s === null || s === 1 || s === -1)) {\r\n        return true;\r\n      }\r\n\r\n      throw Error\r\n        (bignumberError + 'Invalid BigNumber: ' + v);\r\n    };\r\n\r\n\r\n    /*\r\n     * Return a new BigNumber whose value is the maximum of the arguments.\r\n     *\r\n     * arguments {number|string|BigNumber}\r\n     */\r\n    BigNumber.maximum = BigNumber.max = function () {\r\n      return maxOrMin(arguments, P.lt);\r\n    };\r\n\r\n\r\n    /*\r\n     * Return a new BigNumber whose value is the minimum of the arguments.\r\n     *\r\n     * arguments {number|string|BigNumber}\r\n     */\r\n    BigNumber.minimum = BigNumber.min = function () {\r\n      return maxOrMin(arguments, P.gt);\r\n    };\r\n\r\n\r\n    /*\r\n     * Return a new BigNumber with a random value equal to or greater than 0 and less than 1,\r\n     * and with dp, or DECIMAL_PLACES if dp is omitted, decimal places (or less if trailing\r\n     * zeros are produced).\r\n     *\r\n     * [dp] {number} Decimal places. Integer, 0 to MAX inclusive.\r\n     *\r\n     * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {dp}'\r\n     * '[BigNumber Error] crypto unavailable'\r\n     */\r\n    BigNumber.random = (function () {\r\n      var pow2_53 = 0x20000000000000;\r\n\r\n      // Return a 53 bit integer n, where 0 <= n < 9007199254740992.\r\n      // Check if Math.random() produces more than 32 bits of randomness.\r\n      // If it does, assume at least 53 bits are produced, otherwise assume at least 30 bits.\r\n      // 0x40000000 is 2^30, 0x800000 is 2^23, 0x1fffff is 2^21 - 1.\r\n      var random53bitInt = (Math.random() * pow2_53) & 0x1fffff\r\n       ? function () { return mathfloor(Math.random() * pow2_53); }\r\n       : function () { return ((Math.random() * 0x40000000 | 0) * 0x800000) +\r\n         (Math.random() * 0x800000 | 0); };\r\n\r\n      return function (dp) {\r\n        var a, b, e, k, v,\r\n          i = 0,\r\n          c = [],\r\n          rand = new BigNumber(ONE);\r\n\r\n        if (dp == null) dp = DECIMAL_PLACES;\r\n        else intCheck(dp, 0, MAX);\r\n\r\n        k = mathceil(dp / LOG_BASE);\r\n\r\n        if (CRYPTO) {\r\n\r\n          // Browsers supporting crypto.getRandomValues.\r\n          if (crypto.getRandomValues) {\r\n\r\n            a = crypto.getRandomValues(new Uint32Array(k *= 2));\r\n\r\n            for (; i < k;) {\r\n\r\n              // 53 bits:\r\n              // ((Math.pow(2, 32) - 1) * Math.pow(2, 21)).toString(2)\r\n              // 11111 11111111 11111111 11111111 11100000 00000000 00000000\r\n              // ((Math.pow(2, 32) - 1) >>> 11).toString(2)\r\n              //                                     11111 11111111 11111111\r\n              // 0x20000 is 2^21.\r\n              v = a[i] * 0x20000 + (a[i + 1] >>> 11);\r\n\r\n              // Rejection sampling:\r\n              // 0 <= v < 9007199254740992\r\n              // Probability that v >= 9e15, is\r\n              // 7199254740992 / 9007199254740992 ~= 0.0008, i.e. 1 in 1251\r\n              if (v >= 9e15) {\r\n                b = crypto.getRandomValues(new Uint32Array(2));\r\n                a[i] = b[0];\r\n                a[i + 1] = b[1];\r\n              } else {\r\n\r\n                // 0 <= v <= 8999999999999999\r\n                // 0 <= (v % 1e14) <= 99999999999999\r\n                c.push(v % 1e14);\r\n                i += 2;\r\n              }\r\n            }\r\n            i = k / 2;\r\n\r\n          // Node.js supporting crypto.randomBytes.\r\n          } else if (crypto.randomBytes) {\r\n\r\n            // buffer\r\n            a = crypto.randomBytes(k *= 7);\r\n\r\n            for (; i < k;) {\r\n\r\n              // 0x1000000000000 is 2^48, 0x10000000000 is 2^40\r\n              // 0x100000000 is 2^32, 0x1000000 is 2^24\r\n              // 11111 11111111 11111111 11111111 11111111 11111111 11111111\r\n              // 0 <= v < 9007199254740992\r\n              v = ((a[i] & 31) * 0x1000000000000) + (a[i + 1] * 0x10000000000) +\r\n                 (a[i + 2] * 0x100000000) + (a[i + 3] * 0x1000000) +\r\n                 (a[i + 4] << 16) + (a[i + 5] << 8) + a[i + 6];\r\n\r\n              if (v >= 9e15) {\r\n                crypto.randomBytes(7).copy(a, i);\r\n              } else {\r\n\r\n                // 0 <= (v % 1e14) <= 99999999999999\r\n                c.push(v % 1e14);\r\n                i += 7;\r\n              }\r\n            }\r\n            i = k / 7;\r\n          } else {\r\n            CRYPTO = false;\r\n            throw Error\r\n             (bignumberError + 'crypto unavailable');\r\n          }\r\n        }\r\n\r\n        // Use Math.random.\r\n        if (!CRYPTO) {\r\n\r\n          for (; i < k;) {\r\n            v = random53bitInt();\r\n            if (v < 9e15) c[i++] = v % 1e14;\r\n          }\r\n        }\r\n\r\n        k = c[--i];\r\n        dp %= LOG_BASE;\r\n\r\n        // Convert trailing digits to zeros according to dp.\r\n        if (k && dp) {\r\n          v = POWS_TEN[LOG_BASE - dp];\r\n          c[i] = mathfloor(k / v) * v;\r\n        }\r\n\r\n        // Remove trailing elements which are zero.\r\n        for (; c[i] === 0; c.pop(), i--);\r\n\r\n        // Zero?\r\n        if (i < 0) {\r\n          c = [e = 0];\r\n        } else {\r\n\r\n          // Remove leading elements which are zero and adjust exponent accordingly.\r\n          for (e = -1 ; c[0] === 0; c.splice(0, 1), e -= LOG_BASE);\r\n\r\n          // Count the digits of the first element of c to determine leading zeros, and...\r\n          for (i = 1, v = c[0]; v >= 10; v /= 10, i++);\r\n\r\n          // adjust the exponent accordingly.\r\n          if (i < LOG_BASE) e -= LOG_BASE - i;\r\n        }\r\n\r\n        rand.e = e;\r\n        rand.c = c;\r\n        return rand;\r\n      };\r\n    })();\r\n\r\n\r\n    /*\r\n     * Return a BigNumber whose value is the sum of the arguments.\r\n     *\r\n     * arguments {number|string|BigNumber}\r\n     */\r\n    BigNumber.sum = function () {\r\n      var i = 1,\r\n        args = arguments,\r\n        sum = new BigNumber(args[0]);\r\n      for (; i < args.length;) sum = sum.plus(args[i++]);\r\n      return sum;\r\n    };\r\n\r\n\r\n    // PRIVATE FUNCTIONS\r\n\r\n\r\n    // Called by BigNumber and BigNumber.prototype.toString.\r\n    convertBase = (function () {\r\n      var decimal = '0123456789';\r\n\r\n      /*\r\n       * Convert string of baseIn to an array of numbers of baseOut.\r\n       * Eg. toBaseOut('255', 10, 16) returns [15, 15].\r\n       * Eg. toBaseOut('ff', 16, 10) returns [2, 5, 5].\r\n       */\r\n      function toBaseOut(str, baseIn, baseOut, alphabet) {\r\n        var j,\r\n          arr = [0],\r\n          arrL,\r\n          i = 0,\r\n          len = str.length;\r\n\r\n        for (; i < len;) {\r\n          for (arrL = arr.length; arrL--; arr[arrL] *= baseIn);\r\n\r\n          arr[0] += alphabet.indexOf(str.charAt(i++));\r\n\r\n          for (j = 0; j < arr.length; j++) {\r\n\r\n            if (arr[j] > baseOut - 1) {\r\n              if (arr[j + 1] == null) arr[j + 1] = 0;\r\n              arr[j + 1] += arr[j] / baseOut | 0;\r\n              arr[j] %= baseOut;\r\n            }\r\n          }\r\n        }\r\n\r\n        return arr.reverse();\r\n      }\r\n\r\n      // Convert a numeric string of baseIn to a numeric string of baseOut.\r\n      // If the caller is toString, we are converting from base 10 to baseOut.\r\n      // If the caller is BigNumber, we are converting from baseIn to base 10.\r\n      return function (str, baseIn, baseOut, sign, callerIsToString) {\r\n        var alphabet, d, e, k, r, x, xc, y,\r\n          i = str.indexOf('.'),\r\n          dp = DECIMAL_PLACES,\r\n          rm = ROUNDING_MODE;\r\n\r\n        // Non-integer.\r\n        if (i >= 0) {\r\n          k = POW_PRECISION;\r\n\r\n          // Unlimited precision.\r\n          POW_PRECISION = 0;\r\n          str = str.replace('.', '');\r\n          y = new BigNumber(baseIn);\r\n          x = y.pow(str.length - i);\r\n          POW_PRECISION = k;\r\n\r\n          // Convert str as if an integer, then restore the fraction part by dividing the\r\n          // result by its base raised to a power.\r\n\r\n          y.c = toBaseOut(toFixedPoint(coeffToString(x.c), x.e, '0'),\r\n           10, baseOut, decimal);\r\n          y.e = y.c.length;\r\n        }\r\n\r\n        // Convert the number as integer.\r\n\r\n        xc = toBaseOut(str, baseIn, baseOut, callerIsToString\r\n         ? (alphabet = ALPHABET, decimal)\r\n         : (alphabet = decimal, ALPHABET));\r\n\r\n        // xc now represents str as an integer and converted to baseOut. e is the exponent.\r\n        e = k = xc.length;\r\n\r\n        // Remove trailing zeros.\r\n        for (; xc[--k] == 0; xc.pop());\r\n\r\n        // Zero?\r\n        if (!xc[0]) return alphabet.charAt(0);\r\n\r\n        // Does str represent an integer? If so, no need for the division.\r\n        if (i < 0) {\r\n          --e;\r\n        } else {\r\n          x.c = xc;\r\n          x.e = e;\r\n\r\n          // The sign is needed for correct rounding.\r\n          x.s = sign;\r\n          x = div(x, y, dp, rm, baseOut);\r\n          xc = x.c;\r\n          r = x.r;\r\n          e = x.e;\r\n        }\r\n\r\n        // xc now represents str converted to baseOut.\r\n\r\n        // THe index of the rounding digit.\r\n        d = e + dp + 1;\r\n\r\n        // The rounding digit: the digit to the right of the digit that may be rounded up.\r\n        i = xc[d];\r\n\r\n        // Look at the rounding digits and mode to determine whether to round up.\r\n\r\n        k = baseOut / 2;\r\n        r = r || d < 0 || xc[d + 1] != null;\r\n\r\n        r = rm < 4 ? (i != null || r) && (rm == 0 || rm == (x.s < 0 ? 3 : 2))\r\n              : i > k || i == k &&(rm == 4 || r || rm == 6 && xc[d - 1] & 1 ||\r\n               rm == (x.s < 0 ? 8 : 7));\r\n\r\n        // If the index of the rounding digit is not greater than zero, or xc represents\r\n        // zero, then the result of the base conversion is zero or, if rounding up, a value\r\n        // such as 0.00001.\r\n        if (d < 1 || !xc[0]) {\r\n\r\n          // 1^-dp or 0\r\n          str = r ? toFixedPoint(alphabet.charAt(1), -dp, alphabet.charAt(0)) : alphabet.charAt(0);\r\n        } else {\r\n\r\n          // Truncate xc to the required number of decimal places.\r\n          xc.length = d;\r\n\r\n          // Round up?\r\n          if (r) {\r\n\r\n            // Rounding up may mean the previous digit has to be rounded up and so on.\r\n            for (--baseOut; ++xc[--d] > baseOut;) {\r\n              xc[d] = 0;\r\n\r\n              if (!d) {\r\n                ++e;\r\n                xc = [1].concat(xc);\r\n              }\r\n            }\r\n          }\r\n\r\n          // Determine trailing zeros.\r\n          for (k = xc.length; !xc[--k];);\r\n\r\n          // E.g. [4, 11, 15] becomes 4bf.\r\n          for (i = 0, str = ''; i <= k; str += alphabet.charAt(xc[i++]));\r\n\r\n          // Add leading zeros, decimal point and trailing zeros as required.\r\n          str = toFixedPoint(str, e, alphabet.charAt(0));\r\n        }\r\n\r\n        // The caller will add the sign.\r\n        return str;\r\n      };\r\n    })();\r\n\r\n\r\n    // Perform division in the specified base. Called by div and convertBase.\r\n    div = (function () {\r\n\r\n      // Assume non-zero x and k.\r\n      function multiply(x, k, base) {\r\n        var m, temp, xlo, xhi,\r\n          carry = 0,\r\n          i = x.length,\r\n          klo = k % SQRT_BASE,\r\n          khi = k / SQRT_BASE | 0;\r\n\r\n        for (x = x.slice(); i--;) {\r\n          xlo = x[i] % SQRT_BASE;\r\n          xhi = x[i] / SQRT_BASE | 0;\r\n          m = khi * xlo + xhi * klo;\r\n          temp = klo * xlo + ((m % SQRT_BASE) * SQRT_BASE) + carry;\r\n          carry = (temp / base | 0) + (m / SQRT_BASE | 0) + khi * xhi;\r\n          x[i] = temp % base;\r\n        }\r\n\r\n        if (carry) x = [carry].concat(x);\r\n\r\n        return x;\r\n      }\r\n\r\n      function compare(a, b, aL, bL) {\r\n        var i, cmp;\r\n\r\n        if (aL != bL) {\r\n          cmp = aL > bL ? 1 : -1;\r\n        } else {\r\n\r\n          for (i = cmp = 0; i < aL; i++) {\r\n\r\n            if (a[i] != b[i]) {\r\n              cmp = a[i] > b[i] ? 1 : -1;\r\n              break;\r\n            }\r\n          }\r\n        }\r\n\r\n        return cmp;\r\n      }\r\n\r\n      function subtract(a, b, aL, base) {\r\n        var i = 0;\r\n\r\n        // Subtract b from a.\r\n        for (; aL--;) {\r\n          a[aL] -= i;\r\n          i = a[aL] < b[aL] ? 1 : 0;\r\n          a[aL] = i * base + a[aL] - b[aL];\r\n        }\r\n\r\n        // Remove leading zeros.\r\n        for (; !a[0] && a.length > 1; a.splice(0, 1));\r\n      }\r\n\r\n      // x: dividend, y: divisor.\r\n      return function (x, y, dp, rm, base) {\r\n        var cmp, e, i, more, n, prod, prodL, q, qc, rem, remL, rem0, xi, xL, yc0,\r\n          yL, yz,\r\n          s = x.s == y.s ? 1 : -1,\r\n          xc = x.c,\r\n          yc = y.c;\r\n\r\n        // Either NaN, Infinity or 0?\r\n        if (!xc || !xc[0] || !yc || !yc[0]) {\r\n\r\n          return new BigNumber(\r\n\r\n           // Return NaN if either NaN, or both Infinity or 0.\r\n           !x.s || !y.s || (xc ? yc && xc[0] == yc[0] : !yc) ? NaN :\r\n\r\n            // Return ±0 if x is ±0 or y is ±Infinity, or return ±Infinity as y is ±0.\r\n            xc && xc[0] == 0 || !yc ? s * 0 : s / 0\r\n         );\r\n        }\r\n\r\n        q = new BigNumber(s);\r\n        qc = q.c = [];\r\n        e = x.e - y.e;\r\n        s = dp + e + 1;\r\n\r\n        if (!base) {\r\n          base = BASE;\r\n          e = bitFloor(x.e / LOG_BASE) - bitFloor(y.e / LOG_BASE);\r\n          s = s / LOG_BASE | 0;\r\n        }\r\n\r\n        // Result exponent may be one less then the current value of e.\r\n        // The coefficients of the BigNumbers from convertBase may have trailing zeros.\r\n        for (i = 0; yc[i] == (xc[i] || 0); i++);\r\n\r\n        if (yc[i] > (xc[i] || 0)) e--;\r\n\r\n        if (s < 0) {\r\n          qc.push(1);\r\n          more = true;\r\n        } else {\r\n          xL = xc.length;\r\n          yL = yc.length;\r\n          i = 0;\r\n          s += 2;\r\n\r\n          // Normalise xc and yc so highest order digit of yc is >= base / 2.\r\n\r\n          n = mathfloor(base / (yc[0] + 1));\r\n\r\n          // Not necessary, but to handle odd bases where yc[0] == (base / 2) - 1.\r\n          // if (n > 1 || n++ == 1 && yc[0] < base / 2) {\r\n          if (n > 1) {\r\n            yc = multiply(yc, n, base);\r\n            xc = multiply(xc, n, base);\r\n            yL = yc.length;\r\n            xL = xc.length;\r\n          }\r\n\r\n          xi = yL;\r\n          rem = xc.slice(0, yL);\r\n          remL = rem.length;\r\n\r\n          // Add zeros to make remainder as long as divisor.\r\n          for (; remL < yL; rem[remL++] = 0);\r\n          yz = yc.slice();\r\n          yz = [0].concat(yz);\r\n          yc0 = yc[0];\r\n          if (yc[1] >= base / 2) yc0++;\r\n          // Not necessary, but to prevent trial digit n > base, when using base 3.\r\n          // else if (base == 3 && yc0 == 1) yc0 = 1 + 1e-15;\r\n\r\n          do {\r\n            n = 0;\r\n\r\n            // Compare divisor and remainder.\r\n            cmp = compare(yc, rem, yL, remL);\r\n\r\n            // If divisor < remainder.\r\n            if (cmp < 0) {\r\n\r\n              // Calculate trial digit, n.\r\n\r\n              rem0 = rem[0];\r\n              if (yL != remL) rem0 = rem0 * base + (rem[1] || 0);\r\n\r\n              // n is how many times the divisor goes into the current remainder.\r\n              n = mathfloor(rem0 / yc0);\r\n\r\n              //  Algorithm:\r\n              //  product = divisor multiplied by trial digit (n).\r\n              //  Compare product and remainder.\r\n              //  If product is greater than remainder:\r\n              //    Subtract divisor from product, decrement trial digit.\r\n              //  Subtract product from remainder.\r\n              //  If product was less than remainder at the last compare:\r\n              //    Compare new remainder and divisor.\r\n              //    If remainder is greater than divisor:\r\n              //      Subtract divisor from remainder, increment trial digit.\r\n\r\n              if (n > 1) {\r\n\r\n                // n may be > base only when base is 3.\r\n                if (n >= base) n = base - 1;\r\n\r\n                // product = divisor * trial digit.\r\n                prod = multiply(yc, n, base);\r\n                prodL = prod.length;\r\n                remL = rem.length;\r\n\r\n                // Compare product and remainder.\r\n                // If product > remainder then trial digit n too high.\r\n                // n is 1 too high about 5% of the time, and is not known to have\r\n                // ever been more than 1 too high.\r\n                while (compare(prod, rem, prodL, remL) == 1) {\r\n                  n--;\r\n\r\n                  // Subtract divisor from product.\r\n                  subtract(prod, yL < prodL ? yz : yc, prodL, base);\r\n                  prodL = prod.length;\r\n                  cmp = 1;\r\n                }\r\n              } else {\r\n\r\n                // n is 0 or 1, cmp is -1.\r\n                // If n is 0, there is no need to compare yc and rem again below,\r\n                // so change cmp to 1 to avoid it.\r\n                // If n is 1, leave cmp as -1, so yc and rem are compared again.\r\n                if (n == 0) {\r\n\r\n                  // divisor < remainder, so n must be at least 1.\r\n                  cmp = n = 1;\r\n                }\r\n\r\n                // product = divisor\r\n                prod = yc.slice();\r\n                prodL = prod.length;\r\n              }\r\n\r\n              if (prodL < remL) prod = [0].concat(prod);\r\n\r\n              // Subtract product from remainder.\r\n              subtract(rem, prod, remL, base);\r\n              remL = rem.length;\r\n\r\n               // If product was < remainder.\r\n              if (cmp == -1) {\r\n\r\n                // Compare divisor and new remainder.\r\n                // If divisor < new remainder, subtract divisor from remainder.\r\n                // Trial digit n too low.\r\n                // n is 1 too low about 5% of the time, and very rarely 2 too low.\r\n                while (compare(yc, rem, yL, remL) < 1) {\r\n                  n++;\r\n\r\n                  // Subtract divisor from remainder.\r\n                  subtract(rem, yL < remL ? yz : yc, remL, base);\r\n                  remL = rem.length;\r\n                }\r\n              }\r\n            } else if (cmp === 0) {\r\n              n++;\r\n              rem = [0];\r\n            } // else cmp === 1 and n will be 0\r\n\r\n            // Add the next digit, n, to the result array.\r\n            qc[i++] = n;\r\n\r\n            // Update the remainder.\r\n            if (rem[0]) {\r\n              rem[remL++] = xc[xi] || 0;\r\n            } else {\r\n              rem = [xc[xi]];\r\n              remL = 1;\r\n            }\r\n          } while ((xi++ < xL || rem[0] != null) && s--);\r\n\r\n          more = rem[0] != null;\r\n\r\n          // Leading zero?\r\n          if (!qc[0]) qc.splice(0, 1);\r\n        }\r\n\r\n        if (base == BASE) {\r\n\r\n          // To calculate q.e, first get the number of digits of qc[0].\r\n          for (i = 1, s = qc[0]; s >= 10; s /= 10, i++);\r\n\r\n          round(q, dp + (q.e = i + e * LOG_BASE - 1) + 1, rm, more);\r\n\r\n        // Caller is convertBase.\r\n        } else {\r\n          q.e = e;\r\n          q.r = +more;\r\n        }\r\n\r\n        return q;\r\n      };\r\n    })();\r\n\r\n\r\n    /*\r\n     * Return a string representing the value of BigNumber n in fixed-point or exponential\r\n     * notation rounded to the specified decimal places or significant digits.\r\n     *\r\n     * n: a BigNumber.\r\n     * i: the index of the last digit required (i.e. the digit that may be rounded up).\r\n     * rm: the rounding mode.\r\n     * id: 1 (toExponential) or 2 (toPrecision).\r\n     */\r\n    function format(n, i, rm, id) {\r\n      var c0, e, ne, len, str;\r\n\r\n      if (rm == null) rm = ROUNDING_MODE;\r\n      else intCheck(rm, 0, 8);\r\n\r\n      if (!n.c) return n.toString();\r\n\r\n      c0 = n.c[0];\r\n      ne = n.e;\r\n\r\n      if (i == null) {\r\n        str = coeffToString(n.c);\r\n        str = id == 1 || id == 2 && (ne <= TO_EXP_NEG || ne >= TO_EXP_POS)\r\n         ? toExponential(str, ne)\r\n         : toFixedPoint(str, ne, '0');\r\n      } else {\r\n        n = round(new BigNumber(n), i, rm);\r\n\r\n        // n.e may have changed if the value was rounded up.\r\n        e = n.e;\r\n\r\n        str = coeffToString(n.c);\r\n        len = str.length;\r\n\r\n        // toPrecision returns exponential notation if the number of significant digits\r\n        // specified is less than the number of digits necessary to represent the integer\r\n        // part of the value in fixed-point notation.\r\n\r\n        // Exponential notation.\r\n        if (id == 1 || id == 2 && (i <= e || e <= TO_EXP_NEG)) {\r\n\r\n          // Append zeros?\r\n          for (; len < i; str += '0', len++);\r\n          str = toExponential(str, e);\r\n\r\n        // Fixed-point notation.\r\n        } else {\r\n          i -= ne;\r\n          str = toFixedPoint(str, e, '0');\r\n\r\n          // Append zeros?\r\n          if (e + 1 > len) {\r\n            if (--i > 0) for (str += '.'; i--; str += '0');\r\n          } else {\r\n            i += e - len;\r\n            if (i > 0) {\r\n              if (e + 1 == len) str += '.';\r\n              for (; i--; str += '0');\r\n            }\r\n          }\r\n        }\r\n      }\r\n\r\n      return n.s < 0 && c0 ? '-' + str : str;\r\n    }\r\n\r\n\r\n    // Handle BigNumber.max and BigNumber.min.\r\n    function maxOrMin(args, method) {\r\n      var n,\r\n        i = 1,\r\n        m = new BigNumber(args[0]);\r\n\r\n      for (; i < args.length; i++) {\r\n        n = new BigNumber(args[i]);\r\n\r\n        // If any number is NaN, return NaN.\r\n        if (!n.s) {\r\n          m = n;\r\n          break;\r\n        } else if (method.call(m, n)) {\r\n          m = n;\r\n        }\r\n      }\r\n\r\n      return m;\r\n    }\r\n\r\n\r\n    /*\r\n     * Strip trailing zeros, calculate base 10 exponent and check against MIN_EXP and MAX_EXP.\r\n     * Called by minus, plus and times.\r\n     */\r\n    function normalise(n, c, e) {\r\n      var i = 1,\r\n        j = c.length;\r\n\r\n       // Remove trailing zeros.\r\n      for (; !c[--j]; c.pop());\r\n\r\n      // Calculate the base 10 exponent. First get the number of digits of c[0].\r\n      for (j = c[0]; j >= 10; j /= 10, i++);\r\n\r\n      // Overflow?\r\n      if ((e = i + e * LOG_BASE - 1) > MAX_EXP) {\r\n\r\n        // Infinity.\r\n        n.c = n.e = null;\r\n\r\n      // Underflow?\r\n      } else if (e < MIN_EXP) {\r\n\r\n        // Zero.\r\n        n.c = [n.e = 0];\r\n      } else {\r\n        n.e = e;\r\n        n.c = c;\r\n      }\r\n\r\n      return n;\r\n    }\r\n\r\n\r\n    // Handle values that fail the validity test in BigNumber.\r\n    parseNumeric = (function () {\r\n      var basePrefix = /^(-?)0([xbo])(?=\\w[\\w.]*$)/i,\r\n        dotAfter = /^([^.]+)\\.$/,\r\n        dotBefore = /^\\.([^.]+)$/,\r\n        isInfinityOrNaN = /^-?(Infinity|NaN)$/,\r\n        whitespaceOrPlus = /^\\s*\\+(?=[\\w.])|^\\s+|\\s+$/g;\r\n\r\n      return function (x, str, isNum, b) {\r\n        var base,\r\n          s = isNum ? str : str.replace(whitespaceOrPlus, '');\r\n\r\n        // No exception on ±Infinity or NaN.\r\n        if (isInfinityOrNaN.test(s)) {\r\n          x.s = isNaN(s) ? null : s < 0 ? -1 : 1;\r\n        } else {\r\n          if (!isNum) {\r\n\r\n            // basePrefix = /^(-?)0([xbo])(?=\\w[\\w.]*$)/i\r\n            s = s.replace(basePrefix, function (m, p1, p2) {\r\n              base = (p2 = p2.toLowerCase()) == 'x' ? 16 : p2 == 'b' ? 2 : 8;\r\n              return !b || b == base ? p1 : m;\r\n            });\r\n\r\n            if (b) {\r\n              base = b;\r\n\r\n              // E.g. '1.' to '1', '.1' to '0.1'\r\n              s = s.replace(dotAfter, '$1').replace(dotBefore, '0.$1');\r\n            }\r\n\r\n            if (str != s) return new BigNumber(s, base);\r\n          }\r\n\r\n          // '[BigNumber Error] Not a number: {n}'\r\n          // '[BigNumber Error] Not a base {b} number: {n}'\r\n          if (BigNumber.DEBUG) {\r\n            throw Error\r\n              (bignumberError + 'Not a' + (b ? ' base ' + b : '') + ' number: ' + str);\r\n          }\r\n\r\n          // NaN\r\n          x.s = null;\r\n        }\r\n\r\n        x.c = x.e = null;\r\n      }\r\n    })();\r\n\r\n\r\n    /*\r\n     * Round x to sd significant digits using rounding mode rm. Check for over/under-flow.\r\n     * If r is truthy, it is known that there are more digits after the rounding digit.\r\n     */\r\n    function round(x, sd, rm, r) {\r\n      var d, i, j, k, n, ni, rd,\r\n        xc = x.c,\r\n        pows10 = POWS_TEN;\r\n\r\n      // if x is not Infinity or NaN...\r\n      if (xc) {\r\n\r\n        // rd is the rounding digit, i.e. the digit after the digit that may be rounded up.\r\n        // n is a base 1e14 number, the value of the element of array x.c containing rd.\r\n        // ni is the index of n within x.c.\r\n        // d is the number of digits of n.\r\n        // i is the index of rd within n including leading zeros.\r\n        // j is the actual index of rd within n (if < 0, rd is a leading zero).\r\n        out: {\r\n\r\n          // Get the number of digits of the first element of xc.\r\n          for (d = 1, k = xc[0]; k >= 10; k /= 10, d++);\r\n          i = sd - d;\r\n\r\n          // If the rounding digit is in the first element of xc...\r\n          if (i < 0) {\r\n            i += LOG_BASE;\r\n            j = sd;\r\n            n = xc[ni = 0];\r\n\r\n            // Get the rounding digit at index j of n.\r\n            rd = n / pows10[d - j - 1] % 10 | 0;\r\n          } else {\r\n            ni = mathceil((i + 1) / LOG_BASE);\r\n\r\n            if (ni >= xc.length) {\r\n\r\n              if (r) {\r\n\r\n                // Needed by sqrt.\r\n                for (; xc.length <= ni; xc.push(0));\r\n                n = rd = 0;\r\n                d = 1;\r\n                i %= LOG_BASE;\r\n                j = i - LOG_BASE + 1;\r\n              } else {\r\n                break out;\r\n              }\r\n            } else {\r\n              n = k = xc[ni];\r\n\r\n              // Get the number of digits of n.\r\n              for (d = 1; k >= 10; k /= 10, d++);\r\n\r\n              // Get the index of rd within n.\r\n              i %= LOG_BASE;\r\n\r\n              // Get the index of rd within n, adjusted for leading zeros.\r\n              // The number of leading zeros of n is given by LOG_BASE - d.\r\n              j = i - LOG_BASE + d;\r\n\r\n              // Get the rounding digit at index j of n.\r\n              rd = j < 0 ? 0 : n / pows10[d - j - 1] % 10 | 0;\r\n            }\r\n          }\r\n\r\n          r = r || sd < 0 ||\r\n\r\n          // Are there any non-zero digits after the rounding digit?\r\n          // The expression  n % pows10[d - j - 1]  returns all digits of n to the right\r\n          // of the digit at j, e.g. if n is 908714 and j is 2, the expression gives 714.\r\n           xc[ni + 1] != null || (j < 0 ? n : n % pows10[d - j - 1]);\r\n\r\n          r = rm < 4\r\n           ? (rd || r) && (rm == 0 || rm == (x.s < 0 ? 3 : 2))\r\n           : rd > 5 || rd == 5 && (rm == 4 || r || rm == 6 &&\r\n\r\n            // Check whether the digit to the left of the rounding digit is odd.\r\n            ((i > 0 ? j > 0 ? n / pows10[d - j] : 0 : xc[ni - 1]) % 10) & 1 ||\r\n             rm == (x.s < 0 ? 8 : 7));\r\n\r\n          if (sd < 1 || !xc[0]) {\r\n            xc.length = 0;\r\n\r\n            if (r) {\r\n\r\n              // Convert sd to decimal places.\r\n              sd -= x.e + 1;\r\n\r\n              // 1, 0.1, 0.01, 0.001, 0.0001 etc.\r\n              xc[0] = pows10[(LOG_BASE - sd % LOG_BASE) % LOG_BASE];\r\n              x.e = -sd || 0;\r\n            } else {\r\n\r\n              // Zero.\r\n              xc[0] = x.e = 0;\r\n            }\r\n\r\n            return x;\r\n          }\r\n\r\n          // Remove excess digits.\r\n          if (i == 0) {\r\n            xc.length = ni;\r\n            k = 1;\r\n            ni--;\r\n          } else {\r\n            xc.length = ni + 1;\r\n            k = pows10[LOG_BASE - i];\r\n\r\n            // E.g. 56700 becomes 56000 if 7 is the rounding digit.\r\n            // j > 0 means i > number of leading zeros of n.\r\n            xc[ni] = j > 0 ? mathfloor(n / pows10[d - j] % pows10[j]) * k : 0;\r\n          }\r\n\r\n          // Round up?\r\n          if (r) {\r\n\r\n            for (; ;) {\r\n\r\n              // If the digit to be rounded up is in the first element of xc...\r\n              if (ni == 0) {\r\n\r\n                // i will be the length of xc[0] before k is added.\r\n                for (i = 1, j = xc[0]; j >= 10; j /= 10, i++);\r\n                j = xc[0] += k;\r\n                for (k = 1; j >= 10; j /= 10, k++);\r\n\r\n                // if i != k the length has increased.\r\n                if (i != k) {\r\n                  x.e++;\r\n                  if (xc[0] == BASE) xc[0] = 1;\r\n                }\r\n\r\n                break;\r\n              } else {\r\n                xc[ni] += k;\r\n                if (xc[ni] != BASE) break;\r\n                xc[ni--] = 0;\r\n                k = 1;\r\n              }\r\n            }\r\n          }\r\n\r\n          // Remove trailing zeros.\r\n          for (i = xc.length; xc[--i] === 0; xc.pop());\r\n        }\r\n\r\n        // Overflow? Infinity.\r\n        if (x.e > MAX_EXP) {\r\n          x.c = x.e = null;\r\n\r\n        // Underflow? Zero.\r\n        } else if (x.e < MIN_EXP) {\r\n          x.c = [x.e = 0];\r\n        }\r\n      }\r\n\r\n      return x;\r\n    }\r\n\r\n\r\n    function valueOf(n) {\r\n      var str,\r\n        e = n.e;\r\n\r\n      if (e === null) return n.toString();\r\n\r\n      str = coeffToString(n.c);\r\n\r\n      str = e <= TO_EXP_NEG || e >= TO_EXP_POS\r\n        ? toExponential(str, e)\r\n        : toFixedPoint(str, e, '0');\r\n\r\n      return n.s < 0 ? '-' + str : str;\r\n    }\r\n\r\n\r\n    // PROTOTYPE/INSTANCE METHODS\r\n\r\n\r\n    /*\r\n     * Return a new BigNumber whose value is the absolute value of this BigNumber.\r\n     */\r\n    P.absoluteValue = P.abs = function () {\r\n      var x = new BigNumber(this);\r\n      if (x.s < 0) x.s = 1;\r\n      return x;\r\n    };\r\n\r\n\r\n    /*\r\n     * Return\r\n     *   1 if the value of this BigNumber is greater than the value of BigNumber(y, b),\r\n     *   -1 if the value of this BigNumber is less than the value of BigNumber(y, b),\r\n     *   0 if they have the same value,\r\n     *   or null if the value of either is NaN.\r\n     */\r\n    P.comparedTo = function (y, b) {\r\n      return compare(this, new BigNumber(y, b));\r\n    };\r\n\r\n\r\n    /*\r\n     * If dp is undefined or null or true or false, return the number of decimal places of the\r\n     * value of this BigNumber, or null if the value of this BigNumber is ±Infinity or NaN.\r\n     *\r\n     * Otherwise, if dp is a number, return a new BigNumber whose value is the value of this\r\n     * BigNumber rounded to a maximum of dp decimal places using rounding mode rm, or\r\n     * ROUNDING_MODE if rm is omitted.\r\n     *\r\n     * [dp] {number} Decimal places: integer, 0 to MAX inclusive.\r\n     * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n     *\r\n     * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {dp|rm}'\r\n     */\r\n    P.decimalPlaces = P.dp = function (dp, rm) {\r\n      var c, n, v,\r\n        x = this;\r\n\r\n      if (dp != null) {\r\n        intCheck(dp, 0, MAX);\r\n        if (rm == null) rm = ROUNDING_MODE;\r\n        else intCheck(rm, 0, 8);\r\n\r\n        return round(new BigNumber(x), dp + x.e + 1, rm);\r\n      }\r\n\r\n      if (!(c = x.c)) return null;\r\n      n = ((v = c.length - 1) - bitFloor(this.e / LOG_BASE)) * LOG_BASE;\r\n\r\n      // Subtract the number of trailing zeros of the last number.\r\n      if (v = c[v]) for (; v % 10 == 0; v /= 10, n--);\r\n      if (n < 0) n = 0;\r\n\r\n      return n;\r\n    };\r\n\r\n\r\n    /*\r\n     *  n / 0 = I\r\n     *  n / N = N\r\n     *  n / I = 0\r\n     *  0 / n = 0\r\n     *  0 / 0 = N\r\n     *  0 / N = N\r\n     *  0 / I = 0\r\n     *  N / n = N\r\n     *  N / 0 = N\r\n     *  N / N = N\r\n     *  N / I = N\r\n     *  I / n = I\r\n     *  I / 0 = I\r\n     *  I / N = N\r\n     *  I / I = N\r\n     *\r\n     * Return a new BigNumber whose value is the value of this BigNumber divided by the value of\r\n     * BigNumber(y, b), rounded according to DECIMAL_PLACES and ROUNDING_MODE.\r\n     */\r\n    P.dividedBy = P.div = function (y, b) {\r\n      return div(this, new BigNumber(y, b), DECIMAL_PLACES, ROUNDING_MODE);\r\n    };\r\n\r\n\r\n    /*\r\n     * Return a new BigNumber whose value is the integer part of dividing the value of this\r\n     * BigNumber by the value of BigNumber(y, b).\r\n     */\r\n    P.dividedToIntegerBy = P.idiv = function (y, b) {\r\n      return div(this, new BigNumber(y, b), 0, 1);\r\n    };\r\n\r\n\r\n    /*\r\n     * Return a BigNumber whose value is the value of this BigNumber exponentiated by n.\r\n     *\r\n     * If m is present, return the result modulo m.\r\n     * If n is negative round according to DECIMAL_PLACES and ROUNDING_MODE.\r\n     * If POW_PRECISION is non-zero and m is not present, round to POW_PRECISION using ROUNDING_MODE.\r\n     *\r\n     * The modular power operation works efficiently when x, n, and m are integers, otherwise it\r\n     * is equivalent to calculating x.exponentiatedBy(n).modulo(m) with a POW_PRECISION of 0.\r\n     *\r\n     * n {number|string|BigNumber} The exponent. An integer.\r\n     * [m] {number|string|BigNumber} The modulus.\r\n     *\r\n     * '[BigNumber Error] Exponent not an integer: {n}'\r\n     */\r\n    P.exponentiatedBy = P.pow = function (n, m) {\r\n      var half, isModExp, i, k, more, nIsBig, nIsNeg, nIsOdd, y,\r\n        x = this;\r\n\r\n      n = new BigNumber(n);\r\n\r\n      // Allow NaN and ±Infinity, but not other non-integers.\r\n      if (n.c && !n.isInteger()) {\r\n        throw Error\r\n          (bignumberError + 'Exponent not an integer: ' + valueOf(n));\r\n      }\r\n\r\n      if (m != null) m = new BigNumber(m);\r\n\r\n      // Exponent of MAX_SAFE_INTEGER is 15.\r\n      nIsBig = n.e > 14;\r\n\r\n      // If x is NaN, ±Infinity, ±0 or ±1, or n is ±Infinity, NaN or ±0.\r\n      if (!x.c || !x.c[0] || x.c[0] == 1 && !x.e && x.c.length == 1 || !n.c || !n.c[0]) {\r\n\r\n        // The sign of the result of pow when x is negative depends on the evenness of n.\r\n        // If +n overflows to ±Infinity, the evenness of n would be not be known.\r\n        y = new BigNumber(Math.pow(+valueOf(x), nIsBig ? 2 - isOdd(n) : +valueOf(n)));\r\n        return m ? y.mod(m) : y;\r\n      }\r\n\r\n      nIsNeg = n.s < 0;\r\n\r\n      if (m) {\r\n\r\n        // x % m returns NaN if abs(m) is zero, or m is NaN.\r\n        if (m.c ? !m.c[0] : !m.s) return new BigNumber(NaN);\r\n\r\n        isModExp = !nIsNeg && x.isInteger() && m.isInteger();\r\n\r\n        if (isModExp) x = x.mod(m);\r\n\r\n      // Overflow to ±Infinity: >=2**1e10 or >=1.0000024**1e15.\r\n      // Underflow to ±0: <=0.79**1e10 or <=0.9999975**1e15.\r\n      } else if (n.e > 9 && (x.e > 0 || x.e < -1 || (x.e == 0\r\n        // [1, 240000000]\r\n        ? x.c[0] > 1 || nIsBig && x.c[1] >= 24e7\r\n        // [80000000000000]  [99999750000000]\r\n        : x.c[0] < 8e13 || nIsBig && x.c[0] <= 9999975e7))) {\r\n\r\n        // If x is negative and n is odd, k = -0, else k = 0.\r\n        k = x.s < 0 && isOdd(n) ? -0 : 0;\r\n\r\n        // If x >= 1, k = ±Infinity.\r\n        if (x.e > -1) k = 1 / k;\r\n\r\n        // If n is negative return ±0, else return ±Infinity.\r\n        return new BigNumber(nIsNeg ? 1 / k : k);\r\n\r\n      } else if (POW_PRECISION) {\r\n\r\n        // Truncating each coefficient array to a length of k after each multiplication\r\n        // equates to truncating significant digits to POW_PRECISION + [28, 41],\r\n        // i.e. there will be a minimum of 28 guard digits retained.\r\n        k = mathceil(POW_PRECISION / LOG_BASE + 2);\r\n      }\r\n\r\n      if (nIsBig) {\r\n        half = new BigNumber(0.5);\r\n        if (nIsNeg) n.s = 1;\r\n        nIsOdd = isOdd(n);\r\n      } else {\r\n        i = Math.abs(+valueOf(n));\r\n        nIsOdd = i % 2;\r\n      }\r\n\r\n      y = new BigNumber(ONE);\r\n\r\n      // Performs 54 loop iterations for n of 9007199254740991.\r\n      for (; ;) {\r\n\r\n        if (nIsOdd) {\r\n          y = y.times(x);\r\n          if (!y.c) break;\r\n\r\n          if (k) {\r\n            if (y.c.length > k) y.c.length = k;\r\n          } else if (isModExp) {\r\n            y = y.mod(m);    //y = y.minus(div(y, m, 0, MODULO_MODE).times(m));\r\n          }\r\n        }\r\n\r\n        if (i) {\r\n          i = mathfloor(i / 2);\r\n          if (i === 0) break;\r\n          nIsOdd = i % 2;\r\n        } else {\r\n          n = n.times(half);\r\n          round(n, n.e + 1, 1);\r\n\r\n          if (n.e > 14) {\r\n            nIsOdd = isOdd(n);\r\n          } else {\r\n            i = +valueOf(n);\r\n            if (i === 0) break;\r\n            nIsOdd = i % 2;\r\n          }\r\n        }\r\n\r\n        x = x.times(x);\r\n\r\n        if (k) {\r\n          if (x.c && x.c.length > k) x.c.length = k;\r\n        } else if (isModExp) {\r\n          x = x.mod(m);    //x = x.minus(div(x, m, 0, MODULO_MODE).times(m));\r\n        }\r\n      }\r\n\r\n      if (isModExp) return y;\r\n      if (nIsNeg) y = ONE.div(y);\r\n\r\n      return m ? y.mod(m) : k ? round(y, POW_PRECISION, ROUNDING_MODE, more) : y;\r\n    };\r\n\r\n\r\n    /*\r\n     * Return a new BigNumber whose value is the value of this BigNumber rounded to an integer\r\n     * using rounding mode rm, or ROUNDING_MODE if rm is omitted.\r\n     *\r\n     * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n     *\r\n     * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {rm}'\r\n     */\r\n    P.integerValue = function (rm) {\r\n      var n = new BigNumber(this);\r\n      if (rm == null) rm = ROUNDING_MODE;\r\n      else intCheck(rm, 0, 8);\r\n      return round(n, n.e + 1, rm);\r\n    };\r\n\r\n\r\n    /*\r\n     * Return true if the value of this BigNumber is equal to the value of BigNumber(y, b),\r\n     * otherwise return false.\r\n     */\r\n    P.isEqualTo = P.eq = function (y, b) {\r\n      return compare(this, new BigNumber(y, b)) === 0;\r\n    };\r\n\r\n\r\n    /*\r\n     * Return true if the value of this BigNumber is a finite number, otherwise return false.\r\n     */\r\n    P.isFinite = function () {\r\n      return !!this.c;\r\n    };\r\n\r\n\r\n    /*\r\n     * Return true if the value of this BigNumber is greater than the value of BigNumber(y, b),\r\n     * otherwise return false.\r\n     */\r\n    P.isGreaterThan = P.gt = function (y, b) {\r\n      return compare(this, new BigNumber(y, b)) > 0;\r\n    };\r\n\r\n\r\n    /*\r\n     * Return true if the value of this BigNumber is greater than or equal to the value of\r\n     * BigNumber(y, b), otherwise return false.\r\n     */\r\n    P.isGreaterThanOrEqualTo = P.gte = function (y, b) {\r\n      return (b = compare(this, new BigNumber(y, b))) === 1 || b === 0;\r\n\r\n    };\r\n\r\n\r\n    /*\r\n     * Return true if the value of this BigNumber is an integer, otherwise return false.\r\n     */\r\n    P.isInteger = function () {\r\n      return !!this.c && bitFloor(this.e / LOG_BASE) > this.c.length - 2;\r\n    };\r\n\r\n\r\n    /*\r\n     * Return true if the value of this BigNumber is less than the value of BigNumber(y, b),\r\n     * otherwise return false.\r\n     */\r\n    P.isLessThan = P.lt = function (y, b) {\r\n      return compare(this, new BigNumber(y, b)) < 0;\r\n    };\r\n\r\n\r\n    /*\r\n     * Return true if the value of this BigNumber is less than or equal to the value of\r\n     * BigNumber(y, b), otherwise return false.\r\n     */\r\n    P.isLessThanOrEqualTo = P.lte = function (y, b) {\r\n      return (b = compare(this, new BigNumber(y, b))) === -1 || b === 0;\r\n    };\r\n\r\n\r\n    /*\r\n     * Return true if the value of this BigNumber is NaN, otherwise return false.\r\n     */\r\n    P.isNaN = function () {\r\n      return !this.s;\r\n    };\r\n\r\n\r\n    /*\r\n     * Return true if the value of this BigNumber is negative, otherwise return false.\r\n     */\r\n    P.isNegative = function () {\r\n      return this.s < 0;\r\n    };\r\n\r\n\r\n    /*\r\n     * Return true if the value of this BigNumber is positive, otherwise return false.\r\n     */\r\n    P.isPositive = function () {\r\n      return this.s > 0;\r\n    };\r\n\r\n\r\n    /*\r\n     * Return true if the value of this BigNumber is 0 or -0, otherwise return false.\r\n     */\r\n    P.isZero = function () {\r\n      return !!this.c && this.c[0] == 0;\r\n    };\r\n\r\n\r\n    /*\r\n     *  n - 0 = n\r\n     *  n - N = N\r\n     *  n - I = -I\r\n     *  0 - n = -n\r\n     *  0 - 0 = 0\r\n     *  0 - N = N\r\n     *  0 - I = -I\r\n     *  N - n = N\r\n     *  N - 0 = N\r\n     *  N - N = N\r\n     *  N - I = N\r\n     *  I - n = I\r\n     *  I - 0 = I\r\n     *  I - N = N\r\n     *  I - I = N\r\n     *\r\n     * Return a new BigNumber whose value is the value of this BigNumber minus the value of\r\n     * BigNumber(y, b).\r\n     */\r\n    P.minus = function (y, b) {\r\n      var i, j, t, xLTy,\r\n        x = this,\r\n        a = x.s;\r\n\r\n      y = new BigNumber(y, b);\r\n      b = y.s;\r\n\r\n      // Either NaN?\r\n      if (!a || !b) return new BigNumber(NaN);\r\n\r\n      // Signs differ?\r\n      if (a != b) {\r\n        y.s = -b;\r\n        return x.plus(y);\r\n      }\r\n\r\n      var xe = x.e / LOG_BASE,\r\n        ye = y.e / LOG_BASE,\r\n        xc = x.c,\r\n        yc = y.c;\r\n\r\n      if (!xe || !ye) {\r\n\r\n        // Either Infinity?\r\n        if (!xc || !yc) return xc ? (y.s = -b, y) : new BigNumber(yc ? x : NaN);\r\n\r\n        // Either zero?\r\n        if (!xc[0] || !yc[0]) {\r\n\r\n          // Return y if y is non-zero, x if x is non-zero, or zero if both are zero.\r\n          return yc[0] ? (y.s = -b, y) : new BigNumber(xc[0] ? x :\r\n\r\n           // IEEE 754 (2008) 6.3: n - n = -0 when rounding to -Infinity\r\n           ROUNDING_MODE == 3 ? -0 : 0);\r\n        }\r\n      }\r\n\r\n      xe = bitFloor(xe);\r\n      ye = bitFloor(ye);\r\n      xc = xc.slice();\r\n\r\n      // Determine which is the bigger number.\r\n      if (a = xe - ye) {\r\n\r\n        if (xLTy = a < 0) {\r\n          a = -a;\r\n          t = xc;\r\n        } else {\r\n          ye = xe;\r\n          t = yc;\r\n        }\r\n\r\n        t.reverse();\r\n\r\n        // Prepend zeros to equalise exponents.\r\n        for (b = a; b--; t.push(0));\r\n        t.reverse();\r\n      } else {\r\n\r\n        // Exponents equal. Check digit by digit.\r\n        j = (xLTy = (a = xc.length) < (b = yc.length)) ? a : b;\r\n\r\n        for (a = b = 0; b < j; b++) {\r\n\r\n          if (xc[b] != yc[b]) {\r\n            xLTy = xc[b] < yc[b];\r\n            break;\r\n          }\r\n        }\r\n      }\r\n\r\n      // x < y? Point xc to the array of the bigger number.\r\n      if (xLTy) t = xc, xc = yc, yc = t, y.s = -y.s;\r\n\r\n      b = (j = yc.length) - (i = xc.length);\r\n\r\n      // Append zeros to xc if shorter.\r\n      // No need to add zeros to yc if shorter as subtract only needs to start at yc.length.\r\n      if (b > 0) for (; b--; xc[i++] = 0);\r\n      b = BASE - 1;\r\n\r\n      // Subtract yc from xc.\r\n      for (; j > a;) {\r\n\r\n        if (xc[--j] < yc[j]) {\r\n          for (i = j; i && !xc[--i]; xc[i] = b);\r\n          --xc[i];\r\n          xc[j] += BASE;\r\n        }\r\n\r\n        xc[j] -= yc[j];\r\n      }\r\n\r\n      // Remove leading zeros and adjust exponent accordingly.\r\n      for (; xc[0] == 0; xc.splice(0, 1), --ye);\r\n\r\n      // Zero?\r\n      if (!xc[0]) {\r\n\r\n        // Following IEEE 754 (2008) 6.3,\r\n        // n - n = +0  but  n - n = -0  when rounding towards -Infinity.\r\n        y.s = ROUNDING_MODE == 3 ? -1 : 1;\r\n        y.c = [y.e = 0];\r\n        return y;\r\n      }\r\n\r\n      // No need to check for Infinity as +x - +y != Infinity && -x - -y != Infinity\r\n      // for finite x and y.\r\n      return normalise(y, xc, ye);\r\n    };\r\n\r\n\r\n    /*\r\n     *   n % 0 =  N\r\n     *   n % N =  N\r\n     *   n % I =  n\r\n     *   0 % n =  0\r\n     *  -0 % n = -0\r\n     *   0 % 0 =  N\r\n     *   0 % N =  N\r\n     *   0 % I =  0\r\n     *   N % n =  N\r\n     *   N % 0 =  N\r\n     *   N % N =  N\r\n     *   N % I =  N\r\n     *   I % n =  N\r\n     *   I % 0 =  N\r\n     *   I % N =  N\r\n     *   I % I =  N\r\n     *\r\n     * Return a new BigNumber whose value is the value of this BigNumber modulo the value of\r\n     * BigNumber(y, b). The result depends on the value of MODULO_MODE.\r\n     */\r\n    P.modulo = P.mod = function (y, b) {\r\n      var q, s,\r\n        x = this;\r\n\r\n      y = new BigNumber(y, b);\r\n\r\n      // Return NaN if x is Infinity or NaN, or y is NaN or zero.\r\n      if (!x.c || !y.s || y.c && !y.c[0]) {\r\n        return new BigNumber(NaN);\r\n\r\n      // Return x if y is Infinity or x is zero.\r\n      } else if (!y.c || x.c && !x.c[0]) {\r\n        return new BigNumber(x);\r\n      }\r\n\r\n      if (MODULO_MODE == 9) {\r\n\r\n        // Euclidian division: q = sign(y) * floor(x / abs(y))\r\n        // r = x - qy    where  0 <= r < abs(y)\r\n        s = y.s;\r\n        y.s = 1;\r\n        q = div(x, y, 0, 3);\r\n        y.s = s;\r\n        q.s *= s;\r\n      } else {\r\n        q = div(x, y, 0, MODULO_MODE);\r\n      }\r\n\r\n      y = x.minus(q.times(y));\r\n\r\n      // To match JavaScript %, ensure sign of zero is sign of dividend.\r\n      if (!y.c[0] && MODULO_MODE == 1) y.s = x.s;\r\n\r\n      return y;\r\n    };\r\n\r\n\r\n    /*\r\n     *  n * 0 = 0\r\n     *  n * N = N\r\n     *  n * I = I\r\n     *  0 * n = 0\r\n     *  0 * 0 = 0\r\n     *  0 * N = N\r\n     *  0 * I = N\r\n     *  N * n = N\r\n     *  N * 0 = N\r\n     *  N * N = N\r\n     *  N * I = N\r\n     *  I * n = I\r\n     *  I * 0 = N\r\n     *  I * N = N\r\n     *  I * I = I\r\n     *\r\n     * Return a new BigNumber whose value is the value of this BigNumber multiplied by the value\r\n     * of BigNumber(y, b).\r\n     */\r\n    P.multipliedBy = P.times = function (y, b) {\r\n      var c, e, i, j, k, m, xcL, xlo, xhi, ycL, ylo, yhi, zc,\r\n        base, sqrtBase,\r\n        x = this,\r\n        xc = x.c,\r\n        yc = (y = new BigNumber(y, b)).c;\r\n\r\n      // Either NaN, ±Infinity or ±0?\r\n      if (!xc || !yc || !xc[0] || !yc[0]) {\r\n\r\n        // Return NaN if either is NaN, or one is 0 and the other is Infinity.\r\n        if (!x.s || !y.s || xc && !xc[0] && !yc || yc && !yc[0] && !xc) {\r\n          y.c = y.e = y.s = null;\r\n        } else {\r\n          y.s *= x.s;\r\n\r\n          // Return ±Infinity if either is ±Infinity.\r\n          if (!xc || !yc) {\r\n            y.c = y.e = null;\r\n\r\n          // Return ±0 if either is ±0.\r\n          } else {\r\n            y.c = [0];\r\n            y.e = 0;\r\n          }\r\n        }\r\n\r\n        return y;\r\n      }\r\n\r\n      e = bitFloor(x.e / LOG_BASE) + bitFloor(y.e / LOG_BASE);\r\n      y.s *= x.s;\r\n      xcL = xc.length;\r\n      ycL = yc.length;\r\n\r\n      // Ensure xc points to longer array and xcL to its length.\r\n      if (xcL < ycL) zc = xc, xc = yc, yc = zc, i = xcL, xcL = ycL, ycL = i;\r\n\r\n      // Initialise the result array with zeros.\r\n      for (i = xcL + ycL, zc = []; i--; zc.push(0));\r\n\r\n      base = BASE;\r\n      sqrtBase = SQRT_BASE;\r\n\r\n      for (i = ycL; --i >= 0;) {\r\n        c = 0;\r\n        ylo = yc[i] % sqrtBase;\r\n        yhi = yc[i] / sqrtBase | 0;\r\n\r\n        for (k = xcL, j = i + k; j > i;) {\r\n          xlo = xc[--k] % sqrtBase;\r\n          xhi = xc[k] / sqrtBase | 0;\r\n          m = yhi * xlo + xhi * ylo;\r\n          xlo = ylo * xlo + ((m % sqrtBase) * sqrtBase) + zc[j] + c;\r\n          c = (xlo / base | 0) + (m / sqrtBase | 0) + yhi * xhi;\r\n          zc[j--] = xlo % base;\r\n        }\r\n\r\n        zc[j] = c;\r\n      }\r\n\r\n      if (c) {\r\n        ++e;\r\n      } else {\r\n        zc.splice(0, 1);\r\n      }\r\n\r\n      return normalise(y, zc, e);\r\n    };\r\n\r\n\r\n    /*\r\n     * Return a new BigNumber whose value is the value of this BigNumber negated,\r\n     * i.e. multiplied by -1.\r\n     */\r\n    P.negated = function () {\r\n      var x = new BigNumber(this);\r\n      x.s = -x.s || null;\r\n      return x;\r\n    };\r\n\r\n\r\n    /*\r\n     *  n + 0 = n\r\n     *  n + N = N\r\n     *  n + I = I\r\n     *  0 + n = n\r\n     *  0 + 0 = 0\r\n     *  0 + N = N\r\n     *  0 + I = I\r\n     *  N + n = N\r\n     *  N + 0 = N\r\n     *  N + N = N\r\n     *  N + I = N\r\n     *  I + n = I\r\n     *  I + 0 = I\r\n     *  I + N = N\r\n     *  I + I = I\r\n     *\r\n     * Return a new BigNumber whose value is the value of this BigNumber plus the value of\r\n     * BigNumber(y, b).\r\n     */\r\n    P.plus = function (y, b) {\r\n      var t,\r\n        x = this,\r\n        a = x.s;\r\n\r\n      y = new BigNumber(y, b);\r\n      b = y.s;\r\n\r\n      // Either NaN?\r\n      if (!a || !b) return new BigNumber(NaN);\r\n\r\n      // Signs differ?\r\n       if (a != b) {\r\n        y.s = -b;\r\n        return x.minus(y);\r\n      }\r\n\r\n      var xe = x.e / LOG_BASE,\r\n        ye = y.e / LOG_BASE,\r\n        xc = x.c,\r\n        yc = y.c;\r\n\r\n      if (!xe || !ye) {\r\n\r\n        // Return ±Infinity if either ±Infinity.\r\n        if (!xc || !yc) return new BigNumber(a / 0);\r\n\r\n        // Either zero?\r\n        // Return y if y is non-zero, x if x is non-zero, or zero if both are zero.\r\n        if (!xc[0] || !yc[0]) return yc[0] ? y : new BigNumber(xc[0] ? x : a * 0);\r\n      }\r\n\r\n      xe = bitFloor(xe);\r\n      ye = bitFloor(ye);\r\n      xc = xc.slice();\r\n\r\n      // Prepend zeros to equalise exponents. Faster to use reverse then do unshifts.\r\n      if (a = xe - ye) {\r\n        if (a > 0) {\r\n          ye = xe;\r\n          t = yc;\r\n        } else {\r\n          a = -a;\r\n          t = xc;\r\n        }\r\n\r\n        t.reverse();\r\n        for (; a--; t.push(0));\r\n        t.reverse();\r\n      }\r\n\r\n      a = xc.length;\r\n      b = yc.length;\r\n\r\n      // Point xc to the longer array, and b to the shorter length.\r\n      if (a - b < 0) t = yc, yc = xc, xc = t, b = a;\r\n\r\n      // Only start adding at yc.length - 1 as the further digits of xc can be ignored.\r\n      for (a = 0; b;) {\r\n        a = (xc[--b] = xc[b] + yc[b] + a) / BASE | 0;\r\n        xc[b] = BASE === xc[b] ? 0 : xc[b] % BASE;\r\n      }\r\n\r\n      if (a) {\r\n        xc = [a].concat(xc);\r\n        ++ye;\r\n      }\r\n\r\n      // No need to check for zero, as +x + +y != 0 && -x + -y != 0\r\n      // ye = MAX_EXP + 1 possible\r\n      return normalise(y, xc, ye);\r\n    };\r\n\r\n\r\n    /*\r\n     * If sd is undefined or null or true or false, return the number of significant digits of\r\n     * the value of this BigNumber, or null if the value of this BigNumber is ±Infinity or NaN.\r\n     * If sd is true include integer-part trailing zeros in the count.\r\n     *\r\n     * Otherwise, if sd is a number, return a new BigNumber whose value is the value of this\r\n     * BigNumber rounded to a maximum of sd significant digits using rounding mode rm, or\r\n     * ROUNDING_MODE if rm is omitted.\r\n     *\r\n     * sd {number|boolean} number: significant digits: integer, 1 to MAX inclusive.\r\n     *                     boolean: whether to count integer-part trailing zeros: true or false.\r\n     * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n     *\r\n     * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {sd|rm}'\r\n     */\r\n    P.precision = P.sd = function (sd, rm) {\r\n      var c, n, v,\r\n        x = this;\r\n\r\n      if (sd != null && sd !== !!sd) {\r\n        intCheck(sd, 1, MAX);\r\n        if (rm == null) rm = ROUNDING_MODE;\r\n        else intCheck(rm, 0, 8);\r\n\r\n        return round(new BigNumber(x), sd, rm);\r\n      }\r\n\r\n      if (!(c = x.c)) return null;\r\n      v = c.length - 1;\r\n      n = v * LOG_BASE + 1;\r\n\r\n      if (v = c[v]) {\r\n\r\n        // Subtract the number of trailing zeros of the last element.\r\n        for (; v % 10 == 0; v /= 10, n--);\r\n\r\n        // Add the number of digits of the first element.\r\n        for (v = c[0]; v >= 10; v /= 10, n++);\r\n      }\r\n\r\n      if (sd && x.e + 1 > n) n = x.e + 1;\r\n\r\n      return n;\r\n    };\r\n\r\n\r\n    /*\r\n     * Return a new BigNumber whose value is the value of this BigNumber shifted by k places\r\n     * (powers of 10). Shift to the right if n > 0, and to the left if n < 0.\r\n     *\r\n     * k {number} Integer, -MAX_SAFE_INTEGER to MAX_SAFE_INTEGER inclusive.\r\n     *\r\n     * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {k}'\r\n     */\r\n    P.shiftedBy = function (k) {\r\n      intCheck(k, -MAX_SAFE_INTEGER, MAX_SAFE_INTEGER);\r\n      return this.times('1e' + k);\r\n    };\r\n\r\n\r\n    /*\r\n     *  sqrt(-n) =  N\r\n     *  sqrt(N) =  N\r\n     *  sqrt(-I) =  N\r\n     *  sqrt(I) =  I\r\n     *  sqrt(0) =  0\r\n     *  sqrt(-0) = -0\r\n     *\r\n     * Return a new BigNumber whose value is the square root of the value of this BigNumber,\r\n     * rounded according to DECIMAL_PLACES and ROUNDING_MODE.\r\n     */\r\n    P.squareRoot = P.sqrt = function () {\r\n      var m, n, r, rep, t,\r\n        x = this,\r\n        c = x.c,\r\n        s = x.s,\r\n        e = x.e,\r\n        dp = DECIMAL_PLACES + 4,\r\n        half = new BigNumber('0.5');\r\n\r\n      // Negative/NaN/Infinity/zero?\r\n      if (s !== 1 || !c || !c[0]) {\r\n        return new BigNumber(!s || s < 0 && (!c || c[0]) ? NaN : c ? x : 1 / 0);\r\n      }\r\n\r\n      // Initial estimate.\r\n      s = Math.sqrt(+valueOf(x));\r\n\r\n      // Math.sqrt underflow/overflow?\r\n      // Pass x to Math.sqrt as integer, then adjust the exponent of the result.\r\n      if (s == 0 || s == 1 / 0) {\r\n        n = coeffToString(c);\r\n        if ((n.length + e) % 2 == 0) n += '0';\r\n        s = Math.sqrt(+n);\r\n        e = bitFloor((e + 1) / 2) - (e < 0 || e % 2);\r\n\r\n        if (s == 1 / 0) {\r\n          n = '5e' + e;\r\n        } else {\r\n          n = s.toExponential();\r\n          n = n.slice(0, n.indexOf('e') + 1) + e;\r\n        }\r\n\r\n        r = new BigNumber(n);\r\n      } else {\r\n        r = new BigNumber(s + '');\r\n      }\r\n\r\n      // Check for zero.\r\n      // r could be zero if MIN_EXP is changed after the this value was created.\r\n      // This would cause a division by zero (x/t) and hence Infinity below, which would cause\r\n      // coeffToString to throw.\r\n      if (r.c[0]) {\r\n        e = r.e;\r\n        s = e + dp;\r\n        if (s < 3) s = 0;\r\n\r\n        // Newton-Raphson iteration.\r\n        for (; ;) {\r\n          t = r;\r\n          r = half.times(t.plus(div(x, t, dp, 1)));\r\n\r\n          if (coeffToString(t.c).slice(0, s) === (n = coeffToString(r.c)).slice(0, s)) {\r\n\r\n            // The exponent of r may here be one less than the final result exponent,\r\n            // e.g 0.0009999 (e-4) --> 0.001 (e-3), so adjust s so the rounding digits\r\n            // are indexed correctly.\r\n            if (r.e < e) --s;\r\n            n = n.slice(s - 3, s + 1);\r\n\r\n            // The 4th rounding digit may be in error by -1 so if the 4 rounding digits\r\n            // are 9999 or 4999 (i.e. approaching a rounding boundary) continue the\r\n            // iteration.\r\n            if (n == '9999' || !rep && n == '4999') {\r\n\r\n              // On the first iteration only, check to see if rounding up gives the\r\n              // exact result as the nines may infinitely repeat.\r\n              if (!rep) {\r\n                round(t, t.e + DECIMAL_PLACES + 2, 0);\r\n\r\n                if (t.times(t).eq(x)) {\r\n                  r = t;\r\n                  break;\r\n                }\r\n              }\r\n\r\n              dp += 4;\r\n              s += 4;\r\n              rep = 1;\r\n            } else {\r\n\r\n              // If rounding digits are null, 0{0,4} or 50{0,3}, check for exact\r\n              // result. If not, then there are further digits and m will be truthy.\r\n              if (!+n || !+n.slice(1) && n.charAt(0) == '5') {\r\n\r\n                // Truncate to the first rounding digit.\r\n                round(r, r.e + DECIMAL_PLACES + 2, 1);\r\n                m = !r.times(r).eq(x);\r\n              }\r\n\r\n              break;\r\n            }\r\n          }\r\n        }\r\n      }\r\n\r\n      return round(r, r.e + DECIMAL_PLACES + 1, ROUNDING_MODE, m);\r\n    };\r\n\r\n\r\n    /*\r\n     * Return a string representing the value of this BigNumber in exponential notation and\r\n     * rounded using ROUNDING_MODE to dp fixed decimal places.\r\n     *\r\n     * [dp] {number} Decimal places. Integer, 0 to MAX inclusive.\r\n     * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n     *\r\n     * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {dp|rm}'\r\n     */\r\n    P.toExponential = function (dp, rm) {\r\n      if (dp != null) {\r\n        intCheck(dp, 0, MAX);\r\n        dp++;\r\n      }\r\n      return format(this, dp, rm, 1);\r\n    };\r\n\r\n\r\n    /*\r\n     * Return a string representing the value of this BigNumber in fixed-point notation rounding\r\n     * to dp fixed decimal places using rounding mode rm, or ROUNDING_MODE if rm is omitted.\r\n     *\r\n     * Note: as with JavaScript's number type, (-0).toFixed(0) is '0',\r\n     * but e.g. (-0.00001).toFixed(0) is '-0'.\r\n     *\r\n     * [dp] {number} Decimal places. Integer, 0 to MAX inclusive.\r\n     * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n     *\r\n     * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {dp|rm}'\r\n     */\r\n    P.toFixed = function (dp, rm) {\r\n      if (dp != null) {\r\n        intCheck(dp, 0, MAX);\r\n        dp = dp + this.e + 1;\r\n      }\r\n      return format(this, dp, rm);\r\n    };\r\n\r\n\r\n    /*\r\n     * Return a string representing the value of this BigNumber in fixed-point notation rounded\r\n     * using rm or ROUNDING_MODE to dp decimal places, and formatted according to the properties\r\n     * of the format or FORMAT object (see BigNumber.set).\r\n     *\r\n     * The formatting object may contain some or all of the properties shown below.\r\n     *\r\n     * FORMAT = {\r\n     *   prefix: '',\r\n     *   groupSize: 3,\r\n     *   secondaryGroupSize: 0,\r\n     *   groupSeparator: ',',\r\n     *   decimalSeparator: '.',\r\n     *   fractionGroupSize: 0,\r\n     *   fractionGroupSeparator: '\\xA0',      // non-breaking space\r\n     *   suffix: ''\r\n     * };\r\n     *\r\n     * [dp] {number} Decimal places. Integer, 0 to MAX inclusive.\r\n     * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n     * [format] {object} Formatting options. See FORMAT pbject above.\r\n     *\r\n     * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {dp|rm}'\r\n     * '[BigNumber Error] Argument not an object: {format}'\r\n     */\r\n    P.toFormat = function (dp, rm, format) {\r\n      var str,\r\n        x = this;\r\n\r\n      if (format == null) {\r\n        if (dp != null && rm && typeof rm == 'object') {\r\n          format = rm;\r\n          rm = null;\r\n        } else if (dp && typeof dp == 'object') {\r\n          format = dp;\r\n          dp = rm = null;\r\n        } else {\r\n          format = FORMAT;\r\n        }\r\n      } else if (typeof format != 'object') {\r\n        throw Error\r\n          (bignumberError + 'Argument not an object: ' + format);\r\n      }\r\n\r\n      str = x.toFixed(dp, rm);\r\n\r\n      if (x.c) {\r\n        var i,\r\n          arr = str.split('.'),\r\n          g1 = +format.groupSize,\r\n          g2 = +format.secondaryGroupSize,\r\n          groupSeparator = format.groupSeparator || '',\r\n          intPart = arr[0],\r\n          fractionPart = arr[1],\r\n          isNeg = x.s < 0,\r\n          intDigits = isNeg ? intPart.slice(1) : intPart,\r\n          len = intDigits.length;\r\n\r\n        if (g2) i = g1, g1 = g2, g2 = i, len -= i;\r\n\r\n        if (g1 > 0 && len > 0) {\r\n          i = len % g1 || g1;\r\n          intPart = intDigits.substr(0, i);\r\n          for (; i < len; i += g1) intPart += groupSeparator + intDigits.substr(i, g1);\r\n          if (g2 > 0) intPart += groupSeparator + intDigits.slice(i);\r\n          if (isNeg) intPart = '-' + intPart;\r\n        }\r\n\r\n        str = fractionPart\r\n         ? intPart + (format.decimalSeparator || '') + ((g2 = +format.fractionGroupSize)\r\n          ? fractionPart.replace(new RegExp('\\\\d{' + g2 + '}\\\\B', 'g'),\r\n           '$&' + (format.fractionGroupSeparator || ''))\r\n          : fractionPart)\r\n         : intPart;\r\n      }\r\n\r\n      return (format.prefix || '') + str + (format.suffix || '');\r\n    };\r\n\r\n\r\n    /*\r\n     * Return an array of two BigNumbers representing the value of this BigNumber as a simple\r\n     * fraction with an integer numerator and an integer denominator.\r\n     * The denominator will be a positive non-zero value less than or equal to the specified\r\n     * maximum denominator. If a maximum denominator is not specified, the denominator will be\r\n     * the lowest value necessary to represent the number exactly.\r\n     *\r\n     * [md] {number|string|BigNumber} Integer >= 1, or Infinity. The maximum denominator.\r\n     *\r\n     * '[BigNumber Error] Argument {not an integer|out of range} : {md}'\r\n     */\r\n    P.toFraction = function (md) {\r\n      var d, d0, d1, d2, e, exp, n, n0, n1, q, r, s,\r\n        x = this,\r\n        xc = x.c;\r\n\r\n      if (md != null) {\r\n        n = new BigNumber(md);\r\n\r\n        // Throw if md is less than one or is not an integer, unless it is Infinity.\r\n        if (!n.isInteger() && (n.c || n.s !== 1) || n.lt(ONE)) {\r\n          throw Error\r\n            (bignumberError + 'Argument ' +\r\n              (n.isInteger() ? 'out of range: ' : 'not an integer: ') + valueOf(n));\r\n        }\r\n      }\r\n\r\n      if (!xc) return new BigNumber(x);\r\n\r\n      d = new BigNumber(ONE);\r\n      n1 = d0 = new BigNumber(ONE);\r\n      d1 = n0 = new BigNumber(ONE);\r\n      s = coeffToString(xc);\r\n\r\n      // Determine initial denominator.\r\n      // d is a power of 10 and the minimum max denominator that specifies the value exactly.\r\n      e = d.e = s.length - x.e - 1;\r\n      d.c[0] = POWS_TEN[(exp = e % LOG_BASE) < 0 ? LOG_BASE + exp : exp];\r\n      md = !md || n.comparedTo(d) > 0 ? (e > 0 ? d : n1) : n;\r\n\r\n      exp = MAX_EXP;\r\n      MAX_EXP = 1 / 0;\r\n      n = new BigNumber(s);\r\n\r\n      // n0 = d1 = 0\r\n      n0.c[0] = 0;\r\n\r\n      for (; ;)  {\r\n        q = div(n, d, 0, 1);\r\n        d2 = d0.plus(q.times(d1));\r\n        if (d2.comparedTo(md) == 1) break;\r\n        d0 = d1;\r\n        d1 = d2;\r\n        n1 = n0.plus(q.times(d2 = n1));\r\n        n0 = d2;\r\n        d = n.minus(q.times(d2 = d));\r\n        n = d2;\r\n      }\r\n\r\n      d2 = div(md.minus(d0), d1, 0, 1);\r\n      n0 = n0.plus(d2.times(n1));\r\n      d0 = d0.plus(d2.times(d1));\r\n      n0.s = n1.s = x.s;\r\n      e = e * 2;\r\n\r\n      // Determine which fraction is closer to x, n0/d0 or n1/d1\r\n      r = div(n1, d1, e, ROUNDING_MODE).minus(x).abs().comparedTo(\r\n          div(n0, d0, e, ROUNDING_MODE).minus(x).abs()) < 1 ? [n1, d1] : [n0, d0];\r\n\r\n      MAX_EXP = exp;\r\n\r\n      return r;\r\n    };\r\n\r\n\r\n    /*\r\n     * Return the value of this BigNumber converted to a number primitive.\r\n     */\r\n    P.toNumber = function () {\r\n      return +valueOf(this);\r\n    };\r\n\r\n\r\n    /*\r\n     * Return a string representing the value of this BigNumber rounded to sd significant digits\r\n     * using rounding mode rm or ROUNDING_MODE. If sd is less than the number of digits\r\n     * necessary to represent the integer part of the value in fixed-point notation, then use\r\n     * exponential notation.\r\n     *\r\n     * [sd] {number} Significant digits. Integer, 1 to MAX inclusive.\r\n     * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n     *\r\n     * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {sd|rm}'\r\n     */\r\n    P.toPrecision = function (sd, rm) {\r\n      if (sd != null) intCheck(sd, 1, MAX);\r\n      return format(this, sd, rm, 2);\r\n    };\r\n\r\n\r\n    /*\r\n     * Return a string representing the value of this BigNumber in base b, or base 10 if b is\r\n     * omitted. If a base is specified, including base 10, round according to DECIMAL_PLACES and\r\n     * ROUNDING_MODE. If a base is not specified, and this BigNumber has a positive exponent\r\n     * that is equal to or greater than TO_EXP_POS, or a negative exponent equal to or less than\r\n     * TO_EXP_NEG, return exponential notation.\r\n     *\r\n     * [b] {number} Integer, 2 to ALPHABET.length inclusive.\r\n     *\r\n     * '[BigNumber Error] Base {not a primitive number|not an integer|out of range}: {b}'\r\n     */\r\n    P.toString = function (b) {\r\n      var str,\r\n        n = this,\r\n        s = n.s,\r\n        e = n.e;\r\n\r\n      // Infinity or NaN?\r\n      if (e === null) {\r\n        if (s) {\r\n          str = 'Infinity';\r\n          if (s < 0) str = '-' + str;\r\n        } else {\r\n          str = 'NaN';\r\n        }\r\n      } else {\r\n        if (b == null) {\r\n          str = e <= TO_EXP_NEG || e >= TO_EXP_POS\r\n           ? toExponential(coeffToString(n.c), e)\r\n           : toFixedPoint(coeffToString(n.c), e, '0');\r\n        } else if (b === 10 && alphabetHasNormalDecimalDigits) {\r\n          n = round(new BigNumber(n), DECIMAL_PLACES + e + 1, ROUNDING_MODE);\r\n          str = toFixedPoint(coeffToString(n.c), n.e, '0');\r\n        } else {\r\n          intCheck(b, 2, ALPHABET.length, 'Base');\r\n          str = convertBase(toFixedPoint(coeffToString(n.c), e, '0'), 10, b, s, true);\r\n        }\r\n\r\n        if (s < 0 && n.c[0]) str = '-' + str;\r\n      }\r\n\r\n      return str;\r\n    };\r\n\r\n\r\n    /*\r\n     * Return as toString, but do not accept a base argument, and include the minus sign for\r\n     * negative zero.\r\n     */\r\n    P.valueOf = P.toJSON = function () {\r\n      return valueOf(this);\r\n    };\r\n\r\n\r\n    P._isBigNumber = true;\r\n\r\n    if (configObject != null) BigNumber.set(configObject);\r\n\r\n    return BigNumber;\r\n  }\r\n\r\n\r\n  // PRIVATE HELPER FUNCTIONS\r\n\r\n  // These functions don't need access to variables,\r\n  // e.g. DECIMAL_PLACES, in the scope of the `clone` function above.\r\n\r\n\r\n  function bitFloor(n) {\r\n    var i = n | 0;\r\n    return n > 0 || n === i ? i : i - 1;\r\n  }\r\n\r\n\r\n  // Return a coefficient array as a string of base 10 digits.\r\n  function coeffToString(a) {\r\n    var s, z,\r\n      i = 1,\r\n      j = a.length,\r\n      r = a[0] + '';\r\n\r\n    for (; i < j;) {\r\n      s = a[i++] + '';\r\n      z = LOG_BASE - s.length;\r\n      for (; z--; s = '0' + s);\r\n      r += s;\r\n    }\r\n\r\n    // Determine trailing zeros.\r\n    for (j = r.length; r.charCodeAt(--j) === 48;);\r\n\r\n    return r.slice(0, j + 1 || 1);\r\n  }\r\n\r\n\r\n  // Compare the value of BigNumbers x and y.\r\n  function compare(x, y) {\r\n    var a, b,\r\n      xc = x.c,\r\n      yc = y.c,\r\n      i = x.s,\r\n      j = y.s,\r\n      k = x.e,\r\n      l = y.e;\r\n\r\n    // Either NaN?\r\n    if (!i || !j) return null;\r\n\r\n    a = xc && !xc[0];\r\n    b = yc && !yc[0];\r\n\r\n    // Either zero?\r\n    if (a || b) return a ? b ? 0 : -j : i;\r\n\r\n    // Signs differ?\r\n    if (i != j) return i;\r\n\r\n    a = i < 0;\r\n    b = k == l;\r\n\r\n    // Either Infinity?\r\n    if (!xc || !yc) return b ? 0 : !xc ^ a ? 1 : -1;\r\n\r\n    // Compare exponents.\r\n    if (!b) return k > l ^ a ? 1 : -1;\r\n\r\n    j = (k = xc.length) < (l = yc.length) ? k : l;\r\n\r\n    // Compare digit by digit.\r\n    for (i = 0; i < j; i++) if (xc[i] != yc[i]) return xc[i] > yc[i] ^ a ? 1 : -1;\r\n\r\n    // Compare lengths.\r\n    return k == l ? 0 : k > l ^ a ? 1 : -1;\r\n  }\r\n\r\n\r\n  /*\r\n   * Check that n is a primitive number, an integer, and in range, otherwise throw.\r\n   */\r\n  function intCheck(n, min, max, name) {\r\n    if (n < min || n > max || n !== mathfloor(n)) {\r\n      throw Error\r\n       (bignumberError + (name || 'Argument') + (typeof n == 'number'\r\n         ? n < min || n > max ? ' out of range: ' : ' not an integer: '\r\n         : ' not a primitive number: ') + String(n));\r\n    }\r\n  }\r\n\r\n\r\n  // Assumes finite n.\r\n  function isOdd(n) {\r\n    var k = n.c.length - 1;\r\n    return bitFloor(n.e / LOG_BASE) == k && n.c[k] % 2 != 0;\r\n  }\r\n\r\n\r\n  function toExponential(str, e) {\r\n    return (str.length > 1 ? str.charAt(0) + '.' + str.slice(1) : str) +\r\n     (e < 0 ? 'e' : 'e+') + e;\r\n  }\r\n\r\n\r\n  function toFixedPoint(str, e, z) {\r\n    var len, zs;\r\n\r\n    // Negative exponent?\r\n    if (e < 0) {\r\n\r\n      // Prepend zeros.\r\n      for (zs = z + '.'; ++e; zs += z);\r\n      str = zs + str;\r\n\r\n    // Positive exponent\r\n    } else {\r\n      len = str.length;\r\n\r\n      // Append zeros.\r\n      if (++e > len) {\r\n        for (zs = z, e -= len; --e; zs += z);\r\n        str += zs;\r\n      } else if (e < len) {\r\n        str = str.slice(0, e) + '.' + str.slice(e);\r\n      }\r\n    }\r\n\r\n    return str;\r\n  }\r\n\r\n\r\n  // EXPORT\r\n\r\n\r\n  BigNumber = clone();\r\n  BigNumber['default'] = BigNumber.BigNumber = BigNumber;\r\n\r\n  // AMD.\r\n  if (typeof define == 'function' && define.amd) {\r\n    define(function () { return BigNumber; });\r\n\r\n  // Node.js and other environments that support module.exports.\r\n  } else if (typeof module != 'undefined' && module.exports) {\r\n    module.exports = BigNumber;\r\n\r\n  // Browser.\r\n  } else {\r\n    if (!globalObject) {\r\n      globalObject = typeof self != 'undefined' && self ? self : window;\r\n    }\r\n\r\n    globalObject.BigNumber = BigNumber;\r\n  }\r\n})(this);\r\n","var document = require('./_global').document;\nmodule.exports = document && document.documentElement;\n","var def = require('./_object-dp').f;\nvar has = require('./_has');\nvar TAG = require('./_wks')('toStringTag');\n\nmodule.exports = function (it, tag, stat) {\n  if (it && !has(it = stat ? it : it.prototype, TAG)) def(it, TAG, { configurable: true, value: tag });\n};\n","var nestRE = /^(attrs|props|on|nativeOn|class|style|hook)$/\n\nmodule.exports = function mergeJSXProps (objs) {\n  return objs.reduce(function (a, b) {\n    var aa, bb, key, nestedKey, temp\n    for (key in b) {\n      aa = a[key]\n      bb = b[key]\n      if (aa && nestRE.test(key)) {\n        // normalize class\n        if (key === 'class') {\n          if (typeof aa === 'string') {\n            temp = aa\n            a[key] = aa = {}\n            aa[temp] = true\n          }\n          if (typeof bb === 'string') {\n            temp = bb\n            b[key] = bb = {}\n            bb[temp] = true\n          }\n        }\n        if (key === 'on' || key === 'nativeOn' || key === 'hook') {\n          // merge functions\n          for (nestedKey in bb) {\n            aa[nestedKey] = mergeFn(aa[nestedKey], bb[nestedKey])\n          }\n        } else if (Array.isArray(aa)) {\n          a[key] = aa.concat(bb)\n        } else if (Array.isArray(bb)) {\n          a[key] = [aa].concat(bb)\n        } else {\n          for (nestedKey in bb) {\n            aa[nestedKey] = bb[nestedKey]\n          }\n        }\n      } else {\n        a[key] = b[key]\n      }\n    }\n    return a\n  }, {})\n}\n\nfunction mergeFn (a, b) {\n  return function () {\n    a && a.apply(this, arguments)\n    b && b.apply(this, arguments)\n  }\n}\n","module.exports = { \"default\": require(\"core-js/library/fn/is-iterable\"), __esModule: true };","// IE 8- don't enum bug keys\nmodule.exports = (\n  'constructor,hasOwnProperty,isPrototypeOf,propertyIsEnumerable,toLocaleString,toString,valueOf'\n).split(',');\n","// 19.1.2.14 / 15.2.3.14 Object.keys(O)\nvar $keys = require('./_object-keys-internal');\nvar enumBugKeys = require('./_enum-bug-keys');\n\nmodule.exports = Object.keys || function keys(O) {\n  return $keys(O, enumBugKeys);\n};\n","require('../../modules/es6.string.iterator');\nrequire('../../modules/es6.array.from');\nmodule.exports = require('../../modules/_core').Array.from;\n","\"use strict\";\n\nexports.__esModule = true;\n\nvar _from = require(\"../core-js/array/from\");\n\nvar _from2 = _interopRequireDefault(_from);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nexports.default = function (arr) {\n  if (Array.isArray(arr)) {\n    for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) {\n      arr2[i] = arr[i];\n    }\n\n    return arr2;\n  } else {\n    return (0, _from2.default)(arr);\n  }\n};","// optional / simple context binding\nvar aFunction = require('./_a-function');\nmodule.exports = function (fn, that, length) {\n  aFunction(fn);\n  if (that === undefined) return fn;\n  switch (length) {\n    case 1: return function (a) {\n      return fn.call(that, a);\n    };\n    case 2: return function (a, b) {\n      return fn.call(that, a, b);\n    };\n    case 3: return function (a, b, c) {\n      return fn.call(that, a, b, c);\n    };\n  }\n  return function (/* ...args */) {\n    return fn.apply(that, arguments);\n  };\n};\n","var hasOwnProperty = {}.hasOwnProperty;\nmodule.exports = function (it, key) {\n  return hasOwnProperty.call(it, key);\n};\n","var toInteger = require('./_to-integer');\nvar max = Math.max;\nvar min = Math.min;\nmodule.exports = function (index, length) {\n  index = toInteger(index);\n  return index < 0 ? max(index + length, 0) : min(index, length);\n};\n","// fallback for non-array-like ES3 and non-enumerable old V8 strings\nvar cof = require('./_cof');\n// eslint-disable-next-line no-prototype-builtins\nmodule.exports = Object('z').propertyIsEnumerable(0) ? Object : function (it) {\n  return cof(it) == 'String' ? it.split('') : Object(it);\n};\n","module.exports = { \"default\": require(\"core-js/library/fn/array/from\"), __esModule: true };","var anObject = require('./_an-object');\nvar get = require('./core.get-iterator-method');\nmodule.exports = require('./_core').getIterator = function (it) {\n  var iterFn = get(it);\n  if (typeof iterFn != 'function') throw TypeError(it + ' is not iterable!');\n  return anObject(iterFn.call(it));\n};\n","\"use strict\";\n\nexports.__esModule = true;\n\nvar _isIterable2 = require(\"../core-js/is-iterable\");\n\nvar _isIterable3 = _interopRequireDefault(_isIterable2);\n\nvar _getIterator2 = require(\"../core-js/get-iterator\");\n\nvar _getIterator3 = _interopRequireDefault(_getIterator2);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nexports.default = function () {\n  function sliceIterator(arr, i) {\n    var _arr = [];\n    var _n = true;\n    var _d = false;\n    var _e = undefined;\n\n    try {\n      for (var _i = (0, _getIterator3.default)(arr), _s; !(_n = (_s = _i.next()).done); _n = true) {\n        _arr.push(_s.value);\n\n        if (i && _arr.length === i) break;\n      }\n    } catch (err) {\n      _d = true;\n      _e = err;\n    } finally {\n      try {\n        if (!_n && _i[\"return\"]) _i[\"return\"]();\n      } finally {\n        if (_d) throw _e;\n      }\n    }\n\n    return _arr;\n  }\n\n  return function (arr, i) {\n    if (Array.isArray(arr)) {\n      return arr;\n    } else if ((0, _isIterable3.default)(Object(arr))) {\n      return sliceIterator(arr, i);\n    } else {\n      throw new TypeError(\"Invalid attempt to destructure non-iterable instance\");\n    }\n  };\n}();","var core = require('./_core');\nvar global = require('./_global');\nvar SHARED = '__core-js_shared__';\nvar store = global[SHARED] || (global[SHARED] = {});\n\n(module.exports = function (key, value) {\n  return store[key] || (store[key] = value !== undefined ? value : {});\n})('versions', []).push({\n  version: core.version,\n  mode: require('./_library') ? 'pure' : 'global',\n  copyright: '© 2020 Denis Pushkarev (zloirock.ru)'\n});\n","require('../../modules/es6.object.assign');\nmodule.exports = require('../../modules/_core').Object.assign;\n","module.exports = require('./_hide');\n","'use strict'\nvar ALPHABET = 'qpzry9x8gf2tvdw0s3jn54khce6mua7l'\n\n// pre-compute lookup table\nvar ALPHABET_MAP = {}\nfor (var z = 0; z < ALPHABET.length; z++) {\n  var x = ALPHABET.charAt(z)\n\n  if (ALPHABET_MAP[x] !== undefined) throw new TypeError(x + ' is ambiguous')\n  ALPHABET_MAP[x] = z\n}\n\nfunction polymodStep (pre) {\n  var b = pre >> 25\n  return ((pre & 0x1FFFFFF) << 5) ^\n    (-((b >> 0) & 1) & 0x3b6a57b2) ^\n    (-((b >> 1) & 1) & 0x26508e6d) ^\n    (-((b >> 2) & 1) & 0x1ea119fa) ^\n    (-((b >> 3) & 1) & 0x3d4233dd) ^\n    (-((b >> 4) & 1) & 0x2a1462b3)\n}\n\nfunction prefixChk (prefix) {\n  var chk = 1\n  for (var i = 0; i < prefix.length; ++i) {\n    var c = prefix.charCodeAt(i)\n    if (c < 33 || c > 126) return 'Invalid prefix (' + prefix + ')'\n\n    chk = polymodStep(chk) ^ (c >> 5)\n  }\n  chk = polymodStep(chk)\n\n  for (i = 0; i < prefix.length; ++i) {\n    var v = prefix.charCodeAt(i)\n    chk = polymodStep(chk) ^ (v & 0x1f)\n  }\n  return chk\n}\n\nfunction encode (prefix, words, LIMIT) {\n  LIMIT = LIMIT || 90\n  if ((prefix.length + 7 + words.length) > LIMIT) throw new TypeError('Exceeds length limit')\n\n  prefix = prefix.toLowerCase()\n\n  // determine chk mod\n  var chk = prefixChk(prefix)\n  if (typeof chk === 'string') throw new Error(chk)\n\n  var result = prefix + '1'\n  for (var i = 0; i < words.length; ++i) {\n    var x = words[i]\n    if ((x >> 5) !== 0) throw new Error('Non 5-bit word')\n\n    chk = polymodStep(chk) ^ x\n    result += ALPHABET.charAt(x)\n  }\n\n  for (i = 0; i < 6; ++i) {\n    chk = polymodStep(chk)\n  }\n  chk ^= 1\n\n  for (i = 0; i < 6; ++i) {\n    var v = (chk >> ((5 - i) * 5)) & 0x1f\n    result += ALPHABET.charAt(v)\n  }\n\n  return result\n}\n\nfunction __decode (str, LIMIT) {\n  LIMIT = LIMIT || 90\n  if (str.length < 8) return str + ' too short'\n  if (str.length > LIMIT) return 'Exceeds length limit'\n\n  // don't allow mixed case\n  var lowered = str.toLowerCase()\n  var uppered = str.toUpperCase()\n  if (str !== lowered && str !== uppered) return 'Mixed-case string ' + str\n  str = lowered\n\n  var split = str.lastIndexOf('1')\n  if (split === -1) return 'No separator character for ' + str\n  if (split === 0) return 'Missing prefix for ' + str\n\n  var prefix = str.slice(0, split)\n  var wordChars = str.slice(split + 1)\n  if (wordChars.length < 6) return 'Data too short'\n\n  var chk = prefixChk(prefix)\n  if (typeof chk === 'string') return chk\n\n  var words = []\n  for (var i = 0; i < wordChars.length; ++i) {\n    var c = wordChars.charAt(i)\n    var v = ALPHABET_MAP[c]\n    if (v === undefined) return 'Unknown character ' + c\n    chk = polymodStep(chk) ^ v\n\n    // not in the checksum?\n    if (i + 6 >= wordChars.length) continue\n    words.push(v)\n  }\n\n  if (chk !== 1) return 'Invalid checksum for ' + str\n  return { prefix: prefix, words: words }\n}\n\nfunction decodeUnsafe () {\n  var res = __decode.apply(null, arguments)\n  if (typeof res === 'object') return res\n}\n\nfunction decode (str) {\n  var res = __decode.apply(null, arguments)\n  if (typeof res === 'object') return res\n\n  throw new Error(res)\n}\n\nfunction convert (data, inBits, outBits, pad) {\n  var value = 0\n  var bits = 0\n  var maxV = (1 << outBits) - 1\n\n  var result = []\n  for (var i = 0; i < data.length; ++i) {\n    value = (value << inBits) | data[i]\n    bits += inBits\n\n    while (bits >= outBits) {\n      bits -= outBits\n      result.push((value >> bits) & maxV)\n    }\n  }\n\n  if (pad) {\n    if (bits > 0) {\n      result.push((value << (outBits - bits)) & maxV)\n    }\n  } else {\n    if (bits >= inBits) return 'Excess padding'\n    if ((value << (outBits - bits)) & maxV) return 'Non-zero padding'\n  }\n\n  return result\n}\n\nfunction toWordsUnsafe (bytes) {\n  var res = convert(bytes, 8, 5, true)\n  if (Array.isArray(res)) return res\n}\n\nfunction toWords (bytes) {\n  var res = convert(bytes, 8, 5, true)\n  if (Array.isArray(res)) return res\n\n  throw new Error(res)\n}\n\nfunction fromWordsUnsafe (words) {\n  var res = convert(words, 5, 8, false)\n  if (Array.isArray(res)) return res\n}\n\nfunction fromWords (words) {\n  var res = convert(words, 5, 8, false)\n  if (Array.isArray(res)) return res\n\n  throw new Error(res)\n}\n\nmodule.exports = {\n  decodeUnsafe: decodeUnsafe,\n  decode: decode,\n  encode: encode,\n  toWordsUnsafe: toWordsUnsafe,\n  toWords: toWords,\n  fromWordsUnsafe: fromWordsUnsafe,\n  fromWords: fromWords\n}\n","var $export = require('./_export');\n// 19.1.2.4 / 15.2.3.6 Object.defineProperty(O, P, Attributes)\n$export($export.S + $export.F * !require('./_descriptors'), 'Object', { defineProperty: require('./_object-dp').f });\n","// call something on iterator step with safe closing on error\nvar anObject = require('./_an-object');\nmodule.exports = function (iterator, fn, value, entries) {\n  try {\n    return entries ? fn(anObject(value)[0], value[1]) : fn(value);\n  // 7.4.6 IteratorClose(iterator, completion)\n  } catch (e) {\n    var ret = iterator['return'];\n    if (ret !== undefined) anObject(ret.call(iterator));\n    throw e;\n  }\n};\n","// 7.2.1 RequireObjectCoercible(argument)\nmodule.exports = function (it) {\n  if (it == undefined) throw TypeError(\"Can't call method on  \" + it);\n  return it;\n};\n","var store = require('./_shared')('wks');\nvar uid = require('./_uid');\nvar Symbol = require('./_global').Symbol;\nvar USE_SYMBOL = typeof Symbol == 'function';\n\nvar $exports = module.exports = function (name) {\n  return store[name] || (store[name] =\n    USE_SYMBOL && Symbol[name] || (USE_SYMBOL ? Symbol : uid)('Symbol.' + name));\n};\n\n$exports.store = store;\n","// 19.1.2.9 / 15.2.3.2 Object.getPrototypeOf(O)\nvar has = require('./_has');\nvar toObject = require('./_to-object');\nvar IE_PROTO = require('./_shared-key')('IE_PROTO');\nvar ObjectProto = Object.prototype;\n\nmodule.exports = Object.getPrototypeOf || function (O) {\n  O = toObject(O);\n  if (has(O, IE_PROTO)) return O[IE_PROTO];\n  if (typeof O.constructor == 'function' && O instanceof O.constructor) {\n    return O.constructor.prototype;\n  } return O instanceof Object ? ObjectProto : null;\n};\n","// 7.1.15 ToLength\nvar toInteger = require('./_to-integer');\nvar min = Math.min;\nmodule.exports = function (it) {\n  return it > 0 ? min(toInteger(it), 0x1fffffffffffff) : 0; // pow(2, 53) - 1 == 9007199254740991\n};\n","var global = require('./_global');\nvar core = require('./_core');\nvar LIBRARY = require('./_library');\nvar wksExt = require('./_wks-ext');\nvar defineProperty = require('./_object-dp').f;\nmodule.exports = function (name) {\n  var $Symbol = core.Symbol || (core.Symbol = LIBRARY ? {} : global.Symbol || {});\n  if (name.charAt(0) != '_' && !(name in $Symbol)) defineProperty($Symbol, name, { value: wksExt.f(name) });\n};\n","var META = require('./_uid')('meta');\nvar isObject = require('./_is-object');\nvar has = require('./_has');\nvar setDesc = require('./_object-dp').f;\nvar id = 0;\nvar isExtensible = Object.isExtensible || function () {\n  return true;\n};\nvar FREEZE = !require('./_fails')(function () {\n  return isExtensible(Object.preventExtensions({}));\n});\nvar setMeta = function (it) {\n  setDesc(it, META, { value: {\n    i: 'O' + ++id, // object ID\n    w: {}          // weak collections IDs\n  } });\n};\nvar fastKey = function (it, create) {\n  // return primitive with prefix\n  if (!isObject(it)) return typeof it == 'symbol' ? it : (typeof it == 'string' ? 'S' : 'P') + it;\n  if (!has(it, META)) {\n    // can't set metadata to uncaught frozen object\n    if (!isExtensible(it)) return 'F';\n    // not necessary to add metadata\n    if (!create) return 'E';\n    // add missing metadata\n    setMeta(it);\n  // return object ID\n  } return it[META].i;\n};\nvar getWeak = function (it, create) {\n  if (!has(it, META)) {\n    // can't set metadata to uncaught frozen object\n    if (!isExtensible(it)) return true;\n    // not necessary to add metadata\n    if (!create) return false;\n    // add missing metadata\n    setMeta(it);\n  // return hash weak collections IDs\n  } return it[META].w;\n};\n// add metadata on freeze-family methods calling\nvar onFreeze = function (it) {\n  if (FREEZE && meta.NEED && isExtensible(it) && !has(it, META)) setMeta(it);\n  return it;\n};\nvar meta = module.exports = {\n  KEY: META,\n  NEED: false,\n  fastKey: fastKey,\n  getWeak: getWeak,\n  onFreeze: onFreeze\n};\n","module.exports = true;\n","// 19.1.3.1 Object.assign(target, source)\nvar $export = require('./_export');\n\n$export($export.S + $export.F, 'Object', { assign: require('./_object-assign') });\n","module.exports = function (done, value) {\n  return { value: value, done: !!done };\n};\n","// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028\nvar global = module.exports = typeof window != 'undefined' && window.Math == Math\n  ? window : typeof self != 'undefined' && self.Math == Math ? self\n  // eslint-disable-next-line no-new-func\n  : Function('return this')();\nif (typeof __g == 'number') __g = global; // eslint-disable-line no-undef\n","module.exports = { \"default\": require(\"core-js/library/fn/symbol\"), __esModule: true };","module.exports = !require('./_descriptors') && !require('./_fails')(function () {\n  return Object.defineProperty(require('./_dom-create')('div'), 'a', { get: function () { return 7; } }).a != 7;\n});\n","// 7.1.4 ToInteger\nvar ceil = Math.ceil;\nvar floor = Math.floor;\nmodule.exports = function (it) {\n  return isNaN(it = +it) ? 0 : (it > 0 ? floor : ceil)(it);\n};\n","exports.f = require('./_wks');\n","exports.f = Object.getOwnPropertySymbols;\n"],"sourceRoot":""}