{"version":3,"sources":["webpack:///bundle.js","webpack:///webpack/bootstrap 341a3223c6a7219097e2","webpack:///./node_modules/elliptic/lib/elliptic.js","webpack:///./node_modules/bn.js/lib/bn.js","webpack:///./node_modules/buffer/index.js","webpack:///./node_modules/inherits/inherits_browser.js","webpack:///./node_modules/hash.js/lib/hash/utils.js","webpack:///(webpack)/buildin/global.js","webpack:///./node_modules/minimalistic-assert/index.js","webpack:///./node_modules/readable-stream/lib/_stream_duplex.js","webpack:///./node_modules/hash.js/lib/hash/common.js","webpack:///./node_modules/process/browser.js","webpack:///./node_modules/core-util-is/lib/util.js","webpack:///./node_modules/elliptic/lib/elliptic/curve/index.js","webpack:///./../lib/rlp.js","webpack:///./node_modules/process-nextick-args/index.js","webpack:///./node_modules/safe-buffer/index.js","webpack:///./node_modules/hash.js/lib/hash.js","webpack:///./node_modules/util/util.js","webpack:///./../lib/keccak/index.js","webpack:///./node_modules/events/events.js","webpack:///./node_modules/readable-stream/readable-browser.js","webpack:///./node_modules/readable-stream/lib/_stream_writable.js","webpack:///./node_modules/isarray/index.js","webpack:///./node_modules/minimalistic-crypto-utils/lib/utils.js","webpack:///./node_modules/hash.js/lib/hash/sha/common.js","webpack:///./node_modules/hash.js/lib/hash/sha/256.js","webpack:///./node_modules/hash.js/lib/hash/sha/512.js","webpack:///./node_modules/assert/assert.js","webpack:///./node_modules/stream-browserify/index.js","webpack:///./node_modules/readable-stream/lib/_stream_readable.js","webpack:///./node_modules/readable-stream/lib/internal/streams/stream-browser.js","webpack:///./node_modules/readable-stream/lib/internal/streams/destroy.js","webpack:///./node_modules/string_decoder/lib/string_decoder.js","webpack:///./node_modules/readable-stream/lib/_stream_transform.js","webpack:///./../lib/keypairs.js","webpack:///./src/globals.js","webpack:///./node_modules/base64-js/index.js","webpack:///./node_modules/ieee754/index.js","webpack:///(webpack)/buildin/module.js","webpack:///./../index.js","webpack:///./node_modules/elliptic/package.json","webpack:///./node_modules/elliptic/lib/elliptic/utils.js","webpack:///./node_modules/brorand/index.js","webpack:///./node_modules/elliptic/lib/elliptic/curve/base.js","webpack:///./node_modules/elliptic/lib/elliptic/curve/short.js","webpack:///./node_modules/elliptic/lib/elliptic/curve/mont.js","webpack:///./node_modules/elliptic/lib/elliptic/curve/edwards.js","webpack:///./node_modules/elliptic/lib/elliptic/curves.js","webpack:///./node_modules/hash.js/lib/hash/sha.js","webpack:///./node_modules/hash.js/lib/hash/sha/1.js","webpack:///./node_modules/hash.js/lib/hash/sha/224.js","webpack:///./node_modules/hash.js/lib/hash/sha/384.js","webpack:///./node_modules/hash.js/lib/hash/ripemd.js","webpack:///./node_modules/hash.js/lib/hash/hmac.js","webpack:///./node_modules/elliptic/lib/elliptic/precomputed/secp256k1.js","webpack:///./node_modules/elliptic/lib/elliptic/ec/index.js","webpack:///./node_modules/hmac-drbg/lib/hmac-drbg.js","webpack:///./node_modules/elliptic/lib/elliptic/ec/key.js","webpack:///./node_modules/elliptic/lib/elliptic/ec/signature.js","webpack:///./node_modules/elliptic/lib/elliptic/eddsa/index.js","webpack:///./node_modules/elliptic/lib/elliptic/eddsa/key.js","webpack:///./node_modules/elliptic/lib/elliptic/eddsa/signature.js","webpack:///./../node_modules/@warren-bank/ethereumjs-tx-unsign/index.js","webpack:///./../node_modules/@warren-bank/ethereumjs-tx-unsign/lib/rlp.js","webpack:///./node_modules/util/support/isBufferBrowser.js","webpack:///./../lib/keccak/api/index.js","webpack:///./../lib/keccak/api/keccak.js","webpack:///./node_modules/readable-stream/lib/internal/streams/BufferList.js","webpack:///./node_modules/timers-browserify/main.js","webpack:///./node_modules/setimmediate/setImmediate.js","webpack:///./node_modules/util-deprecate/browser.js","webpack:///./node_modules/readable-stream/lib/_stream_passthrough.js","webpack:///./node_modules/readable-stream/writable-browser.js","webpack:///./node_modules/readable-stream/duplex-browser.js","webpack:///./node_modules/readable-stream/transform.js","webpack:///./node_modules/readable-stream/passthrough.js","webpack:///./../lib/keccak/api/shake.js","webpack:///./../lib/keccak/keccak.js","webpack:///./../lib/keccak/keccak-state-unroll.js"],"names":["modules","__webpack_require__","moduleId","installedModules","exports","module","i","l","call","m","c","d","name","getter","o","Object","defineProperty","configurable","enumerable","get","n","__esModule","object","property","prototype","hasOwnProperty","p","s","elliptic","version","utils","rand","curve","curves","ec","eddsa","_typeof","Symbol","iterator","obj","constructor","assert","val","msg","Error","inherits","ctor","superCtor","super_","TempCtor","BN","number","base","endian","isBN","this","negative","words","length","red","_init","parseHex","str","start","end","r","len","Math","min","charCodeAt","parseBase","mul","toBitArray","num","w","Array","bitLength","bit","off","wbit","smallMulTo","self","out","a","b","lo","carry","k","ncarry","rword","maxJ","j","max","strip","bigMulTo","hncarry","jumboMulTo","FFTM","mulp","x","y","MPrime","iushln","isub","tmp","_tmp","K256","P224","P192","P25519","Red","prime","_prime","gtn","Mont","shift","r2","imod","sqr","rinv","_invmp","minv","isubn","div","umod","sub","wordSize","Buffer","e","isArray","left","right","cmp","_initNumber","_initArray","toString","replace","_parseHex","_parseBase","toArray","ceil","limbLen","limbPow","total","mod","word","imuln","_iaddn","pow","copy","dest","clone","_expand","size","_normSign","inspect","zeros","groupSizes","groupBases","padding","groupSize","groupBase","isZero","modn","idivn","toNumber","ret","toJSON","toBuffer","toArrayLike","ArrayType","byteLength","reqLength","littleEndian","res","q","andln","iushrn","clz32","_countBits","t","_zeroBits","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","iadd","add","comb10MulTo","mid","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","imul","w0","w1","w2","w3","w4","w5","w6","w7","w8","w9","w10","w11","w12","w13","w14","w15","w16","w17","w18","mulTo","makeRBT","N","revBin","rb","permute","rbt","rws","iws","rtws","itws","transform","rtwdf","cos","PI","itwdf","sin","rtwdf_","itwdf_","re","ie","ro","io","rx","guessLen13b","odd","conjugate","normalize13b","ws","round","convert13b","stub","ph","_","rwst","iwst","nrws","nrwst","niwst","rmws","mulf","muln","isqr","bits","carryMask","newCarry","ishln","hint","extended","h","mask","maskedWords","ishrn","shln","ushln","shrn","ushrn","imaskn","maskn","addn","subn","iabs","_ishlnsubmul","_wordDiv","mode","bhi","diff","qj","divmod","positive","divn","divRound","dm","half","acc","egcd","A","B","C","D","g","isEven","yp","xp","im","isOdd","jm","gcd","x1","x2","delta","cmpn","invm","bincn","ucmp","gt","gten","gte","ltn","lt","lten","lte","eqn","eq","toRed","ctx","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","ireduce","rlen","split","imulK","input","output","outLen","prev","next","mod3","one","nOne","lpow","z","inv","wnd","current","currentLen","mont","u","undefined","global","kMaxLength","TYPED_ARRAY_SUPPORT","createBuffer","that","RangeError","Uint8Array","__proto__","arg","encodingOrOffset","allocUnsafe","from","value","TypeError","ArrayBuffer","fromArrayBuffer","fromString","fromObject","assertSize","alloc","fill","encoding","checked","string","isEncoding","actual","write","slice","fromArrayLike","array","byteOffset","isBuffer","buffer","isnan","type","data","SlowBuffer","isView","loweredCase","utf8ToBytes","base64ToBytes","toLowerCase","slowToString","hexSlice","utf8Slice","asciiSlice","latin1Slice","base64Slice","utf16leSlice","swap","bidirectionalIndexOf","dir","isNaN","arrayIndexOf","indexOf","lastIndexOf","arr","read","buf","indexSize","readUInt16BE","arrLength","valLength","String","foundIndex","found","hexWrite","offset","Number","remaining","strLen","parsed","parseInt","substr","utf8Write","blitBuffer","asciiWrite","asciiToBytes","latin1Write","base64Write","ucs2Write","utf16leToBytes","base64","fromByteArray","firstByte","codePoint","bytesPerSequence","secondByte","thirdByte","fourthByte","tempCodePoint","push","decodeCodePointsArray","codePoints","MAX_ARGUMENTS_LENGTH","fromCharCode","apply","toHex","bytes","checkOffset","ext","checkInt","objectWriteUInt16","objectWriteUInt32","checkIEEE754","writeFloat","noAssert","ieee754","writeDouble","base64clean","stringtrim","INVALID_BASE64_RE","trim","units","Infinity","leadSurrogate","byteArray","toByteArray","src","dst","INSPECT_MAX_BYTES","foo","subarray","poolSize","_augment","species","allocUnsafeSlow","_isBuffer","compare","concat","list","pos","swap16","swap32","swap64","arguments","equals","match","join","target","thisStart","thisEnd","thisCopy","targetCopy","includes","isFinite","_arr","newBuf","sliceLen","readUIntLE","readUIntBE","readUInt8","readUInt16LE","readUInt32LE","readUInt32BE","readIntLE","readIntBE","readInt8","readInt16LE","readInt16BE","readInt32LE","readInt32BE","readFloatLE","readFloatBE","readDoubleLE","readDoubleBE","writeUIntLE","writeUIntBE","writeUInt8","floor","writeUInt16LE","writeUInt16BE","writeUInt32LE","writeUInt32BE","writeIntLE","limit","writeIntBE","writeInt8","writeInt16LE","writeInt16BE","writeInt32LE","writeInt32BE","writeFloatLE","writeFloatBE","writeDoubleLE","writeDoubleBE","targetStart","set","code","create","writable","enc","zero2","htonl","toHex32","zero8","join32","split32","rotr32","rotl32","sum32","sum32_3","sum32_4","sum32_5","sum64","ah","al","bh","bl","sum64_hi","sum64_lo","sum64_4_hi","ch","cl","dh","dl","sum64_4_lo","sum64_5_hi","eh","el","sum64_5_lo","rotr64_hi","rotr64_lo","shr64_hi","shr64_lo","Function","eval","window","equal","Duplex","options","Readable","Writable","readable","allowHalfOpen","once","onend","_writableState","ended","processNextTick","onEndNT","objectKeys","keys","key","util","v","method","_readableState","destroyed","_destroy","err","cb","BlockHash","pending","pendingTotal","blockSize","outSize","hmacStrength","padLength","_delta8","_delta32","update","_update","digest","_pad","_digest","defaultSetTimout","defaultClearTimeout","runTimeout","fun","cachedSetTimeout","setTimeout","runClearTimeout","marker","cachedClearTimeout","clearTimeout","cleanUpNextTick","draining","currentQueue","queue","queueIndex","drainQueue","timeout","run","Item","noop","process","nextTick","args","title","browser","env","argv","versions","on","addListener","removeListener","removeAllListeners","emit","prependListener","prependOnceListener","listeners","binding","cwd","chdir","umask","objectToString","isBoolean","isNull","isNullOrUndefined","isNumber","isString","isSymbol","isUndefined","isRegExp","isObject","isDate","isError","isFunction","isPrimitive","short","edwards","encode","encodeLength","hexLength","intToHex","lLength","isHexPrefixed","stripHexPrefix","stripZeros","first","hex","padToEven","intToBuffer","bufferToHex","add_prefix","bufferToInt","fn","arg1","arg2","arg3","copyProps","SafeBuffer","hash","common","sha","ripemd","hmac","sha1","sha256","sha224","sha384","sha512","ripemd160","opts","seen","stylize","stylizeNoColor","depth","colors","showHidden","_extend","customInspect","stylizeWithColor","formatValue","styleType","style","styles","arrayToHash","forEach","idx","recurseTimes","primitive","formatPrimitive","visibleKeys","getOwnPropertyNames","formatError","RegExp","Date","braces","toUTCString","formatArray","map","formatProperty","pop","reduceToSingleString","simple","JSON","stringify","desc","getOwnPropertyDescriptor","line","numLinesEst","reduce","cur","ar","pad","timestamp","time","getHours","getMinutes","getSeconds","getDate","months","getMonth","prop","formatRegExp","format","f","objects","deprecate","deprecated","warned","throwDeprecation","traceDeprecation","console","trace","error","noDeprecation","debugEnviron","debugs","debuglog","NODE_ENV","NODE_DEBUG","toUpperCase","test","pid","bold","italic","underline","inverse","white","grey","black","blue","cyan","green","magenta","yellow","special","boolean","null","date","regexp","log","origin","createKeccakHash","sha3","EventEmitter","_events","_maxListeners","defaultMaxListeners","setMaxListeners","er","handler","context","listener","newListener","fired","position","splice","listenerCount","evlistener","emitter","Stream","Transform","PassThrough","setImmediate","CorkedRequest","state","_this","entry","finish","onCorkedFinish","_uint8ArrayToBuffer","chunk","_isUint8Array","OurUint8Array","nop","WritableState","stream","objectMode","writableObjectMode","hwm","highWaterMark","defaultHwm","finalCalled","needDrain","ending","finished","noDecode","decodeStrings","defaultEncoding","writing","corked","sync","bufferProcessing","onwrite","writecb","writelen","bufferedRequest","lastBufferedRequest","pendingcb","prefinished","errorEmitted","bufferedRequestCount","corkedRequestsFree","realHasInstance","_write","writev","_writev","destroy","final","_final","writeAfterEnd","validChunk","valid","decodeChunk","writeOrBuffer","isBuf","newChunk","last","callback","doWrite","onwriteError","finishMaybe","onwriteStateUpdate","needFinish","clearBuffer","asyncWrite","afterWrite","onwriteDrain","holder","count","allBuffers","callFinal","prefinish","need","endWritable","corkReq","internalUtil","destroyImpl","getBuffer","hasInstance","pipe","cork","uncork","setDefaultEncoding","_undestroy","undestroy","ft_1","ch32","p32","maj32","s0_256","s1_256","g0_256","g1_256","SHA256","sha256_K","W","shaCommon","T1","T2","SHA512","sha512_K","ch64_hi","xh","xl","yh","yl","zh","ch64_lo","zl","maj64_hi","maj64_lo","s0_512_hi","c0_hi","c1_hi","c2_hi","s0_512_lo","c0_lo","c1_lo","c2_lo","s1_512_hi","s1_512_lo","g0_512_hi","g0_512_lo","g1_512_hi","g1_512_lo","_prepareBlock","c3_hi","c3_lo","fh","fl","gh","gl","hh","hl","c4_hi","c4_lo","T1_hi","T1_lo","T2_hi","T2_lo","pToString","arrbuf","DataView","getName","func","functionsHaveNames","regex","truncate","something","rawname","getMessage","operator","expected","fail","message","stackStartFunction","AssertionError","ok","_deepEqual","strict","memos","getTime","source","multiline","lastIndex","ignoreCase","Float32Array","Float64Array","actualIndex","objEquiv","isArguments","actualVisitedObjects","getPrototypeOf","aIsArgs","bIsArgs","pSlice","ka","kb","sort","notDeepStrictEqual","expectedException","isPrototypeOf","_tryBlock","block","_throws","shouldThrow","userProvidedMessage","isUnwantedException","isUnexpectedException","hasOwn","generatedMessage","captureStackTrace","stack","fn_name","next_line","substring","notEqual","deepEqual","deepStrictEqual","notDeepEqual","strictEqual","notStrictEqual","throws","doesNotThrow","ifError","EE","ondata","pause","ondrain","resume","didOnEnd","onclose","onerror","cleanup","_isStdio","event","unshift","ReadableState","readableObjectMode","BufferList","pipes","pipesCount","flowing","endEmitted","reading","needReadable","emittedReadable","readableListening","resumeScheduled","awaitDrain","readingMore","decoder","StringDecoder","_read","readableAddChunk","addToFront","skipChunkCheck","onEofChunk","chunkInvalid","addChunk","maybeReadMore","needMoreData","emitReadable","computeNewHighWaterMark","MAX_HWM","howMuchToRead","head","debug","emitReadable_","flow","maybeReadMore_","pipeOnDrain","EElistenerCount","nReadingNextTick","resume_","fromList","clear","fromListPartial","hasStrings","copyFromBufferString","copyFromBuffer","nb","tail","endReadable","endReadableNT","xs","debugUtil","kProxyEvents","isPaused","setEncoding","nOrig","doRead","pipeOpts","onunpipe","unpipeInfo","hasUnpiped","onfinish","unpipe","cleanedUp","increasedAwaitDrain","doEnd","stdout","stderr","endFn","dests","index","ev","wrap","paused","bind","_fromList","readableDestroyed","writableDestroyed","emitErrorNT","_normalizeEncoding","retried","normalizeEncoding","nenc","text","utf16Text","utf16End","fillLast","utf8FillLast","base64Text","base64End","simpleWrite","simpleEnd","lastNeed","lastTotal","lastChar","utf8CheckByte","byte","utf8CheckIncomplete","utf8CheckExtraBytes","repeat","utf8Text","utf8End","TransformState","afterTransform","needTransform","transforming","writechunk","writeencoding","ts","_transformState","rs","_transform","flush","_flush","done","err2","EC","ecparams","rlp","_require","privateToPublic","privateKey","compressed","keyFromPrivate","getPublic","publicToAddress","publicKey","genKeyPair","getPrivate","address","_require2","sign","verify","unsign","_require3","_require4","_require5","ethereumjs_tx_sign","keypairs","keccak","placeHoldersCount","b64","placeHolders","Arr","L","revLookup","tripletToBase64","lookup","encodeChunk","uint8","extraBytes","parts","len2","isLE","mLen","nBytes","eLen","eMax","eBias","nBits","NaN","rt","LN2","webpackPolyfill","paths","children","unsignRawTx","fields","allowLess","default","alias","allowZero","process_data","use_defaults","raw","field","get_field_value","get_signature","rawData","chainId","msgHash","get_hash","_get_raw_signature","get_raw_signature","DER","sig","rawSigData","format_raw_signature","signature","items","signed_msgHash","canonical","toDER","recovery","recoveryParam","_get_signature","rawTx","sigObj","sigr","sigs","nh","_unsignRawTx","txData","ec_msgHash","ec_signature","ec_recovery","recoverPubKey","_args","_development","_from","_id","_inBundle","_integrity","_location","_phantomChildren","_requested","registry","escapedName","rawSpec","saveSpec","fetchSpec","_requiredBy","_resolved","_spec","_where","author","email","bugs","url","dependencies","bn.js","brorand","hash.js","hmac-drbg","minimalistic-assert","minimalistic-crypto-utils","description","devDependencies","brfs","coveralls","grunt","grunt-browserify","grunt-cli","grunt-contrib-connect","grunt-contrib-copy","grunt-contrib-uglify","grunt-mocha-istanbul","grunt-saucelabs","istanbul","jscs","jshint","mocha","files","homepage","keywords","license","main","repository","scripts","lint","unit","getNAF","naf","getJSF","k1","k2","jsf","d1","d2","m14","m24","u1","m8","u2","cachedProperty","computer","parseBytes","intFromLE","minAssert","minUtils","Rand","generate","_rand","getBytes","getByte","crypto","getRandomValues","msCrypto","randomBytes","BaseCurve","conf","zero","two","pointFromJSON","gRed","_wnafT1","_wnafT2","_wnafT3","_wnafT4","adjustCount","redN","_maxwellTrick","BasePoint","precomputed","point","validate","_fixedNafMul","doubles","_getDoubles","I","step","repr","nafW","jpoint","mixedAdd","points","toP","_wnafMul","nafPoints","_getNAFPoints","dblp","_wnafMulAdd","defW","coeffs","jacobianResult","wndWidth","comb","toJ","ja","jb","decodePoint","pointFromX","encodeCompressed","_encode","compact","getX","getY","precompute","power","beta","_getBeta","_hasDoubles","dbl","ShortCurve","Base","tinv","zeroA","threeA","endo","_getEndomorphism","_endoWnafT1","_endoWnafT2","Point","isRed","inf","JPoint","zOne","lambda","betas","_getEndoRoots","lambdas","basis","vec","_getEndoBasis","ntinv","prevR","aprxSqrt","y1","y2","len1","_endoSplit","v1","v2","c1","c2","p1","p2","q1","q2","ax","rhs","_endoWnafMulAdd","npoints","ncoeffs","fromJSON","pre","endoMul","obj2point","parse","isInfinity","nx","ny","ys1","dyinv","mulAdd","jmulAdd","_precompute","negate","zinv","zinv2","ay","pz2","z2","s1","s2","h2","h3","nz","jx","jy","jz","jz4","jyd","jx2","jyd2","jyd4","t1","t2","dny","_zeroDbl","_threeDbl","_dbl","xx","yy","yyyy","yyyy8","c8","gamma","alpha","beta4","beta8","ggamma8","jy2","jxd4","jyd8","trpl","zz","mm","ee","yyu4","kbase","z3","pz3","eqXToP","zs","xc","MontCurve","i4","a24","normalize","aa","bb","diffAdd","da","jumlAdd","other","EdwardsCurve","twisted","mOneA","dd","oneC","_mulA","_mulC","lhs","pointFromY","_extDbl","nt","_projDbl","_extAdd","_projAdd","zi","PresetCurve","defineCurve","SHA1","sha1_K","SHA224","SHA384","RIPEMD160","K","Kh","E","Ah","Bh","Ch","Dh","Eh","T","rh","sh","Hmac","Hash","inner","outer","HmacDRBG","KeyPair","Signature","keyPair","priv","fromPrivate","keyFromPublic","pub","fromPublic","drbg","pers","persEnc","entropy","entropyEnc","nonce","ns2","_truncateToN","truncOnly","bkey","ns1","iter","kp","kpX","sinv","isYOdd","isSecondKey","rInv","getKeyRecoveryParam","Q","Qprime","predResist","minEntropy","_reseed","reseedInterval","V","nonceEnc","seed","_hmac","kmac","reseed","addEnc","temp","_importPrivate","privEnc","_importPublic","pubEnc","result","reason","derive","_importDER","Position","place","getLength","initial","octetLen","rmPadding","constructLength","octets","slen","backHalf","EDDSA","pointClass","encodingLength","secret","keyFromSecret","hashInt","messagePrefix","R","Rencoded","encodePoint","s_","pubBytes","S","makeSignature","SG","fromSecret","lastIx","normed","xIsOdd","encodeInt","decodeInt","isPoint","params","_secret","_pub","_pubBytes","privBytes","getSecret","_R","_S","_Rencoded","_Sencoded","Sencoded","toBytes","field_sets","format_fields","to_hex","add_prefix_txData","add_prefix_signature","decode","v_hex","v_int","decoded","_decode","remainder","llength","innerRemainder","safeParseInt","totalLength","createKeccak","createShake","KeccakState","Keccak","Shake","algorithm","rate","capacity","delimitedSuffix","hashBitLength","_rate","_capacity","_delimitedSuffix","_hashBitLength","_options","_state","initialize","_finalized","absorb","absorbLastFewBits","squeeze","_resetState","_clone","_classCallCheck","instance","Constructor","copyBuffer","Timeout","id","clearFn","_clearFn","setInterval","clearInterval","close","unref","ref","enroll","item","msecs","_idleTimeoutId","_idleTimeout","unenroll","_unrefActive","active","_onTimeout","clearImmediate","task","tasksByHandle","nextHandle","registerImmediate","handle","runIfPresent","currentlyRunningATask","doc","document","attachTo","postMessage","importScripts","postMessageIsAsynchronous","oldOnMessage","onmessage","random","onGlobalMessage","addEventListener","attachEvent","MessageChannel","channel","port1","port2","createElement","html","documentElement","script","onreadystatechange","removeChild","appendChild","config","warn","localStorage","dataByteLength","squeezing","keccakState","p1600","P1600_ROUND_CONSTANTS","lo0","hi0","lo1","hi1","lo2","hi2","lo3","hi3","lo4","hi4","t1slo0","t1shi0","t1slo5","t1shi5","t1slo10","t1shi10","t1slo15","t1shi15","t1slo20","t1shi20","t1slo1","t1shi1","t1slo6","t1shi6","t1slo11","t1shi11","t1slo16","t1shi16","t1slo21","t1shi21","t1slo2","t1shi2","t1slo7","t1shi7","t1slo12","t1shi12","t1slo17","t1shi17","t1slo22","t1shi22","t1slo3","t1shi3","t1slo8","t1shi8","t1slo13","t1shi13","t1slo18","t1shi18","t1slo23","t1shi23","t1slo4","t1shi4","t1slo9","t1shi9","t1slo14","t1shi14","t1slo19","t1shi19","t1slo24","t1shi24","t2slo0","t2shi0","t2slo16","t2shi16","t2slo7","t2shi7","t2slo23","t2shi23","t2slo14","t2shi14","t2slo10","t2shi10","t2slo1","t2shi1","t2slo17","t2shi17","t2slo8","t2shi8","t2slo24","t2shi24","t2slo20","t2shi20","t2slo11","t2shi11","t2slo2","t2shi2","t2slo18","t2shi18","t2slo9","t2shi9","t2slo5","t2shi5","t2slo21","t2shi21","t2slo12","t2shi12","t2slo3","t2shi3","t2slo19","t2shi19","t2slo15","t2shi15","t2slo6","t2shi6","t2slo22","t2shi22","t2slo13","t2shi13","t2slo4","t2shi4"],"mappings":"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ACA,oEAGA,mEACA,qEAGA,mEACA,qEAGA,mEACA,qEAGA,mEACA,qEAGA,mEACA,qEAGA,mEACA,oEAGA,mEACA,qEAGA,mEACA,qEAGA,mEACA,oEAGA,mEACA,qEAGA,kEACA,qEAGA,mEACA,qEAGA,mEACA,qEAGA,mEACA,qEAGA,mEACA,qEAGA,mEACA,qEAGA,mEACA,qEAGA,mEACA,oEAGA,mEACA,oEAGA,mEACA,qEAGA,mEACA,qEAGA,mEACA,qEAGA,mEACA,qEAGA,mEACA,qEAGA,mEACA,qEAGA,mEACA,qEAGA,mEACA,qEAGA,mEACA,qEAGA,mEACA,qEAGA,mEACA,qEAGA,mEACA,qEAGA,mEACA,qEAGA,mEACA,qEAGA,mEACA,qEAGA,mEACA,qEAGA,mEACA,qEAGA,mEACA,qEAGA,mEACA,oEAGA,mEACA,qEAGA,mEACA,oEAGA,mEACA,qEAGA,mEACA,qEAGA,mEACA,qEAGA,mEACA,qEAGA,mEACA,qEAGA,mEACA,qEAGA,mEACA,qEAGA,kEACA,qEAGA,mEACA,qEAGA,mEACA,qEAGA,mEACA,oEAGA,mEACA,oEAGA,mEACA,qEAGA,mEACA,qEAGA,kEACA,qEAGA,mEACA,qEAGA,mEACA,oEAGA,mEACA,qEAGA,mEACA,oEAGA,mEACA,qEAGA,kEACA,qEAGA,mEACA,qEAGA,mEACA,qEAGA,mEACA,qEAGA,iEACA,qEAGA,mEACA,qEAGA,mEACA,qEAGA,mEACA,qEAGA,mEACA,qEAGA,mEACA,qEAGA,kEACA,qEAGA,mEACA,oEAGA,mEACA,qEAGA,mEACA,qEAGA,mEACA,qEAGA,mEACA,qEAGA,mEACA,qEAGA,mEACA,qEAGA,mEACA,qEAGA,mEACA,qEAGA,mEACA,qEAGA,mEACA,qEAGA,mEACA,qEAGA,mEACA,qEAGA,mEACA,qEAGA,mEACA,qEAGA,mEACA,qEAGA,mEACA,qEAGA,mEACA,qEAGA,mEACA,qEAGA,mEACA,oEAGA,mEACA,qEAGA,mEACA,qEAGA,mEACA,oEAGA,mEACA,qEAGA,mEACA,qEAGA,mEACA,qEAGA,mEACA,qEAGA,mEACA,oEAGA,mE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","file":"bundle.js","sourcesContent":["/******/ (function(modules) { // webpackBootstrap\n/******/ \t// The module cache\n/******/ \tvar installedModules = {};\n/******/\n/******/ \t// The require function\n/******/ \tfunction __webpack_require__(moduleId) {\n/******/\n/******/ \t\t// Check if module is in cache\n/******/ \t\tif(installedModules[moduleId]) {\n/******/ \t\t\treturn installedModules[moduleId].exports;\n/******/ \t\t}\n/******/ \t\t// Create a new module (and put it into the cache)\n/******/ \t\tvar module = installedModules[moduleId] = {\n/******/ \t\t\ti: moduleId,\n/******/ \t\t\tl: false,\n/******/ \t\t\texports: {}\n/******/ \t\t};\n/******/\n/******/ \t\t// Execute the module function\n/******/ \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n/******/\n/******/ \t\t// Flag the module as loaded\n/******/ \t\tmodule.l = true;\n/******/\n/******/ \t\t// Return the exports of the module\n/******/ \t\treturn module.exports;\n/******/ \t}\n/******/\n/******/\n/******/ \t// expose the modules object (__webpack_modules__)\n/******/ \t__webpack_require__.m = modules;\n/******/\n/******/ \t// expose the module cache\n/******/ \t__webpack_require__.c = installedModules;\n/******/\n/******/ \t// define getter function for harmony exports\n/******/ \t__webpack_require__.d = function(exports, name, getter) {\n/******/ \t\tif(!__webpack_require__.o(exports, name)) {\n/******/ \t\t\tObject.defineProperty(exports, name, {\n/******/ \t\t\t\tconfigurable: false,\n/******/ \t\t\t\tenumerable: true,\n/******/ \t\t\t\tget: getter\n/******/ \t\t\t});\n/******/ \t\t}\n/******/ \t};\n/******/\n/******/ \t// getDefaultExport function for compatibility with non-harmony modules\n/******/ \t__webpack_require__.n = function(module) {\n/******/ \t\tvar getter = module && module.__esModule ?\n/******/ \t\t\tfunction getDefault() { return module['default']; } :\n/******/ \t\t\tfunction getModuleExports() { return module; };\n/******/ \t\t__webpack_require__.d(getter, 'a', getter);\n/******/ \t\treturn getter;\n/******/ \t};\n/******/\n/******/ \t// Object.prototype.hasOwnProperty.call\n/******/ \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n/******/\n/******/ \t// __webpack_public_path__\n/******/ \t__webpack_require__.p = \"\";\n/******/\n/******/ \t// Load entry module and return exports\n/******/ \treturn __webpack_require__(__webpack_require__.s = 34);\n/******/ })\n/************************************************************************/\n/******/ ([\n/* 0 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar elliptic = exports;\n\nelliptic.version = __webpack_require__(40).version;\nelliptic.utils = __webpack_require__(41);\nelliptic.rand = __webpack_require__(42);\nelliptic.curve = __webpack_require__(11);\nelliptic.curves = __webpack_require__(48);\n\n// Protocols\nelliptic.ec = __webpack_require__(56);\nelliptic.eddsa = __webpack_require__(60);\n\n/***/ }),\n/* 1 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/* WEBPACK VAR INJECTION */(function(module) {\n\nvar _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; };\n\n(function (module, exports) {\n  'use strict';\n\n  // Utils\n\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 TempCtor() {};\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 === 'undefined' ? 'undefined' : _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    Buffer = __webpack_require__(38).Buffer;\n  } catch (e) {}\n\n  BN.isBN = function isBN(num) {\n    if (num instanceof BN) {\n      return true;\n    }\n\n    return num !== null && (typeof num === 'undefined' ? 'undefined' : _typeof(num)) === 'object' && 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 === 'undefined' ? 'undefined' : _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    }\n\n    if (base === 16) {\n      this._parseHex(number, start);\n    } else {\n      this._parseBase(number, base, start);\n    }\n\n    if (number[0] === '-') {\n      this.negative = 1;\n    }\n\n    this.strip();\n\n    if (endian !== 'le') return;\n\n    this._initArray(this.toArray(), base, endian);\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 = [number & 0x3ffffff, number / 0x4000000 & 0x3ffffff];\n      this.length = 2;\n    } else {\n      assert(number < 0x20000000000000); // 2 ^ 53 (unsafe)\n      this.words = [number & 0x3ffffff, number / 0x4000000 & 0x3ffffff, 1];\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 parseHex(str, start, end) {\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 <<= 4;\n\n      // 'a' - 'f'\n      if (c >= 49 && c <= 54) {\n        r |= c - 49 + 0xa;\n\n        // 'A' - 'F'\n      } else if (c >= 17 && c <= 22) {\n        r |= c - 17 + 0xa;\n\n        // '0' - '9'\n      } else {\n        r |= c & 0xf;\n      }\n    }\n    return r;\n  }\n\n  BN.prototype._parseHex = function _parseHex(number, start) {\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    var j, w;\n    // Scan 24-bit chunks and add them to the number\n    var off = 0;\n    for (i = number.length - 6, j = 0; i >= start; i -= 6) {\n      w = parseHex(number, i, i + 6);\n      this.words[j] |= w << off & 0x3ffffff;\n      // NOTE: `0x3fffff` is intentional here, 26bits max shift + 24bit hex limb\n      this.words[j + 1] |= w >>> 26 - off & 0x3fffff;\n      off += 24;\n      if (off >= 26) {\n        off -= 26;\n        j++;\n      }\n    }\n    if (i + 6 !== start) {\n      w = parseHex(number, start, i + 6);\n      this.words[j] |= w << off & 0x3ffffff;\n      this.words[j + 1] |= w >>> 26 - off & 0x3fffff;\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\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   var zeros = [];\n  var groupSizes = [];\n  var groupBases = [];\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  var zeros = ['', '0', '00', '000', '0000', '00000', '000000', '0000000', '00000000', '000000000', '0000000000', '00000000000', '000000000000', '0000000000000', '00000000000000', '000000000000000', '0000000000000000', '00000000000000000', '000000000000000000', '0000000000000000000', '00000000000000000000', '000000000000000000000', '0000000000000000000000', '00000000000000000000000', '000000000000000000000000', '0000000000000000000000000'];\n\n  var groupSizes = [0, 0, 25, 16, 12, 11, 10, 9, 8, 8, 7, 7, 7, 7, 6, 6, 6, 6, 6, 6, 6, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5];\n\n  var groupBases = [0, 0, 33554432, 43046721, 16777216, 48828125, 60466176, 40353607, 16777216, 43046721, 10000000, 19487171, 35831808, 62748517, 7529536, 11390625, 16777216, 24137569, 34012224, 47045881, 64000000, 4084101, 5153632, 6436343, 7962624, 9765625, 11881376, 14348907, 17210368, 20511149, 24300000, 28629151, 33554432, 39135393, 45435424, 52521875, 60466176];\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 + Math.round(ws[2 * i] / 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 + (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      r.strip();\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(this, 'k256', '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(this, 'p224', 'ffffffff ffffffff ffffffff ffffffff 00000000 00000000 00000001');\n  }\n  inherits(P224, MPrime);\n\n  function P192() {\n    MPrime.call(this, 'p192', 'ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff');\n  }\n  inherits(P192, MPrime);\n\n  function P25519() {\n    // 2 ^ 255 - 19\n    MPrime.call(this, '25519', '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, '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, undefined);\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(37)(module)))\n\n/***/ }),\n/* 2 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/* WEBPACK VAR INJECTION */(function(global) {/*!\n * The buffer module from node.js, for the browser.\n *\n * @author   Feross Aboukhadijeh <feross@feross.org> <http://feross.org>\n * @license  MIT\n */\n/* eslint-disable no-proto */\n\n\n\nvar base64 = __webpack_require__(35);\nvar ieee754 = __webpack_require__(36);\nvar isArray = __webpack_require__(21);\n\nexports.Buffer = Buffer;\nexports.SlowBuffer = SlowBuffer;\nexports.INSPECT_MAX_BYTES = 50;\n\n/**\n * If `Buffer.TYPED_ARRAY_SUPPORT`:\n *   === true    Use Uint8Array implementation (fastest)\n *   === false   Use Object implementation (most compatible, even IE6)\n *\n * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,\n * Opera 11.6+, iOS 4.2+.\n *\n * Due to various browser bugs, sometimes the Object implementation will be used even\n * when the browser supports typed arrays.\n *\n * Note:\n *\n *   - Firefox 4-29 lacks support for adding new properties to `Uint8Array` instances,\n *     See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438.\n *\n *   - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function.\n *\n *   - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of\n *     incorrect length in some situations.\n\n * We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they\n * get the Object implementation, which is slower but behaves correctly.\n */\nBuffer.TYPED_ARRAY_SUPPORT = global.TYPED_ARRAY_SUPPORT !== undefined ? global.TYPED_ARRAY_SUPPORT : typedArraySupport();\n\n/*\n * Export kMaxLength after typed array support is determined.\n */\nexports.kMaxLength = kMaxLength();\n\nfunction typedArraySupport() {\n  try {\n    var arr = new Uint8Array(1);\n    arr.__proto__ = { __proto__: Uint8Array.prototype, foo: function foo() {\n        return 42;\n      } };\n    return arr.foo() === 42 && // typed array instances can be augmented\n    typeof arr.subarray === 'function' && // chrome 9-10 lack `subarray`\n    arr.subarray(1, 1).byteLength === 0; // ie10 has broken `subarray`\n  } catch (e) {\n    return false;\n  }\n}\n\nfunction kMaxLength() {\n  return Buffer.TYPED_ARRAY_SUPPORT ? 0x7fffffff : 0x3fffffff;\n}\n\nfunction createBuffer(that, length) {\n  if (kMaxLength() < length) {\n    throw new RangeError('Invalid typed array length');\n  }\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    // Return an augmented `Uint8Array` instance, for best performance\n    that = new Uint8Array(length);\n    that.__proto__ = Buffer.prototype;\n  } else {\n    // Fallback: Return an object instance of the Buffer class\n    if (that === null) {\n      that = new Buffer(length);\n    }\n    that.length = length;\n  }\n\n  return that;\n}\n\n/**\n * The Buffer constructor returns instances of `Uint8Array` that have their\n * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of\n * `Uint8Array`, so the returned instances will have all the node `Buffer` methods\n * and the `Uint8Array` methods. Square bracket notation works as expected -- it\n * returns a single octet.\n *\n * The `Uint8Array` prototype remains unmodified.\n */\n\nfunction Buffer(arg, encodingOrOffset, length) {\n  if (!Buffer.TYPED_ARRAY_SUPPORT && !(this instanceof Buffer)) {\n    return new Buffer(arg, encodingOrOffset, length);\n  }\n\n  // Common case.\n  if (typeof arg === 'number') {\n    if (typeof encodingOrOffset === 'string') {\n      throw new Error('If encoding is specified then the first argument must be a string');\n    }\n    return allocUnsafe(this, arg);\n  }\n  return from(this, arg, encodingOrOffset, length);\n}\n\nBuffer.poolSize = 8192; // not used by this implementation\n\n// TODO: Legacy, not needed anymore. Remove in next major version.\nBuffer._augment = function (arr) {\n  arr.__proto__ = Buffer.prototype;\n  return arr;\n};\n\nfunction from(that, value, encodingOrOffset, length) {\n  if (typeof value === 'number') {\n    throw new TypeError('\"value\" argument must not be a number');\n  }\n\n  if (typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer) {\n    return fromArrayBuffer(that, value, encodingOrOffset, length);\n  }\n\n  if (typeof value === 'string') {\n    return fromString(that, value, encodingOrOffset);\n  }\n\n  return fromObject(that, value);\n}\n\n/**\n * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError\n * if value is a number.\n * Buffer.from(str[, encoding])\n * Buffer.from(array)\n * Buffer.from(buffer)\n * Buffer.from(arrayBuffer[, byteOffset[, length]])\n **/\nBuffer.from = function (value, encodingOrOffset, length) {\n  return from(null, value, encodingOrOffset, length);\n};\n\nif (Buffer.TYPED_ARRAY_SUPPORT) {\n  Buffer.prototype.__proto__ = Uint8Array.prototype;\n  Buffer.__proto__ = Uint8Array;\n  if (typeof Symbol !== 'undefined' && Symbol.species && Buffer[Symbol.species] === Buffer) {\n    // Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97\n    Object.defineProperty(Buffer, Symbol.species, {\n      value: null,\n      configurable: true\n    });\n  }\n}\n\nfunction assertSize(size) {\n  if (typeof size !== 'number') {\n    throw new TypeError('\"size\" argument must be a number');\n  } else if (size < 0) {\n    throw new RangeError('\"size\" argument must not be negative');\n  }\n}\n\nfunction alloc(that, size, fill, encoding) {\n  assertSize(size);\n  if (size <= 0) {\n    return createBuffer(that, size);\n  }\n  if (fill !== undefined) {\n    // Only pay attention to encoding if it's a string. This\n    // prevents accidentally sending in a number that would\n    // be interpretted as a start offset.\n    return typeof encoding === 'string' ? createBuffer(that, size).fill(fill, encoding) : createBuffer(that, size).fill(fill);\n  }\n  return createBuffer(that, size);\n}\n\n/**\n * Creates a new filled Buffer instance.\n * alloc(size[, fill[, encoding]])\n **/\nBuffer.alloc = function (size, fill, encoding) {\n  return alloc(null, size, fill, encoding);\n};\n\nfunction allocUnsafe(that, size) {\n  assertSize(size);\n  that = createBuffer(that, size < 0 ? 0 : checked(size) | 0);\n  if (!Buffer.TYPED_ARRAY_SUPPORT) {\n    for (var i = 0; i < size; ++i) {\n      that[i] = 0;\n    }\n  }\n  return that;\n}\n\n/**\n * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.\n * */\nBuffer.allocUnsafe = function (size) {\n  return allocUnsafe(null, size);\n};\n/**\n * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.\n */\nBuffer.allocUnsafeSlow = function (size) {\n  return allocUnsafe(null, size);\n};\n\nfunction fromString(that, string, encoding) {\n  if (typeof encoding !== 'string' || encoding === '') {\n    encoding = 'utf8';\n  }\n\n  if (!Buffer.isEncoding(encoding)) {\n    throw new TypeError('\"encoding\" must be a valid string encoding');\n  }\n\n  var length = byteLength(string, encoding) | 0;\n  that = createBuffer(that, length);\n\n  var actual = that.write(string, encoding);\n\n  if (actual !== length) {\n    // Writing a hex string, for example, that contains invalid characters will\n    // cause everything after the first invalid character to be ignored. (e.g.\n    // 'abxxcd' will be treated as 'ab')\n    that = that.slice(0, actual);\n  }\n\n  return that;\n}\n\nfunction fromArrayLike(that, array) {\n  var length = array.length < 0 ? 0 : checked(array.length) | 0;\n  that = createBuffer(that, length);\n  for (var i = 0; i < length; i += 1) {\n    that[i] = array[i] & 255;\n  }\n  return that;\n}\n\nfunction fromArrayBuffer(that, array, byteOffset, length) {\n  array.byteLength; // this throws if `array` is not a valid ArrayBuffer\n\n  if (byteOffset < 0 || array.byteLength < byteOffset) {\n    throw new RangeError('\\'offset\\' is out of bounds');\n  }\n\n  if (array.byteLength < byteOffset + (length || 0)) {\n    throw new RangeError('\\'length\\' is out of bounds');\n  }\n\n  if (byteOffset === undefined && length === undefined) {\n    array = new Uint8Array(array);\n  } else if (length === undefined) {\n    array = new Uint8Array(array, byteOffset);\n  } else {\n    array = new Uint8Array(array, byteOffset, length);\n  }\n\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    // Return an augmented `Uint8Array` instance, for best performance\n    that = array;\n    that.__proto__ = Buffer.prototype;\n  } else {\n    // Fallback: Return an object instance of the Buffer class\n    that = fromArrayLike(that, array);\n  }\n  return that;\n}\n\nfunction fromObject(that, obj) {\n  if (Buffer.isBuffer(obj)) {\n    var len = checked(obj.length) | 0;\n    that = createBuffer(that, len);\n\n    if (that.length === 0) {\n      return that;\n    }\n\n    obj.copy(that, 0, 0, len);\n    return that;\n  }\n\n  if (obj) {\n    if (typeof ArrayBuffer !== 'undefined' && obj.buffer instanceof ArrayBuffer || 'length' in obj) {\n      if (typeof obj.length !== 'number' || isnan(obj.length)) {\n        return createBuffer(that, 0);\n      }\n      return fromArrayLike(that, obj);\n    }\n\n    if (obj.type === 'Buffer' && isArray(obj.data)) {\n      return fromArrayLike(that, obj.data);\n    }\n  }\n\n  throw new TypeError('First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.');\n}\n\nfunction checked(length) {\n  // Note: cannot use `length < kMaxLength()` here because that fails when\n  // length is NaN (which is otherwise coerced to zero.)\n  if (length >= kMaxLength()) {\n    throw new RangeError('Attempt to allocate Buffer larger than maximum ' + 'size: 0x' + kMaxLength().toString(16) + ' bytes');\n  }\n  return length | 0;\n}\n\nfunction SlowBuffer(length) {\n  if (+length != length) {\n    // eslint-disable-line eqeqeq\n    length = 0;\n  }\n  return Buffer.alloc(+length);\n}\n\nBuffer.isBuffer = function isBuffer(b) {\n  return !!(b != null && b._isBuffer);\n};\n\nBuffer.compare = function compare(a, b) {\n  if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {\n    throw new TypeError('Arguments must be Buffers');\n  }\n\n  if (a === b) return 0;\n\n  var x = a.length;\n  var y = b.length;\n\n  for (var i = 0, len = Math.min(x, y); i < len; ++i) {\n    if (a[i] !== b[i]) {\n      x = a[i];\n      y = b[i];\n      break;\n    }\n  }\n\n  if (x < y) return -1;\n  if (y < x) return 1;\n  return 0;\n};\n\nBuffer.isEncoding = function isEncoding(encoding) {\n  switch (String(encoding).toLowerCase()) {\n    case 'hex':\n    case 'utf8':\n    case 'utf-8':\n    case 'ascii':\n    case 'latin1':\n    case 'binary':\n    case 'base64':\n    case 'ucs2':\n    case 'ucs-2':\n    case 'utf16le':\n    case 'utf-16le':\n      return true;\n    default:\n      return false;\n  }\n};\n\nBuffer.concat = function concat(list, length) {\n  if (!isArray(list)) {\n    throw new TypeError('\"list\" argument must be an Array of Buffers');\n  }\n\n  if (list.length === 0) {\n    return Buffer.alloc(0);\n  }\n\n  var i;\n  if (length === undefined) {\n    length = 0;\n    for (i = 0; i < list.length; ++i) {\n      length += list[i].length;\n    }\n  }\n\n  var buffer = Buffer.allocUnsafe(length);\n  var pos = 0;\n  for (i = 0; i < list.length; ++i) {\n    var buf = list[i];\n    if (!Buffer.isBuffer(buf)) {\n      throw new TypeError('\"list\" argument must be an Array of Buffers');\n    }\n    buf.copy(buffer, pos);\n    pos += buf.length;\n  }\n  return buffer;\n};\n\nfunction byteLength(string, encoding) {\n  if (Buffer.isBuffer(string)) {\n    return string.length;\n  }\n  if (typeof ArrayBuffer !== 'undefined' && typeof ArrayBuffer.isView === 'function' && (ArrayBuffer.isView(string) || string instanceof ArrayBuffer)) {\n    return string.byteLength;\n  }\n  if (typeof string !== 'string') {\n    string = '' + string;\n  }\n\n  var len = string.length;\n  if (len === 0) return 0;\n\n  // Use a for loop to avoid recursion\n  var loweredCase = false;\n  for (;;) {\n    switch (encoding) {\n      case 'ascii':\n      case 'latin1':\n      case 'binary':\n        return len;\n      case 'utf8':\n      case 'utf-8':\n      case undefined:\n        return utf8ToBytes(string).length;\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return len * 2;\n      case 'hex':\n        return len >>> 1;\n      case 'base64':\n        return base64ToBytes(string).length;\n      default:\n        if (loweredCase) return utf8ToBytes(string).length; // assume utf8\n        encoding = ('' + encoding).toLowerCase();\n        loweredCase = true;\n    }\n  }\n}\nBuffer.byteLength = byteLength;\n\nfunction slowToString(encoding, start, end) {\n  var loweredCase = false;\n\n  // No need to verify that \"this.length <= MAX_UINT32\" since it's a read-only\n  // property of a typed array.\n\n  // This behaves neither like String nor Uint8Array in that we set start/end\n  // to their upper/lower bounds if the value passed is out of range.\n  // undefined is handled specially as per ECMA-262 6th Edition,\n  // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.\n  if (start === undefined || start < 0) {\n    start = 0;\n  }\n  // Return early if start > this.length. Done here to prevent potential uint32\n  // coercion fail below.\n  if (start > this.length) {\n    return '';\n  }\n\n  if (end === undefined || end > this.length) {\n    end = this.length;\n  }\n\n  if (end <= 0) {\n    return '';\n  }\n\n  // Force coersion to uint32. This will also coerce falsey/NaN values to 0.\n  end >>>= 0;\n  start >>>= 0;\n\n  if (end <= start) {\n    return '';\n  }\n\n  if (!encoding) encoding = 'utf8';\n\n  while (true) {\n    switch (encoding) {\n      case 'hex':\n        return hexSlice(this, start, end);\n\n      case 'utf8':\n      case 'utf-8':\n        return utf8Slice(this, start, end);\n\n      case 'ascii':\n        return asciiSlice(this, start, end);\n\n      case 'latin1':\n      case 'binary':\n        return latin1Slice(this, start, end);\n\n      case 'base64':\n        return base64Slice(this, start, end);\n\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return utf16leSlice(this, start, end);\n\n      default:\n        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding);\n        encoding = (encoding + '').toLowerCase();\n        loweredCase = true;\n    }\n  }\n}\n\n// The property is used by `Buffer.isBuffer` and `is-buffer` (in Safari 5-7) to detect\n// Buffer instances.\nBuffer.prototype._isBuffer = true;\n\nfunction swap(b, n, m) {\n  var i = b[n];\n  b[n] = b[m];\n  b[m] = i;\n}\n\nBuffer.prototype.swap16 = function swap16() {\n  var len = this.length;\n  if (len % 2 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 16-bits');\n  }\n  for (var i = 0; i < len; i += 2) {\n    swap(this, i, i + 1);\n  }\n  return this;\n};\n\nBuffer.prototype.swap32 = function swap32() {\n  var len = this.length;\n  if (len % 4 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 32-bits');\n  }\n  for (var i = 0; i < len; i += 4) {\n    swap(this, i, i + 3);\n    swap(this, i + 1, i + 2);\n  }\n  return this;\n};\n\nBuffer.prototype.swap64 = function swap64() {\n  var len = this.length;\n  if (len % 8 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 64-bits');\n  }\n  for (var i = 0; i < len; i += 8) {\n    swap(this, i, i + 7);\n    swap(this, i + 1, i + 6);\n    swap(this, i + 2, i + 5);\n    swap(this, i + 3, i + 4);\n  }\n  return this;\n};\n\nBuffer.prototype.toString = function toString() {\n  var length = this.length | 0;\n  if (length === 0) return '';\n  if (arguments.length === 0) return utf8Slice(this, 0, length);\n  return slowToString.apply(this, arguments);\n};\n\nBuffer.prototype.equals = function equals(b) {\n  if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer');\n  if (this === b) return true;\n  return Buffer.compare(this, b) === 0;\n};\n\nBuffer.prototype.inspect = function inspect() {\n  var str = '';\n  var max = exports.INSPECT_MAX_BYTES;\n  if (this.length > 0) {\n    str = this.toString('hex', 0, max).match(/.{2}/g).join(' ');\n    if (this.length > max) str += ' ... ';\n  }\n  return '<Buffer ' + str + '>';\n};\n\nBuffer.prototype.compare = function compare(target, start, end, thisStart, thisEnd) {\n  if (!Buffer.isBuffer(target)) {\n    throw new TypeError('Argument must be a Buffer');\n  }\n\n  if (start === undefined) {\n    start = 0;\n  }\n  if (end === undefined) {\n    end = target ? target.length : 0;\n  }\n  if (thisStart === undefined) {\n    thisStart = 0;\n  }\n  if (thisEnd === undefined) {\n    thisEnd = this.length;\n  }\n\n  if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {\n    throw new RangeError('out of range index');\n  }\n\n  if (thisStart >= thisEnd && start >= end) {\n    return 0;\n  }\n  if (thisStart >= thisEnd) {\n    return -1;\n  }\n  if (start >= end) {\n    return 1;\n  }\n\n  start >>>= 0;\n  end >>>= 0;\n  thisStart >>>= 0;\n  thisEnd >>>= 0;\n\n  if (this === target) return 0;\n\n  var x = thisEnd - thisStart;\n  var y = end - start;\n  var len = Math.min(x, y);\n\n  var thisCopy = this.slice(thisStart, thisEnd);\n  var targetCopy = target.slice(start, end);\n\n  for (var i = 0; i < len; ++i) {\n    if (thisCopy[i] !== targetCopy[i]) {\n      x = thisCopy[i];\n      y = targetCopy[i];\n      break;\n    }\n  }\n\n  if (x < y) return -1;\n  if (y < x) return 1;\n  return 0;\n};\n\n// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,\n// OR the last index of `val` in `buffer` at offset <= `byteOffset`.\n//\n// Arguments:\n// - buffer - a Buffer to search\n// - val - a string, Buffer, or number\n// - byteOffset - an index into `buffer`; will be clamped to an int32\n// - encoding - an optional encoding, relevant is val is a string\n// - dir - true for indexOf, false for lastIndexOf\nfunction bidirectionalIndexOf(buffer, val, byteOffset, encoding, dir) {\n  // Empty buffer means no match\n  if (buffer.length === 0) return -1;\n\n  // Normalize byteOffset\n  if (typeof byteOffset === 'string') {\n    encoding = byteOffset;\n    byteOffset = 0;\n  } else if (byteOffset > 0x7fffffff) {\n    byteOffset = 0x7fffffff;\n  } else if (byteOffset < -0x80000000) {\n    byteOffset = -0x80000000;\n  }\n  byteOffset = +byteOffset; // Coerce to Number.\n  if (isNaN(byteOffset)) {\n    // byteOffset: it it's undefined, null, NaN, \"foo\", etc, search whole buffer\n    byteOffset = dir ? 0 : buffer.length - 1;\n  }\n\n  // Normalize byteOffset: negative offsets start from the end of the buffer\n  if (byteOffset < 0) byteOffset = buffer.length + byteOffset;\n  if (byteOffset >= buffer.length) {\n    if (dir) return -1;else byteOffset = buffer.length - 1;\n  } else if (byteOffset < 0) {\n    if (dir) byteOffset = 0;else return -1;\n  }\n\n  // Normalize val\n  if (typeof val === 'string') {\n    val = Buffer.from(val, encoding);\n  }\n\n  // Finally, search either indexOf (if dir is true) or lastIndexOf\n  if (Buffer.isBuffer(val)) {\n    // Special case: looking for empty string/buffer always fails\n    if (val.length === 0) {\n      return -1;\n    }\n    return arrayIndexOf(buffer, val, byteOffset, encoding, dir);\n  } else if (typeof val === 'number') {\n    val = val & 0xFF; // Search for a byte value [0-255]\n    if (Buffer.TYPED_ARRAY_SUPPORT && typeof Uint8Array.prototype.indexOf === 'function') {\n      if (dir) {\n        return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset);\n      } else {\n        return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset);\n      }\n    }\n    return arrayIndexOf(buffer, [val], byteOffset, encoding, dir);\n  }\n\n  throw new TypeError('val must be string, number or Buffer');\n}\n\nfunction arrayIndexOf(arr, val, byteOffset, encoding, dir) {\n  var indexSize = 1;\n  var arrLength = arr.length;\n  var valLength = val.length;\n\n  if (encoding !== undefined) {\n    encoding = String(encoding).toLowerCase();\n    if (encoding === 'ucs2' || encoding === 'ucs-2' || encoding === 'utf16le' || encoding === 'utf-16le') {\n      if (arr.length < 2 || val.length < 2) {\n        return -1;\n      }\n      indexSize = 2;\n      arrLength /= 2;\n      valLength /= 2;\n      byteOffset /= 2;\n    }\n  }\n\n  function read(buf, i) {\n    if (indexSize === 1) {\n      return buf[i];\n    } else {\n      return buf.readUInt16BE(i * indexSize);\n    }\n  }\n\n  var i;\n  if (dir) {\n    var foundIndex = -1;\n    for (i = byteOffset; i < arrLength; i++) {\n      if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {\n        if (foundIndex === -1) foundIndex = i;\n        if (i - foundIndex + 1 === valLength) return foundIndex * indexSize;\n      } else {\n        if (foundIndex !== -1) i -= i - foundIndex;\n        foundIndex = -1;\n      }\n    }\n  } else {\n    if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength;\n    for (i = byteOffset; i >= 0; i--) {\n      var found = true;\n      for (var j = 0; j < valLength; j++) {\n        if (read(arr, i + j) !== read(val, j)) {\n          found = false;\n          break;\n        }\n      }\n      if (found) return i;\n    }\n  }\n\n  return -1;\n}\n\nBuffer.prototype.includes = function includes(val, byteOffset, encoding) {\n  return this.indexOf(val, byteOffset, encoding) !== -1;\n};\n\nBuffer.prototype.indexOf = function indexOf(val, byteOffset, encoding) {\n  return bidirectionalIndexOf(this, val, byteOffset, encoding, true);\n};\n\nBuffer.prototype.lastIndexOf = function lastIndexOf(val, byteOffset, encoding) {\n  return bidirectionalIndexOf(this, val, byteOffset, encoding, false);\n};\n\nfunction hexWrite(buf, string, offset, length) {\n  offset = Number(offset) || 0;\n  var remaining = buf.length - offset;\n  if (!length) {\n    length = remaining;\n  } else {\n    length = Number(length);\n    if (length > remaining) {\n      length = remaining;\n    }\n  }\n\n  // must be an even number of digits\n  var strLen = string.length;\n  if (strLen % 2 !== 0) throw new TypeError('Invalid hex string');\n\n  if (length > strLen / 2) {\n    length = strLen / 2;\n  }\n  for (var i = 0; i < length; ++i) {\n    var parsed = parseInt(string.substr(i * 2, 2), 16);\n    if (isNaN(parsed)) return i;\n    buf[offset + i] = parsed;\n  }\n  return i;\n}\n\nfunction utf8Write(buf, string, offset, length) {\n  return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length);\n}\n\nfunction asciiWrite(buf, string, offset, length) {\n  return blitBuffer(asciiToBytes(string), buf, offset, length);\n}\n\nfunction latin1Write(buf, string, offset, length) {\n  return asciiWrite(buf, string, offset, length);\n}\n\nfunction base64Write(buf, string, offset, length) {\n  return blitBuffer(base64ToBytes(string), buf, offset, length);\n}\n\nfunction ucs2Write(buf, string, offset, length) {\n  return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length);\n}\n\nBuffer.prototype.write = function write(string, offset, length, encoding) {\n  // Buffer#write(string)\n  if (offset === undefined) {\n    encoding = 'utf8';\n    length = this.length;\n    offset = 0;\n    // Buffer#write(string, encoding)\n  } else if (length === undefined && typeof offset === 'string') {\n    encoding = offset;\n    length = this.length;\n    offset = 0;\n    // Buffer#write(string, offset[, length][, encoding])\n  } else if (isFinite(offset)) {\n    offset = offset | 0;\n    if (isFinite(length)) {\n      length = length | 0;\n      if (encoding === undefined) encoding = 'utf8';\n    } else {\n      encoding = length;\n      length = undefined;\n    }\n    // legacy write(string, encoding, offset, length) - remove in v0.13\n  } else {\n    throw new Error('Buffer.write(string, encoding, offset[, length]) is no longer supported');\n  }\n\n  var remaining = this.length - offset;\n  if (length === undefined || length > remaining) length = remaining;\n\n  if (string.length > 0 && (length < 0 || offset < 0) || offset > this.length) {\n    throw new RangeError('Attempt to write outside buffer bounds');\n  }\n\n  if (!encoding) encoding = 'utf8';\n\n  var loweredCase = false;\n  for (;;) {\n    switch (encoding) {\n      case 'hex':\n        return hexWrite(this, string, offset, length);\n\n      case 'utf8':\n      case 'utf-8':\n        return utf8Write(this, string, offset, length);\n\n      case 'ascii':\n        return asciiWrite(this, string, offset, length);\n\n      case 'latin1':\n      case 'binary':\n        return latin1Write(this, string, offset, length);\n\n      case 'base64':\n        // Warning: maxLength not taken into account in base64Write\n        return base64Write(this, string, offset, length);\n\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return ucs2Write(this, string, offset, length);\n\n      default:\n        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding);\n        encoding = ('' + encoding).toLowerCase();\n        loweredCase = true;\n    }\n  }\n};\n\nBuffer.prototype.toJSON = function toJSON() {\n  return {\n    type: 'Buffer',\n    data: Array.prototype.slice.call(this._arr || this, 0)\n  };\n};\n\nfunction base64Slice(buf, start, end) {\n  if (start === 0 && end === buf.length) {\n    return base64.fromByteArray(buf);\n  } else {\n    return base64.fromByteArray(buf.slice(start, end));\n  }\n}\n\nfunction utf8Slice(buf, start, end) {\n  end = Math.min(buf.length, end);\n  var res = [];\n\n  var i = start;\n  while (i < end) {\n    var firstByte = buf[i];\n    var codePoint = null;\n    var bytesPerSequence = firstByte > 0xEF ? 4 : firstByte > 0xDF ? 3 : firstByte > 0xBF ? 2 : 1;\n\n    if (i + bytesPerSequence <= end) {\n      var secondByte, thirdByte, fourthByte, tempCodePoint;\n\n      switch (bytesPerSequence) {\n        case 1:\n          if (firstByte < 0x80) {\n            codePoint = firstByte;\n          }\n          break;\n        case 2:\n          secondByte = buf[i + 1];\n          if ((secondByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0x1F) << 0x6 | secondByte & 0x3F;\n            if (tempCodePoint > 0x7F) {\n              codePoint = tempCodePoint;\n            }\n          }\n          break;\n        case 3:\n          secondByte = buf[i + 1];\n          thirdByte = buf[i + 2];\n          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | thirdByte & 0x3F;\n            if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {\n              codePoint = tempCodePoint;\n            }\n          }\n          break;\n        case 4:\n          secondByte = buf[i + 1];\n          thirdByte = buf[i + 2];\n          fourthByte = buf[i + 3];\n          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | fourthByte & 0x3F;\n            if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {\n              codePoint = tempCodePoint;\n            }\n          }\n      }\n    }\n\n    if (codePoint === null) {\n      // we did not generate a valid codePoint so insert a\n      // replacement char (U+FFFD) and advance only 1 byte\n      codePoint = 0xFFFD;\n      bytesPerSequence = 1;\n    } else if (codePoint > 0xFFFF) {\n      // encode to utf16 (surrogate pair dance)\n      codePoint -= 0x10000;\n      res.push(codePoint >>> 10 & 0x3FF | 0xD800);\n      codePoint = 0xDC00 | codePoint & 0x3FF;\n    }\n\n    res.push(codePoint);\n    i += bytesPerSequence;\n  }\n\n  return decodeCodePointsArray(res);\n}\n\n// Based on http://stackoverflow.com/a/22747272/680742, the browser with\n// the lowest limit is Chrome, with 0x10000 args.\n// We go 1 magnitude less, for safety\nvar MAX_ARGUMENTS_LENGTH = 0x1000;\n\nfunction decodeCodePointsArray(codePoints) {\n  var len = codePoints.length;\n  if (len <= MAX_ARGUMENTS_LENGTH) {\n    return String.fromCharCode.apply(String, codePoints); // avoid extra slice()\n  }\n\n  // Decode in chunks to avoid \"call stack size exceeded\".\n  var res = '';\n  var i = 0;\n  while (i < len) {\n    res += String.fromCharCode.apply(String, codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH));\n  }\n  return res;\n}\n\nfunction asciiSlice(buf, start, end) {\n  var ret = '';\n  end = Math.min(buf.length, end);\n\n  for (var i = start; i < end; ++i) {\n    ret += String.fromCharCode(buf[i] & 0x7F);\n  }\n  return ret;\n}\n\nfunction latin1Slice(buf, start, end) {\n  var ret = '';\n  end = Math.min(buf.length, end);\n\n  for (var i = start; i < end; ++i) {\n    ret += String.fromCharCode(buf[i]);\n  }\n  return ret;\n}\n\nfunction hexSlice(buf, start, end) {\n  var len = buf.length;\n\n  if (!start || start < 0) start = 0;\n  if (!end || end < 0 || end > len) end = len;\n\n  var out = '';\n  for (var i = start; i < end; ++i) {\n    out += toHex(buf[i]);\n  }\n  return out;\n}\n\nfunction utf16leSlice(buf, start, end) {\n  var bytes = buf.slice(start, end);\n  var res = '';\n  for (var i = 0; i < bytes.length; i += 2) {\n    res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256);\n  }\n  return res;\n}\n\nBuffer.prototype.slice = function slice(start, end) {\n  var len = this.length;\n  start = ~~start;\n  end = end === undefined ? len : ~~end;\n\n  if (start < 0) {\n    start += len;\n    if (start < 0) start = 0;\n  } else if (start > len) {\n    start = len;\n  }\n\n  if (end < 0) {\n    end += len;\n    if (end < 0) end = 0;\n  } else if (end > len) {\n    end = len;\n  }\n\n  if (end < start) end = start;\n\n  var newBuf;\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    newBuf = this.subarray(start, end);\n    newBuf.__proto__ = Buffer.prototype;\n  } else {\n    var sliceLen = end - start;\n    newBuf = new Buffer(sliceLen, undefined);\n    for (var i = 0; i < sliceLen; ++i) {\n      newBuf[i] = this[i + start];\n    }\n  }\n\n  return newBuf;\n};\n\n/*\n * Need to make sure that buffer isn't trying to write out of bounds.\n */\nfunction checkOffset(offset, ext, length) {\n  if (offset % 1 !== 0 || offset < 0) throw new RangeError('offset is not uint');\n  if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length');\n}\n\nBuffer.prototype.readUIntLE = function readUIntLE(offset, byteLength, noAssert) {\n  offset = offset | 0;\n  byteLength = byteLength | 0;\n  if (!noAssert) checkOffset(offset, byteLength, this.length);\n\n  var val = this[offset];\n  var mul = 1;\n  var i = 0;\n  while (++i < byteLength && (mul *= 0x100)) {\n    val += this[offset + i] * mul;\n  }\n\n  return val;\n};\n\nBuffer.prototype.readUIntBE = function readUIntBE(offset, byteLength, noAssert) {\n  offset = offset | 0;\n  byteLength = byteLength | 0;\n  if (!noAssert) {\n    checkOffset(offset, byteLength, this.length);\n  }\n\n  var val = this[offset + --byteLength];\n  var mul = 1;\n  while (byteLength > 0 && (mul *= 0x100)) {\n    val += this[offset + --byteLength] * mul;\n  }\n\n  return val;\n};\n\nBuffer.prototype.readUInt8 = function readUInt8(offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 1, this.length);\n  return this[offset];\n};\n\nBuffer.prototype.readUInt16LE = function readUInt16LE(offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length);\n  return this[offset] | this[offset + 1] << 8;\n};\n\nBuffer.prototype.readUInt16BE = function readUInt16BE(offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length);\n  return this[offset] << 8 | this[offset + 1];\n};\n\nBuffer.prototype.readUInt32LE = function readUInt32LE(offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length);\n\n  return (this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16) + this[offset + 3] * 0x1000000;\n};\n\nBuffer.prototype.readUInt32BE = function readUInt32BE(offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length);\n\n  return this[offset] * 0x1000000 + (this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3]);\n};\n\nBuffer.prototype.readIntLE = function readIntLE(offset, byteLength, noAssert) {\n  offset = offset | 0;\n  byteLength = byteLength | 0;\n  if (!noAssert) checkOffset(offset, byteLength, this.length);\n\n  var val = this[offset];\n  var mul = 1;\n  var i = 0;\n  while (++i < byteLength && (mul *= 0x100)) {\n    val += this[offset + i] * mul;\n  }\n  mul *= 0x80;\n\n  if (val >= mul) val -= Math.pow(2, 8 * byteLength);\n\n  return val;\n};\n\nBuffer.prototype.readIntBE = function readIntBE(offset, byteLength, noAssert) {\n  offset = offset | 0;\n  byteLength = byteLength | 0;\n  if (!noAssert) checkOffset(offset, byteLength, this.length);\n\n  var i = byteLength;\n  var mul = 1;\n  var val = this[offset + --i];\n  while (i > 0 && (mul *= 0x100)) {\n    val += this[offset + --i] * mul;\n  }\n  mul *= 0x80;\n\n  if (val >= mul) val -= Math.pow(2, 8 * byteLength);\n\n  return val;\n};\n\nBuffer.prototype.readInt8 = function readInt8(offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 1, this.length);\n  if (!(this[offset] & 0x80)) return this[offset];\n  return (0xff - this[offset] + 1) * -1;\n};\n\nBuffer.prototype.readInt16LE = function readInt16LE(offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length);\n  var val = this[offset] | this[offset + 1] << 8;\n  return val & 0x8000 ? val | 0xFFFF0000 : val;\n};\n\nBuffer.prototype.readInt16BE = function readInt16BE(offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length);\n  var val = this[offset + 1] | this[offset] << 8;\n  return val & 0x8000 ? val | 0xFFFF0000 : val;\n};\n\nBuffer.prototype.readInt32LE = function readInt32LE(offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length);\n\n  return this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16 | this[offset + 3] << 24;\n};\n\nBuffer.prototype.readInt32BE = function readInt32BE(offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length);\n\n  return this[offset] << 24 | this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3];\n};\n\nBuffer.prototype.readFloatLE = function readFloatLE(offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length);\n  return ieee754.read(this, offset, true, 23, 4);\n};\n\nBuffer.prototype.readFloatBE = function readFloatBE(offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length);\n  return ieee754.read(this, offset, false, 23, 4);\n};\n\nBuffer.prototype.readDoubleLE = function readDoubleLE(offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 8, this.length);\n  return ieee754.read(this, offset, true, 52, 8);\n};\n\nBuffer.prototype.readDoubleBE = function readDoubleBE(offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 8, this.length);\n  return ieee754.read(this, offset, false, 52, 8);\n};\n\nfunction checkInt(buf, value, offset, ext, max, min) {\n  if (!Buffer.isBuffer(buf)) throw new TypeError('\"buffer\" argument must be a Buffer instance');\n  if (value > max || value < min) throw new RangeError('\"value\" argument is out of bounds');\n  if (offset + ext > buf.length) throw new RangeError('Index out of range');\n}\n\nBuffer.prototype.writeUIntLE = function writeUIntLE(value, offset, byteLength, noAssert) {\n  value = +value;\n  offset = offset | 0;\n  byteLength = byteLength | 0;\n  if (!noAssert) {\n    var maxBytes = Math.pow(2, 8 * byteLength) - 1;\n    checkInt(this, value, offset, byteLength, maxBytes, 0);\n  }\n\n  var mul = 1;\n  var i = 0;\n  this[offset] = value & 0xFF;\n  while (++i < byteLength && (mul *= 0x100)) {\n    this[offset + i] = value / mul & 0xFF;\n  }\n\n  return offset + byteLength;\n};\n\nBuffer.prototype.writeUIntBE = function writeUIntBE(value, offset, byteLength, noAssert) {\n  value = +value;\n  offset = offset | 0;\n  byteLength = byteLength | 0;\n  if (!noAssert) {\n    var maxBytes = Math.pow(2, 8 * byteLength) - 1;\n    checkInt(this, value, offset, byteLength, maxBytes, 0);\n  }\n\n  var i = byteLength - 1;\n  var mul = 1;\n  this[offset + i] = value & 0xFF;\n  while (--i >= 0 && (mul *= 0x100)) {\n    this[offset + i] = value / mul & 0xFF;\n  }\n\n  return offset + byteLength;\n};\n\nBuffer.prototype.writeUInt8 = function writeUInt8(value, offset, noAssert) {\n  value = +value;\n  offset = offset | 0;\n  if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0);\n  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value);\n  this[offset] = value & 0xff;\n  return offset + 1;\n};\n\nfunction objectWriteUInt16(buf, value, offset, littleEndian) {\n  if (value < 0) value = 0xffff + value + 1;\n  for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; ++i) {\n    buf[offset + i] = (value & 0xff << 8 * (littleEndian ? i : 1 - i)) >>> (littleEndian ? i : 1 - i) * 8;\n  }\n}\n\nBuffer.prototype.writeUInt16LE = function writeUInt16LE(value, offset, noAssert) {\n  value = +value;\n  offset = offset | 0;\n  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0);\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = value & 0xff;\n    this[offset + 1] = value >>> 8;\n  } else {\n    objectWriteUInt16(this, value, offset, true);\n  }\n  return offset + 2;\n};\n\nBuffer.prototype.writeUInt16BE = function writeUInt16BE(value, offset, noAssert) {\n  value = +value;\n  offset = offset | 0;\n  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0);\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = value >>> 8;\n    this[offset + 1] = value & 0xff;\n  } else {\n    objectWriteUInt16(this, value, offset, false);\n  }\n  return offset + 2;\n};\n\nfunction objectWriteUInt32(buf, value, offset, littleEndian) {\n  if (value < 0) value = 0xffffffff + value + 1;\n  for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; ++i) {\n    buf[offset + i] = value >>> (littleEndian ? i : 3 - i) * 8 & 0xff;\n  }\n}\n\nBuffer.prototype.writeUInt32LE = function writeUInt32LE(value, offset, noAssert) {\n  value = +value;\n  offset = offset | 0;\n  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0);\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset + 3] = value >>> 24;\n    this[offset + 2] = value >>> 16;\n    this[offset + 1] = value >>> 8;\n    this[offset] = value & 0xff;\n  } else {\n    objectWriteUInt32(this, value, offset, true);\n  }\n  return offset + 4;\n};\n\nBuffer.prototype.writeUInt32BE = function writeUInt32BE(value, offset, noAssert) {\n  value = +value;\n  offset = offset | 0;\n  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0);\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = value >>> 24;\n    this[offset + 1] = value >>> 16;\n    this[offset + 2] = value >>> 8;\n    this[offset + 3] = value & 0xff;\n  } else {\n    objectWriteUInt32(this, value, offset, false);\n  }\n  return offset + 4;\n};\n\nBuffer.prototype.writeIntLE = function writeIntLE(value, offset, byteLength, noAssert) {\n  value = +value;\n  offset = offset | 0;\n  if (!noAssert) {\n    var limit = Math.pow(2, 8 * byteLength - 1);\n\n    checkInt(this, value, offset, byteLength, limit - 1, -limit);\n  }\n\n  var i = 0;\n  var mul = 1;\n  var sub = 0;\n  this[offset] = value & 0xFF;\n  while (++i < byteLength && (mul *= 0x100)) {\n    if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {\n      sub = 1;\n    }\n    this[offset + i] = (value / mul >> 0) - sub & 0xFF;\n  }\n\n  return offset + byteLength;\n};\n\nBuffer.prototype.writeIntBE = function writeIntBE(value, offset, byteLength, noAssert) {\n  value = +value;\n  offset = offset | 0;\n  if (!noAssert) {\n    var limit = Math.pow(2, 8 * byteLength - 1);\n\n    checkInt(this, value, offset, byteLength, limit - 1, -limit);\n  }\n\n  var i = byteLength - 1;\n  var mul = 1;\n  var sub = 0;\n  this[offset + i] = value & 0xFF;\n  while (--i >= 0 && (mul *= 0x100)) {\n    if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {\n      sub = 1;\n    }\n    this[offset + i] = (value / mul >> 0) - sub & 0xFF;\n  }\n\n  return offset + byteLength;\n};\n\nBuffer.prototype.writeInt8 = function writeInt8(value, offset, noAssert) {\n  value = +value;\n  offset = offset | 0;\n  if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80);\n  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value);\n  if (value < 0) value = 0xff + value + 1;\n  this[offset] = value & 0xff;\n  return offset + 1;\n};\n\nBuffer.prototype.writeInt16LE = function writeInt16LE(value, offset, noAssert) {\n  value = +value;\n  offset = offset | 0;\n  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000);\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = value & 0xff;\n    this[offset + 1] = value >>> 8;\n  } else {\n    objectWriteUInt16(this, value, offset, true);\n  }\n  return offset + 2;\n};\n\nBuffer.prototype.writeInt16BE = function writeInt16BE(value, offset, noAssert) {\n  value = +value;\n  offset = offset | 0;\n  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000);\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = value >>> 8;\n    this[offset + 1] = value & 0xff;\n  } else {\n    objectWriteUInt16(this, value, offset, false);\n  }\n  return offset + 2;\n};\n\nBuffer.prototype.writeInt32LE = function writeInt32LE(value, offset, noAssert) {\n  value = +value;\n  offset = offset | 0;\n  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000);\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = value & 0xff;\n    this[offset + 1] = value >>> 8;\n    this[offset + 2] = value >>> 16;\n    this[offset + 3] = value >>> 24;\n  } else {\n    objectWriteUInt32(this, value, offset, true);\n  }\n  return offset + 4;\n};\n\nBuffer.prototype.writeInt32BE = function writeInt32BE(value, offset, noAssert) {\n  value = +value;\n  offset = offset | 0;\n  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000);\n  if (value < 0) value = 0xffffffff + value + 1;\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = value >>> 24;\n    this[offset + 1] = value >>> 16;\n    this[offset + 2] = value >>> 8;\n    this[offset + 3] = value & 0xff;\n  } else {\n    objectWriteUInt32(this, value, offset, false);\n  }\n  return offset + 4;\n};\n\nfunction checkIEEE754(buf, value, offset, ext, max, min) {\n  if (offset + ext > buf.length) throw new RangeError('Index out of range');\n  if (offset < 0) throw new RangeError('Index out of range');\n}\n\nfunction writeFloat(buf, value, offset, littleEndian, noAssert) {\n  if (!noAssert) {\n    checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38);\n  }\n  ieee754.write(buf, value, offset, littleEndian, 23, 4);\n  return offset + 4;\n}\n\nBuffer.prototype.writeFloatLE = function writeFloatLE(value, offset, noAssert) {\n  return writeFloat(this, value, offset, true, noAssert);\n};\n\nBuffer.prototype.writeFloatBE = function writeFloatBE(value, offset, noAssert) {\n  return writeFloat(this, value, offset, false, noAssert);\n};\n\nfunction writeDouble(buf, value, offset, littleEndian, noAssert) {\n  if (!noAssert) {\n    checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308);\n  }\n  ieee754.write(buf, value, offset, littleEndian, 52, 8);\n  return offset + 8;\n}\n\nBuffer.prototype.writeDoubleLE = function writeDoubleLE(value, offset, noAssert) {\n  return writeDouble(this, value, offset, true, noAssert);\n};\n\nBuffer.prototype.writeDoubleBE = function writeDoubleBE(value, offset, noAssert) {\n  return writeDouble(this, value, offset, false, noAssert);\n};\n\n// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)\nBuffer.prototype.copy = function copy(target, targetStart, start, end) {\n  if (!start) start = 0;\n  if (!end && end !== 0) end = this.length;\n  if (targetStart >= target.length) targetStart = target.length;\n  if (!targetStart) targetStart = 0;\n  if (end > 0 && end < start) end = start;\n\n  // Copy 0 bytes; we're done\n  if (end === start) return 0;\n  if (target.length === 0 || this.length === 0) return 0;\n\n  // Fatal error conditions\n  if (targetStart < 0) {\n    throw new RangeError('targetStart out of bounds');\n  }\n  if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds');\n  if (end < 0) throw new RangeError('sourceEnd out of bounds');\n\n  // Are we oob?\n  if (end > this.length) end = this.length;\n  if (target.length - targetStart < end - start) {\n    end = target.length - targetStart + start;\n  }\n\n  var len = end - start;\n  var i;\n\n  if (this === target && start < targetStart && targetStart < end) {\n    // descending copy from end\n    for (i = len - 1; i >= 0; --i) {\n      target[i + targetStart] = this[i + start];\n    }\n  } else if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) {\n    // ascending copy from start\n    for (i = 0; i < len; ++i) {\n      target[i + targetStart] = this[i + start];\n    }\n  } else {\n    Uint8Array.prototype.set.call(target, this.subarray(start, start + len), targetStart);\n  }\n\n  return len;\n};\n\n// Usage:\n//    buffer.fill(number[, offset[, end]])\n//    buffer.fill(buffer[, offset[, end]])\n//    buffer.fill(string[, offset[, end]][, encoding])\nBuffer.prototype.fill = function fill(val, start, end, encoding) {\n  // Handle string cases:\n  if (typeof val === 'string') {\n    if (typeof start === 'string') {\n      encoding = start;\n      start = 0;\n      end = this.length;\n    } else if (typeof end === 'string') {\n      encoding = end;\n      end = this.length;\n    }\n    if (val.length === 1) {\n      var code = val.charCodeAt(0);\n      if (code < 256) {\n        val = code;\n      }\n    }\n    if (encoding !== undefined && typeof encoding !== 'string') {\n      throw new TypeError('encoding must be a string');\n    }\n    if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {\n      throw new TypeError('Unknown encoding: ' + encoding);\n    }\n  } else if (typeof val === 'number') {\n    val = val & 255;\n  }\n\n  // Invalid ranges are not set to a default, so can range check early.\n  if (start < 0 || this.length < start || this.length < end) {\n    throw new RangeError('Out of range index');\n  }\n\n  if (end <= start) {\n    return this;\n  }\n\n  start = start >>> 0;\n  end = end === undefined ? this.length : end >>> 0;\n\n  if (!val) val = 0;\n\n  var i;\n  if (typeof val === 'number') {\n    for (i = start; i < end; ++i) {\n      this[i] = val;\n    }\n  } else {\n    var bytes = Buffer.isBuffer(val) ? val : utf8ToBytes(new Buffer(val, encoding).toString());\n    var len = bytes.length;\n    for (i = 0; i < end - start; ++i) {\n      this[i + start] = bytes[i % len];\n    }\n  }\n\n  return this;\n};\n\n// HELPER FUNCTIONS\n// ================\n\nvar INVALID_BASE64_RE = /[^+\\/0-9A-Za-z-_]/g;\n\nfunction base64clean(str) {\n  // Node strips out invalid characters like \\n and \\t from the string, base64-js does not\n  str = stringtrim(str).replace(INVALID_BASE64_RE, '');\n  // Node converts strings with length < 2 to ''\n  if (str.length < 2) return '';\n  // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not\n  while (str.length % 4 !== 0) {\n    str = str + '=';\n  }\n  return str;\n}\n\nfunction stringtrim(str) {\n  if (str.trim) return str.trim();\n  return str.replace(/^\\s+|\\s+$/g, '');\n}\n\nfunction toHex(n) {\n  if (n < 16) return '0' + n.toString(16);\n  return n.toString(16);\n}\n\nfunction utf8ToBytes(string, units) {\n  units = units || Infinity;\n  var codePoint;\n  var length = string.length;\n  var leadSurrogate = null;\n  var bytes = [];\n\n  for (var i = 0; i < length; ++i) {\n    codePoint = string.charCodeAt(i);\n\n    // is surrogate component\n    if (codePoint > 0xD7FF && codePoint < 0xE000) {\n      // last char was a lead\n      if (!leadSurrogate) {\n        // no lead yet\n        if (codePoint > 0xDBFF) {\n          // unexpected trail\n          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD);\n          continue;\n        } else if (i + 1 === length) {\n          // unpaired lead\n          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD);\n          continue;\n        }\n\n        // valid lead\n        leadSurrogate = codePoint;\n\n        continue;\n      }\n\n      // 2 leads in a row\n      if (codePoint < 0xDC00) {\n        if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD);\n        leadSurrogate = codePoint;\n        continue;\n      }\n\n      // valid surrogate pair\n      codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000;\n    } else if (leadSurrogate) {\n      // valid bmp char, but last char was a lead\n      if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD);\n    }\n\n    leadSurrogate = null;\n\n    // encode utf8\n    if (codePoint < 0x80) {\n      if ((units -= 1) < 0) break;\n      bytes.push(codePoint);\n    } else if (codePoint < 0x800) {\n      if ((units -= 2) < 0) break;\n      bytes.push(codePoint >> 0x6 | 0xC0, codePoint & 0x3F | 0x80);\n    } else if (codePoint < 0x10000) {\n      if ((units -= 3) < 0) break;\n      bytes.push(codePoint >> 0xC | 0xE0, codePoint >> 0x6 & 0x3F | 0x80, codePoint & 0x3F | 0x80);\n    } else if (codePoint < 0x110000) {\n      if ((units -= 4) < 0) break;\n      bytes.push(codePoint >> 0x12 | 0xF0, codePoint >> 0xC & 0x3F | 0x80, codePoint >> 0x6 & 0x3F | 0x80, codePoint & 0x3F | 0x80);\n    } else {\n      throw new Error('Invalid code point');\n    }\n  }\n\n  return bytes;\n}\n\nfunction asciiToBytes(str) {\n  var byteArray = [];\n  for (var i = 0; i < str.length; ++i) {\n    // Node's code seems to be doing this and not & 0x7F..\n    byteArray.push(str.charCodeAt(i) & 0xFF);\n  }\n  return byteArray;\n}\n\nfunction utf16leToBytes(str, units) {\n  var c, hi, lo;\n  var byteArray = [];\n  for (var i = 0; i < str.length; ++i) {\n    if ((units -= 2) < 0) break;\n\n    c = str.charCodeAt(i);\n    hi = c >> 8;\n    lo = c % 256;\n    byteArray.push(lo);\n    byteArray.push(hi);\n  }\n\n  return byteArray;\n}\n\nfunction base64ToBytes(str) {\n  return base64.toByteArray(base64clean(str));\n}\n\nfunction blitBuffer(src, dst, offset, length) {\n  for (var i = 0; i < length; ++i) {\n    if (i + offset >= dst.length || i >= src.length) break;\n    dst[i + offset] = src[i];\n  }\n  return i;\n}\n\nfunction isnan(val) {\n  return val !== val; // eslint-disable-line no-self-compare\n}\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(5)))\n\n/***/ }),\n/* 3 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nif (typeof Object.create === 'function') {\n  // implementation from standard node.js 'util' module\n  module.exports = function inherits(ctor, superCtor) {\n    ctor.super_ = superCtor;\n    ctor.prototype = Object.create(superCtor.prototype, {\n      constructor: {\n        value: ctor,\n        enumerable: false,\n        writable: true,\n        configurable: true\n      }\n    });\n  };\n} else {\n  // old school shim for old browsers\n  module.exports = function inherits(ctor, superCtor) {\n    ctor.super_ = superCtor;\n    var TempCtor = function TempCtor() {};\n    TempCtor.prototype = superCtor.prototype;\n    ctor.prototype = new TempCtor();\n    ctor.prototype.constructor = ctor;\n  };\n}\n\n/***/ }),\n/* 4 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar assert = __webpack_require__(6);\nvar inherits = __webpack_require__(3);\n\nexports.inherits = inherits;\n\nfunction toArray(msg, enc) {\n  if (Array.isArray(msg)) return msg.slice();\n  if (!msg) return [];\n  var res = [];\n  if (typeof msg === 'string') {\n    if (!enc) {\n      for (var i = 0; i < msg.length; i++) {\n        var c = msg.charCodeAt(i);\n        var hi = c >> 8;\n        var lo = c & 0xff;\n        if (hi) res.push(hi, lo);else res.push(lo);\n      }\n    } else if (enc === 'hex') {\n      msg = msg.replace(/[^a-z0-9]+/ig, '');\n      if (msg.length % 2 !== 0) msg = '0' + msg;\n      for (i = 0; i < msg.length; i += 2) {\n        res.push(parseInt(msg[i] + msg[i + 1], 16));\n      }\n    }\n  } else {\n    for (i = 0; i < msg.length; i++) {\n      res[i] = msg[i] | 0;\n    }\n  }\n  return res;\n}\nexports.toArray = toArray;\n\nfunction toHex(msg) {\n  var res = '';\n  for (var i = 0; i < msg.length; i++) {\n    res += zero2(msg[i].toString(16));\n  }return res;\n}\nexports.toHex = toHex;\n\nfunction htonl(w) {\n  var res = w >>> 24 | w >>> 8 & 0xff00 | w << 8 & 0xff0000 | (w & 0xff) << 24;\n  return res >>> 0;\n}\nexports.htonl = htonl;\n\nfunction toHex32(msg, endian) {\n  var res = '';\n  for (var i = 0; i < msg.length; i++) {\n    var w = msg[i];\n    if (endian === 'little') w = htonl(w);\n    res += zero8(w.toString(16));\n  }\n  return res;\n}\nexports.toHex32 = toHex32;\n\nfunction zero2(word) {\n  if (word.length === 1) return '0' + word;else return word;\n}\nexports.zero2 = zero2;\n\nfunction zero8(word) {\n  if (word.length === 7) return '0' + word;else if (word.length === 6) return '00' + word;else if (word.length === 5) return '000' + word;else if (word.length === 4) return '0000' + word;else if (word.length === 3) return '00000' + word;else if (word.length === 2) return '000000' + word;else if (word.length === 1) return '0000000' + word;else return word;\n}\nexports.zero8 = zero8;\n\nfunction join32(msg, start, end, endian) {\n  var len = end - start;\n  assert(len % 4 === 0);\n  var res = new Array(len / 4);\n  for (var i = 0, k = start; i < res.length; i++, k += 4) {\n    var w;\n    if (endian === 'big') w = msg[k] << 24 | msg[k + 1] << 16 | msg[k + 2] << 8 | msg[k + 3];else w = msg[k + 3] << 24 | msg[k + 2] << 16 | msg[k + 1] << 8 | msg[k];\n    res[i] = w >>> 0;\n  }\n  return res;\n}\nexports.join32 = join32;\n\nfunction split32(msg, endian) {\n  var res = new Array(msg.length * 4);\n  for (var i = 0, k = 0; i < msg.length; i++, k += 4) {\n    var m = msg[i];\n    if (endian === 'big') {\n      res[k] = m >>> 24;\n      res[k + 1] = m >>> 16 & 0xff;\n      res[k + 2] = m >>> 8 & 0xff;\n      res[k + 3] = m & 0xff;\n    } else {\n      res[k + 3] = m >>> 24;\n      res[k + 2] = m >>> 16 & 0xff;\n      res[k + 1] = m >>> 8 & 0xff;\n      res[k] = m & 0xff;\n    }\n  }\n  return res;\n}\nexports.split32 = split32;\n\nfunction rotr32(w, b) {\n  return w >>> b | w << 32 - b;\n}\nexports.rotr32 = rotr32;\n\nfunction rotl32(w, b) {\n  return w << b | w >>> 32 - b;\n}\nexports.rotl32 = rotl32;\n\nfunction sum32(a, b) {\n  return a + b >>> 0;\n}\nexports.sum32 = sum32;\n\nfunction sum32_3(a, b, c) {\n  return a + b + c >>> 0;\n}\nexports.sum32_3 = sum32_3;\n\nfunction sum32_4(a, b, c, d) {\n  return a + b + c + d >>> 0;\n}\nexports.sum32_4 = sum32_4;\n\nfunction sum32_5(a, b, c, d, e) {\n  return a + b + c + d + e >>> 0;\n}\nexports.sum32_5 = sum32_5;\n\nfunction sum64(buf, pos, ah, al) {\n  var bh = buf[pos];\n  var bl = buf[pos + 1];\n\n  var lo = al + bl >>> 0;\n  var hi = (lo < al ? 1 : 0) + ah + bh;\n  buf[pos] = hi >>> 0;\n  buf[pos + 1] = lo;\n}\nexports.sum64 = sum64;\n\nfunction sum64_hi(ah, al, bh, bl) {\n  var lo = al + bl >>> 0;\n  var hi = (lo < al ? 1 : 0) + ah + bh;\n  return hi >>> 0;\n}\nexports.sum64_hi = sum64_hi;\n\nfunction sum64_lo(ah, al, bh, bl) {\n  var lo = al + bl;\n  return lo >>> 0;\n}\nexports.sum64_lo = sum64_lo;\n\nfunction sum64_4_hi(ah, al, bh, bl, ch, cl, dh, dl) {\n  var carry = 0;\n  var lo = al;\n  lo = lo + bl >>> 0;\n  carry += lo < al ? 1 : 0;\n  lo = lo + cl >>> 0;\n  carry += lo < cl ? 1 : 0;\n  lo = lo + dl >>> 0;\n  carry += lo < dl ? 1 : 0;\n\n  var hi = ah + bh + ch + dh + carry;\n  return hi >>> 0;\n}\nexports.sum64_4_hi = sum64_4_hi;\n\nfunction sum64_4_lo(ah, al, bh, bl, ch, cl, dh, dl) {\n  var lo = al + bl + cl + dl;\n  return lo >>> 0;\n}\nexports.sum64_4_lo = sum64_4_lo;\n\nfunction sum64_5_hi(ah, al, bh, bl, ch, cl, dh, dl, eh, el) {\n  var carry = 0;\n  var lo = al;\n  lo = lo + bl >>> 0;\n  carry += lo < al ? 1 : 0;\n  lo = lo + cl >>> 0;\n  carry += lo < cl ? 1 : 0;\n  lo = lo + dl >>> 0;\n  carry += lo < dl ? 1 : 0;\n  lo = lo + el >>> 0;\n  carry += lo < el ? 1 : 0;\n\n  var hi = ah + bh + ch + dh + eh + carry;\n  return hi >>> 0;\n}\nexports.sum64_5_hi = sum64_5_hi;\n\nfunction sum64_5_lo(ah, al, bh, bl, ch, cl, dh, dl, eh, el) {\n  var lo = al + bl + cl + dl + el;\n\n  return lo >>> 0;\n}\nexports.sum64_5_lo = sum64_5_lo;\n\nfunction rotr64_hi(ah, al, num) {\n  var r = al << 32 - num | ah >>> num;\n  return r >>> 0;\n}\nexports.rotr64_hi = rotr64_hi;\n\nfunction rotr64_lo(ah, al, num) {\n  var r = ah << 32 - num | al >>> num;\n  return r >>> 0;\n}\nexports.rotr64_lo = rotr64_lo;\n\nfunction shr64_hi(ah, al, num) {\n  return ah >>> num;\n}\nexports.shr64_hi = shr64_hi;\n\nfunction shr64_lo(ah, al, num) {\n  var r = ah << 32 - num | al >>> num;\n  return r >>> 0;\n}\nexports.shr64_lo = shr64_lo;\n\n/***/ }),\n/* 5 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; };\n\nvar g;\n\n// This works in non-strict mode\ng = function () {\n\treturn this;\n}();\n\ntry {\n\t// This works if eval is allowed (see CSP)\n\tg = g || Function(\"return this\")() || (1, eval)(\"this\");\n} catch (e) {\n\t// This works if the window reference is available\n\tif ((typeof window === \"undefined\" ? \"undefined\" : _typeof(window)) === \"object\") g = window;\n}\n\n// g can still be undefined, but nothing to do about it...\n// We return undefined, instead of nothing here, so it's\n// easier to handle this case. if(!global) { ...}\n\nmodule.exports = g;\n\n/***/ }),\n/* 6 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nmodule.exports = assert;\n\nfunction assert(val, msg) {\n  if (!val) throw new Error(msg || 'Assertion failed');\n}\n\nassert.equal = function assertEqual(l, r, msg) {\n  if (l != r) throw new Error(msg || 'Assertion failed: ' + l + ' != ' + r);\n};\n\n/***/ }),\n/* 7 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// a duplex stream is just a stream that is both readable and writable.\n// Since JS doesn't have multiple prototypal inheritance, this class\n// prototypally inherits from Readable, and then parasitically from\n// Writable.\n\n\n\n/*<replacement>*/\n\nvar processNextTick = __webpack_require__(13);\n/*</replacement>*/\n\n/*<replacement>*/\nvar objectKeys = Object.keys || function (obj) {\n  var keys = [];\n  for (var key in obj) {\n    keys.push(key);\n  }return keys;\n};\n/*</replacement>*/\n\nmodule.exports = Duplex;\n\n/*<replacement>*/\nvar util = __webpack_require__(10);\nutil.inherits = __webpack_require__(3);\n/*</replacement>*/\n\nvar Readable = __webpack_require__(28);\nvar Writable = __webpack_require__(20);\n\nutil.inherits(Duplex, Readable);\n\nvar keys = objectKeys(Writable.prototype);\nfor (var v = 0; v < keys.length; v++) {\n  var method = keys[v];\n  if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable.prototype[method];\n}\n\nfunction Duplex(options) {\n  if (!(this instanceof Duplex)) return new Duplex(options);\n\n  Readable.call(this, options);\n  Writable.call(this, options);\n\n  if (options && options.readable === false) this.readable = false;\n\n  if (options && options.writable === false) this.writable = false;\n\n  this.allowHalfOpen = true;\n  if (options && options.allowHalfOpen === false) this.allowHalfOpen = false;\n\n  this.once('end', onend);\n}\n\n// the no-half-open enforcer\nfunction onend() {\n  // if we allow half-open state, or if the writable side ended,\n  // then we're ok.\n  if (this.allowHalfOpen || this._writableState.ended) return;\n\n  // no more data can be written.\n  // But allow more writes to happen in this tick.\n  processNextTick(onEndNT, this);\n}\n\nfunction onEndNT(self) {\n  self.end();\n}\n\nObject.defineProperty(Duplex.prototype, 'destroyed', {\n  get: function get() {\n    if (this._readableState === undefined || this._writableState === undefined) {\n      return false;\n    }\n    return this._readableState.destroyed && this._writableState.destroyed;\n  },\n  set: function set(value) {\n    // we ignore the value if the stream\n    // has not been initialized yet\n    if (this._readableState === undefined || this._writableState === undefined) {\n      return;\n    }\n\n    // backward compatibility, the user is explicitly\n    // managing destroyed\n    this._readableState.destroyed = value;\n    this._writableState.destroyed = value;\n  }\n});\n\nDuplex.prototype._destroy = function (err, cb) {\n  this.push(null);\n  this.end();\n\n  processNextTick(cb, err);\n};\n\nfunction forEach(xs, f) {\n  for (var i = 0, l = xs.length; i < l; i++) {\n    f(xs[i], i);\n  }\n}\n\n/***/ }),\n/* 8 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar utils = __webpack_require__(4);\nvar assert = __webpack_require__(6);\n\nfunction BlockHash() {\n  this.pending = null;\n  this.pendingTotal = 0;\n  this.blockSize = this.constructor.blockSize;\n  this.outSize = this.constructor.outSize;\n  this.hmacStrength = this.constructor.hmacStrength;\n  this.padLength = this.constructor.padLength / 8;\n  this.endian = 'big';\n\n  this._delta8 = this.blockSize / 8;\n  this._delta32 = this.blockSize / 32;\n}\nexports.BlockHash = BlockHash;\n\nBlockHash.prototype.update = function update(msg, enc) {\n  // Convert message to array, pad it, and join into 32bit blocks\n  msg = utils.toArray(msg, enc);\n  if (!this.pending) this.pending = msg;else this.pending = this.pending.concat(msg);\n  this.pendingTotal += msg.length;\n\n  // Enough data, try updating\n  if (this.pending.length >= this._delta8) {\n    msg = this.pending;\n\n    // Process pending data in blocks\n    var r = msg.length % this._delta8;\n    this.pending = msg.slice(msg.length - r, msg.length);\n    if (this.pending.length === 0) this.pending = null;\n\n    msg = utils.join32(msg, 0, msg.length - r, this.endian);\n    for (var i = 0; i < msg.length; i += this._delta32) {\n      this._update(msg, i, i + this._delta32);\n    }\n  }\n\n  return this;\n};\n\nBlockHash.prototype.digest = function digest(enc) {\n  this.update(this._pad());\n  assert(this.pending === null);\n\n  return this._digest(enc);\n};\n\nBlockHash.prototype._pad = function pad() {\n  var len = this.pendingTotal;\n  var bytes = this._delta8;\n  var k = bytes - (len + this.padLength) % bytes;\n  var res = new Array(k + this.padLength);\n  res[0] = 0x80;\n  for (var i = 1; i < k; i++) {\n    res[i] = 0;\n  } // Append length\n  len <<= 3;\n  if (this.endian === 'big') {\n    for (var t = 8; t < this.padLength; t++) {\n      res[i++] = 0;\n    }res[i++] = 0;\n    res[i++] = 0;\n    res[i++] = 0;\n    res[i++] = 0;\n    res[i++] = len >>> 24 & 0xff;\n    res[i++] = len >>> 16 & 0xff;\n    res[i++] = len >>> 8 & 0xff;\n    res[i++] = len & 0xff;\n  } else {\n    res[i++] = len & 0xff;\n    res[i++] = len >>> 8 & 0xff;\n    res[i++] = len >>> 16 & 0xff;\n    res[i++] = len >>> 24 & 0xff;\n    res[i++] = 0;\n    res[i++] = 0;\n    res[i++] = 0;\n    res[i++] = 0;\n\n    for (t = 8; t < this.padLength; t++) {\n      res[i++] = 0;\n    }\n  }\n\n  return res;\n};\n\n/***/ }),\n/* 9 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\n// shim for using process in browser\nvar process = module.exports = {};\n\n// cached from whatever global is present so that test runners that stub it\n// don't break things.  But we need to wrap it in a try catch in case it is\n// wrapped in strict mode code which doesn't define any globals.  It's inside a\n// function because try/catches deoptimize in certain engines.\n\nvar cachedSetTimeout;\nvar cachedClearTimeout;\n\nfunction defaultSetTimout() {\n    throw new Error('setTimeout has not been defined');\n}\nfunction defaultClearTimeout() {\n    throw new Error('clearTimeout has not been defined');\n}\n(function () {\n    try {\n        if (typeof setTimeout === 'function') {\n            cachedSetTimeout = setTimeout;\n        } else {\n            cachedSetTimeout = defaultSetTimout;\n        }\n    } catch (e) {\n        cachedSetTimeout = defaultSetTimout;\n    }\n    try {\n        if (typeof clearTimeout === 'function') {\n            cachedClearTimeout = clearTimeout;\n        } else {\n            cachedClearTimeout = defaultClearTimeout;\n        }\n    } catch (e) {\n        cachedClearTimeout = defaultClearTimeout;\n    }\n})();\nfunction runTimeout(fun) {\n    if (cachedSetTimeout === setTimeout) {\n        //normal enviroments in sane situations\n        return setTimeout(fun, 0);\n    }\n    // if setTimeout wasn't available but was latter defined\n    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n        cachedSetTimeout = setTimeout;\n        return setTimeout(fun, 0);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedSetTimeout(fun, 0);\n    } catch (e) {\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n            return cachedSetTimeout.call(null, fun, 0);\n        } catch (e) {\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error\n            return cachedSetTimeout.call(this, fun, 0);\n        }\n    }\n}\nfunction runClearTimeout(marker) {\n    if (cachedClearTimeout === clearTimeout) {\n        //normal enviroments in sane situations\n        return clearTimeout(marker);\n    }\n    // if clearTimeout wasn't available but was latter defined\n    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n        cachedClearTimeout = clearTimeout;\n        return clearTimeout(marker);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedClearTimeout(marker);\n    } catch (e) {\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally\n            return cachedClearTimeout.call(null, marker);\n        } catch (e) {\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.\n            // Some versions of I.E. have different rules for clearTimeout vs setTimeout\n            return cachedClearTimeout.call(this, marker);\n        }\n    }\n}\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\n\nfunction cleanUpNextTick() {\n    if (!draining || !currentQueue) {\n        return;\n    }\n    draining = false;\n    if (currentQueue.length) {\n        queue = currentQueue.concat(queue);\n    } else {\n        queueIndex = -1;\n    }\n    if (queue.length) {\n        drainQueue();\n    }\n}\n\nfunction drainQueue() {\n    if (draining) {\n        return;\n    }\n    var timeout = runTimeout(cleanUpNextTick);\n    draining = true;\n\n    var len = queue.length;\n    while (len) {\n        currentQueue = queue;\n        queue = [];\n        while (++queueIndex < len) {\n            if (currentQueue) {\n                currentQueue[queueIndex].run();\n            }\n        }\n        queueIndex = -1;\n        len = queue.length;\n    }\n    currentQueue = null;\n    draining = false;\n    runClearTimeout(timeout);\n}\n\nprocess.nextTick = function (fun) {\n    var args = new Array(arguments.length - 1);\n    if (arguments.length > 1) {\n        for (var i = 1; i < arguments.length; i++) {\n            args[i - 1] = arguments[i];\n        }\n    }\n    queue.push(new Item(fun, args));\n    if (queue.length === 1 && !draining) {\n        runTimeout(drainQueue);\n    }\n};\n\n// v8 likes predictible objects\nfunction Item(fun, array) {\n    this.fun = fun;\n    this.array = array;\n}\nItem.prototype.run = function () {\n    this.fun.apply(null, this.array);\n};\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\nprocess.version = ''; // empty string to avoid regexp issues\nprocess.versions = {};\n\nfunction noop() {}\n\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\nprocess.prependListener = noop;\nprocess.prependOnceListener = noop;\n\nprocess.listeners = function (name) {\n    return [];\n};\n\nprocess.binding = function (name) {\n    throw new Error('process.binding is not supported');\n};\n\nprocess.cwd = function () {\n    return '/';\n};\nprocess.chdir = function (dir) {\n    throw new Error('process.chdir is not supported');\n};\nprocess.umask = function () {\n    return 0;\n};\n\n/***/ }),\n/* 10 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/* WEBPACK VAR INJECTION */(function(Buffer) {\n\nvar _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; };\n\n// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// NOTE: These type checking functions intentionally don't use `instanceof`\n// because it is fragile and can be easily faked with `Object.create()`.\n\nfunction isArray(arg) {\n  if (Array.isArray) {\n    return Array.isArray(arg);\n  }\n  return objectToString(arg) === '[object Array]';\n}\nexports.isArray = isArray;\n\nfunction isBoolean(arg) {\n  return typeof arg === 'boolean';\n}\nexports.isBoolean = isBoolean;\n\nfunction isNull(arg) {\n  return arg === null;\n}\nexports.isNull = isNull;\n\nfunction isNullOrUndefined(arg) {\n  return arg == null;\n}\nexports.isNullOrUndefined = isNullOrUndefined;\n\nfunction isNumber(arg) {\n  return typeof arg === 'number';\n}\nexports.isNumber = isNumber;\n\nfunction isString(arg) {\n  return typeof arg === 'string';\n}\nexports.isString = isString;\n\nfunction isSymbol(arg) {\n  return (typeof arg === 'undefined' ? 'undefined' : _typeof(arg)) === 'symbol';\n}\nexports.isSymbol = isSymbol;\n\nfunction isUndefined(arg) {\n  return arg === void 0;\n}\nexports.isUndefined = isUndefined;\n\nfunction isRegExp(re) {\n  return objectToString(re) === '[object RegExp]';\n}\nexports.isRegExp = isRegExp;\n\nfunction isObject(arg) {\n  return (typeof arg === 'undefined' ? 'undefined' : _typeof(arg)) === 'object' && arg !== null;\n}\nexports.isObject = isObject;\n\nfunction isDate(d) {\n  return objectToString(d) === '[object Date]';\n}\nexports.isDate = isDate;\n\nfunction isError(e) {\n  return objectToString(e) === '[object Error]' || e instanceof Error;\n}\nexports.isError = isError;\n\nfunction isFunction(arg) {\n  return typeof arg === 'function';\n}\nexports.isFunction = isFunction;\n\nfunction isPrimitive(arg) {\n  return arg === null || typeof arg === 'boolean' || typeof arg === 'number' || typeof arg === 'string' || (typeof arg === 'undefined' ? 'undefined' : _typeof(arg)) === 'symbol' || // ES6 symbol\n  typeof arg === 'undefined';\n}\nexports.isPrimitive = isPrimitive;\n\nexports.isBuffer = Buffer.isBuffer;\n\nfunction objectToString(o) {\n  return Object.prototype.toString.call(o);\n}\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(2).Buffer))\n\n/***/ }),\n/* 11 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar curve = exports;\n\ncurve.base = __webpack_require__(44);\ncurve.short = __webpack_require__(45);\ncurve.mont = __webpack_require__(46);\ncurve.edwards = __webpack_require__(47);\n\n/***/ }),\n/* 12 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/* WEBPACK VAR INJECTION */(function(Buffer) {\n\n// based on:\n//   https://github.com/ethereumjs/rlp/raw/3122e47f7c2ff2c7efa67acfeabe02a5f3a3670a/index.js\n\n/**\r\n * RLP Encoding based on: https://github.com/ethereum/wiki/wiki/%5BEnglish%5D-RLP\r\n * This function takes in a data, convert it to buffer if not, and a length for recursion\r\n *\r\n * @param {Buffer,String,Integer,Array} data - will be converted to buffer\r\n * @returns {Buffer} - returns buffer of encoded data\r\n **/\nfunction encode(input) {\n  if (input instanceof Array) {\n    var output = [];\n    for (var i = 0; i < input.length; i++) {\n      output.push(encode(input[i]));\n    }\n    var buf = Buffer.concat(output);\n    return Buffer.concat([encodeLength(buf.length, 192), buf]);\n  } else {\n    input = toBuffer(input);\n    if (input.length === 1 && input[0] < 128) {\n      return input;\n    } else {\n      return Buffer.concat([encodeLength(input.length, 128), input]);\n    }\n  }\n}\n\nfunction safeParseInt(v, base) {\n  if (v.slice(0, 2) === '00') {\n    throw new Error('invalid RLP: extra zeros');\n  }\n\n  return parseInt(v, base);\n}\n\nfunction encodeLength(len, offset) {\n  if (len < 56) {\n    return new Buffer([len + offset]);\n  } else {\n    var hexLength = intToHex(len);\n    var lLength = hexLength.length / 2;\n    var firstByte = intToHex(offset + 55 + lLength);\n    return new Buffer(firstByte + hexLength, 'hex');\n  }\n}\n\nfunction isHexPrefixed(str) {\n  return str.slice(0, 2) === '0x';\n}\n\n// Removes 0x from a given String\nfunction stripHexPrefix(str) {\n  if (typeof str !== 'string') {\n    return str;\n  }\n  return isHexPrefixed(str) ? str.slice(2) : str;\n}\n\n// Removes leading zeros from: Buffer, Array, or String\nfunction stripZeros(a) {\n  a = stripHexPrefix(a);\n  var first = a[0];\n  while (a.length > 0 && first.toString() === '0') {\n    a = a.slice(1);\n    first = a[0];\n  }\n  return a;\n}\n\nfunction intToHex(i) {\n  var hex = i.toString(16);\n  if (hex.length % 2) {\n    hex = '0' + hex;\n  }\n\n  return hex;\n}\n\nfunction padToEven(a) {\n  if (a.length % 2) a = '0' + a;\n  return a;\n}\n\nfunction intToBuffer(i) {\n  var hex = intToHex(i);\n  return new Buffer(hex, 'hex');\n}\n\nfunction toBuffer(v) {\n  if (!Buffer.isBuffer(v)) {\n    if (Array.isArray(v)) {\n      v = Buffer.from(v);\n    } else if (typeof v === 'string') {\n      if (isHexPrefixed(v)) {\n        v = Buffer.from(padToEven(stripHexPrefix(v)), 'hex');\n      } else {\n        v = Buffer.from(v);\n      }\n    } else if (typeof v === 'number') {\n      v = intToBuffer(v);\n    } else if (v === null || v === undefined) {\n      v = Buffer.allocUnsafe(0);\n    } else if (v.toArray) {\n      // converts a BN to a Buffer\n      v = Buffer.from(v.toArray());\n    } else {\n      throw new Error('invalid type');\n    }\n  }\n  return v;\n}\n\nfunction bufferToHex(buf) {\n  var add_prefix = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;\n\n  buf = toBuffer(buf);\n  if (!buf || buf.length === 0) return '';else return (add_prefix ? '0x' : '') + buf.toString('hex');\n}\n\nfunction bufferToInt(buf) {\n  return parseInt(bufferToHex(buf), 16);\n}\n\nmodule.exports = { encode: encode, isHexPrefixed: isHexPrefixed, stripHexPrefix: stripHexPrefix, stripZeros: stripZeros, intToHex: intToHex, padToEven: padToEven, intToBuffer: intToBuffer, toBuffer: toBuffer, bufferToHex: bufferToHex, bufferToInt: bufferToInt };\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(2).Buffer))\n\n/***/ }),\n/* 13 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/* WEBPACK VAR INJECTION */(function(process) {\n\nif (!process.version || process.version.indexOf('v0.') === 0 || process.version.indexOf('v1.') === 0 && process.version.indexOf('v1.8.') !== 0) {\n  module.exports = nextTick;\n} else {\n  module.exports = process.nextTick;\n}\n\nfunction nextTick(fn, arg1, arg2, arg3) {\n  if (typeof fn !== 'function') {\n    throw new TypeError('\"callback\" argument must be a function');\n  }\n  var len = arguments.length;\n  var args, i;\n  switch (len) {\n    case 0:\n    case 1:\n      return process.nextTick(fn);\n    case 2:\n      return process.nextTick(function afterTickOne() {\n        fn.call(null, arg1);\n      });\n    case 3:\n      return process.nextTick(function afterTickTwo() {\n        fn.call(null, arg1, arg2);\n      });\n    case 4:\n      return process.nextTick(function afterTickThree() {\n        fn.call(null, arg1, arg2, arg3);\n      });\n    default:\n      args = new Array(len - 1);\n      i = 0;\n      while (i < args.length) {\n        args[i++] = arguments[i];\n      }\n      return process.nextTick(function afterTick() {\n        fn.apply(null, args);\n      });\n  }\n}\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(9)))\n\n/***/ }),\n/* 14 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\n/* eslint-disable node/no-deprecated-api */\nvar buffer = __webpack_require__(2);\nvar Buffer = buffer.Buffer;\n\n// alternative to using Object.keys for old browsers\nfunction copyProps(src, dst) {\n  for (var key in src) {\n    dst[key] = src[key];\n  }\n}\nif (Buffer.from && Buffer.alloc && Buffer.allocUnsafe && Buffer.allocUnsafeSlow) {\n  module.exports = buffer;\n} else {\n  // Copy properties from require('buffer')\n  copyProps(buffer, exports);\n  exports.Buffer = SafeBuffer;\n}\n\nfunction SafeBuffer(arg, encodingOrOffset, length) {\n  return Buffer(arg, encodingOrOffset, length);\n}\n\n// Copy static methods from Buffer\ncopyProps(Buffer, SafeBuffer);\n\nSafeBuffer.from = function (arg, encodingOrOffset, length) {\n  if (typeof arg === 'number') {\n    throw new TypeError('Argument must not be a number');\n  }\n  return Buffer(arg, encodingOrOffset, length);\n};\n\nSafeBuffer.alloc = function (size, fill, encoding) {\n  if (typeof size !== 'number') {\n    throw new TypeError('Argument must be a number');\n  }\n  var buf = Buffer(size);\n  if (fill !== undefined) {\n    if (typeof encoding === 'string') {\n      buf.fill(fill, encoding);\n    } else {\n      buf.fill(fill);\n    }\n  } else {\n    buf.fill(0);\n  }\n  return buf;\n};\n\nSafeBuffer.allocUnsafe = function (size) {\n  if (typeof size !== 'number') {\n    throw new TypeError('Argument must be a number');\n  }\n  return Buffer(size);\n};\n\nSafeBuffer.allocUnsafeSlow = function (size) {\n  if (typeof size !== 'number') {\n    throw new TypeError('Argument must be a number');\n  }\n  return buffer.SlowBuffer(size);\n};\n\n/***/ }),\n/* 15 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar hash = exports;\n\nhash.utils = __webpack_require__(4);\nhash.common = __webpack_require__(8);\nhash.sha = __webpack_require__(49);\nhash.ripemd = __webpack_require__(53);\nhash.hmac = __webpack_require__(54);\n\n// Proxy hash functions to the main object\nhash.sha1 = hash.sha.sha1;\nhash.sha256 = hash.sha.sha256;\nhash.sha224 = hash.sha.sha224;\nhash.sha384 = hash.sha.sha384;\nhash.sha512 = hash.sha.sha512;\nhash.ripemd160 = hash.ripemd.ripemd160;\n\n/***/ }),\n/* 16 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/* WEBPACK VAR INJECTION */(function(global, process) {\n\nvar _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; };\n\n// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nvar formatRegExp = /%[sdj%]/g;\nexports.format = function (f) {\n  if (!isString(f)) {\n    var objects = [];\n    for (var i = 0; i < arguments.length; i++) {\n      objects.push(inspect(arguments[i]));\n    }\n    return objects.join(' ');\n  }\n\n  var i = 1;\n  var args = arguments;\n  var len = args.length;\n  var str = String(f).replace(formatRegExp, function (x) {\n    if (x === '%%') return '%';\n    if (i >= len) return x;\n    switch (x) {\n      case '%s':\n        return String(args[i++]);\n      case '%d':\n        return Number(args[i++]);\n      case '%j':\n        try {\n          return JSON.stringify(args[i++]);\n        } catch (_) {\n          return '[Circular]';\n        }\n      default:\n        return x;\n    }\n  });\n  for (var x = args[i]; i < len; x = args[++i]) {\n    if (isNull(x) || !isObject(x)) {\n      str += ' ' + x;\n    } else {\n      str += ' ' + inspect(x);\n    }\n  }\n  return str;\n};\n\n// Mark that a method should not be used.\n// Returns a modified function which warns once by default.\n// If --no-deprecation is set, then it is a no-op.\nexports.deprecate = function (fn, msg) {\n  // Allow for deprecating things in the process of starting up.\n  if (isUndefined(global.process)) {\n    return function () {\n      return exports.deprecate(fn, msg).apply(this, arguments);\n    };\n  }\n\n  if (process.noDeprecation === true) {\n    return fn;\n  }\n\n  var warned = false;\n  function deprecated() {\n    if (!warned) {\n      if (process.throwDeprecation) {\n        throw new Error(msg);\n      } else if (process.traceDeprecation) {\n        console.trace(msg);\n      } else {\n        console.error(msg);\n      }\n      warned = true;\n    }\n    return fn.apply(this, arguments);\n  }\n\n  return deprecated;\n};\n\nvar debugs = {};\nvar debugEnviron;\nexports.debuglog = function (set) {\n  if (isUndefined(debugEnviron)) debugEnviron = Object({\"NODE_ENV\":\"production\"}).NODE_DEBUG || '';\n  set = set.toUpperCase();\n  if (!debugs[set]) {\n    if (new RegExp('\\\\b' + set + '\\\\b', 'i').test(debugEnviron)) {\n      var pid = process.pid;\n      debugs[set] = function () {\n        var msg = exports.format.apply(exports, arguments);\n        console.error('%s %d: %s', set, pid, msg);\n      };\n    } else {\n      debugs[set] = function () {};\n    }\n  }\n  return debugs[set];\n};\n\n/**\n * Echos the value of a value. Trys to print the value out\n * in the best way possible given the different types.\n *\n * @param {Object} obj The object to print out.\n * @param {Object} opts Optional options object that alters the output.\n */\n/* legacy: obj, showHidden, depth, colors*/\nfunction inspect(obj, opts) {\n  // default options\n  var ctx = {\n    seen: [],\n    stylize: stylizeNoColor\n  };\n  // legacy...\n  if (arguments.length >= 3) ctx.depth = arguments[2];\n  if (arguments.length >= 4) ctx.colors = arguments[3];\n  if (isBoolean(opts)) {\n    // legacy...\n    ctx.showHidden = opts;\n  } else if (opts) {\n    // got an \"options\" object\n    exports._extend(ctx, opts);\n  }\n  // set default options\n  if (isUndefined(ctx.showHidden)) ctx.showHidden = false;\n  if (isUndefined(ctx.depth)) ctx.depth = 2;\n  if (isUndefined(ctx.colors)) ctx.colors = false;\n  if (isUndefined(ctx.customInspect)) ctx.customInspect = true;\n  if (ctx.colors) ctx.stylize = stylizeWithColor;\n  return formatValue(ctx, obj, ctx.depth);\n}\nexports.inspect = inspect;\n\n// http://en.wikipedia.org/wiki/ANSI_escape_code#graphics\ninspect.colors = {\n  'bold': [1, 22],\n  'italic': [3, 23],\n  'underline': [4, 24],\n  'inverse': [7, 27],\n  'white': [37, 39],\n  'grey': [90, 39],\n  'black': [30, 39],\n  'blue': [34, 39],\n  'cyan': [36, 39],\n  'green': [32, 39],\n  'magenta': [35, 39],\n  'red': [31, 39],\n  'yellow': [33, 39]\n};\n\n// Don't use 'blue' not visible on cmd.exe\ninspect.styles = {\n  'special': 'cyan',\n  'number': 'yellow',\n  'boolean': 'yellow',\n  'undefined': 'grey',\n  'null': 'bold',\n  'string': 'green',\n  'date': 'magenta',\n  // \"name\": intentionally not styling\n  'regexp': 'red'\n};\n\nfunction stylizeWithColor(str, styleType) {\n  var style = inspect.styles[styleType];\n\n  if (style) {\n    return '\\x1B[' + inspect.colors[style][0] + 'm' + str + '\\x1B[' + inspect.colors[style][1] + 'm';\n  } else {\n    return str;\n  }\n}\n\nfunction stylizeNoColor(str, styleType) {\n  return str;\n}\n\nfunction arrayToHash(array) {\n  var hash = {};\n\n  array.forEach(function (val, idx) {\n    hash[val] = true;\n  });\n\n  return hash;\n}\n\nfunction formatValue(ctx, value, recurseTimes) {\n  // Provide a hook for user-specified inspect functions.\n  // Check that value is an object with an inspect function on it\n  if (ctx.customInspect && value && isFunction(value.inspect) &&\n  // Filter out the util module, it's inspect function is special\n  value.inspect !== exports.inspect &&\n  // Also filter out any prototype objects using the circular check.\n  !(value.constructor && value.constructor.prototype === value)) {\n    var ret = value.inspect(recurseTimes, ctx);\n    if (!isString(ret)) {\n      ret = formatValue(ctx, ret, recurseTimes);\n    }\n    return ret;\n  }\n\n  // Primitive types cannot have properties\n  var primitive = formatPrimitive(ctx, value);\n  if (primitive) {\n    return primitive;\n  }\n\n  // Look up the keys of the object.\n  var keys = Object.keys(value);\n  var visibleKeys = arrayToHash(keys);\n\n  if (ctx.showHidden) {\n    keys = Object.getOwnPropertyNames(value);\n  }\n\n  // IE doesn't make error fields non-enumerable\n  // http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx\n  if (isError(value) && (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) {\n    return formatError(value);\n  }\n\n  // Some type of object without properties can be shortcutted.\n  if (keys.length === 0) {\n    if (isFunction(value)) {\n      var name = value.name ? ': ' + value.name : '';\n      return ctx.stylize('[Function' + name + ']', 'special');\n    }\n    if (isRegExp(value)) {\n      return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');\n    }\n    if (isDate(value)) {\n      return ctx.stylize(Date.prototype.toString.call(value), 'date');\n    }\n    if (isError(value)) {\n      return formatError(value);\n    }\n  }\n\n  var base = '',\n      array = false,\n      braces = ['{', '}'];\n\n  // Make Array say that they are Array\n  if (isArray(value)) {\n    array = true;\n    braces = ['[', ']'];\n  }\n\n  // Make functions say that they are functions\n  if (isFunction(value)) {\n    var n = value.name ? ': ' + value.name : '';\n    base = ' [Function' + n + ']';\n  }\n\n  // Make RegExps say that they are RegExps\n  if (isRegExp(value)) {\n    base = ' ' + RegExp.prototype.toString.call(value);\n  }\n\n  // Make dates with properties first say the date\n  if (isDate(value)) {\n    base = ' ' + Date.prototype.toUTCString.call(value);\n  }\n\n  // Make error with message first say the error\n  if (isError(value)) {\n    base = ' ' + formatError(value);\n  }\n\n  if (keys.length === 0 && (!array || value.length == 0)) {\n    return braces[0] + base + braces[1];\n  }\n\n  if (recurseTimes < 0) {\n    if (isRegExp(value)) {\n      return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');\n    } else {\n      return ctx.stylize('[Object]', 'special');\n    }\n  }\n\n  ctx.seen.push(value);\n\n  var output;\n  if (array) {\n    output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);\n  } else {\n    output = keys.map(function (key) {\n      return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);\n    });\n  }\n\n  ctx.seen.pop();\n\n  return reduceToSingleString(output, base, braces);\n}\n\nfunction formatPrimitive(ctx, value) {\n  if (isUndefined(value)) return ctx.stylize('undefined', 'undefined');\n  if (isString(value)) {\n    var simple = '\\'' + JSON.stringify(value).replace(/^\"|\"$/g, '').replace(/'/g, \"\\\\'\").replace(/\\\\\"/g, '\"') + '\\'';\n    return ctx.stylize(simple, 'string');\n  }\n  if (isNumber(value)) return ctx.stylize('' + value, 'number');\n  if (isBoolean(value)) return ctx.stylize('' + value, 'boolean');\n  // For some reason typeof null is \"object\", so special case here.\n  if (isNull(value)) return ctx.stylize('null', 'null');\n}\n\nfunction formatError(value) {\n  return '[' + Error.prototype.toString.call(value) + ']';\n}\n\nfunction formatArray(ctx, value, recurseTimes, visibleKeys, keys) {\n  var output = [];\n  for (var i = 0, l = value.length; i < l; ++i) {\n    if (hasOwnProperty(value, String(i))) {\n      output.push(formatProperty(ctx, value, recurseTimes, visibleKeys, String(i), true));\n    } else {\n      output.push('');\n    }\n  }\n  keys.forEach(function (key) {\n    if (!key.match(/^\\d+$/)) {\n      output.push(formatProperty(ctx, value, recurseTimes, visibleKeys, key, true));\n    }\n  });\n  return output;\n}\n\nfunction formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {\n  var name, str, desc;\n  desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] };\n  if (desc.get) {\n    if (desc.set) {\n      str = ctx.stylize('[Getter/Setter]', 'special');\n    } else {\n      str = ctx.stylize('[Getter]', 'special');\n    }\n  } else {\n    if (desc.set) {\n      str = ctx.stylize('[Setter]', 'special');\n    }\n  }\n  if (!hasOwnProperty(visibleKeys, key)) {\n    name = '[' + key + ']';\n  }\n  if (!str) {\n    if (ctx.seen.indexOf(desc.value) < 0) {\n      if (isNull(recurseTimes)) {\n        str = formatValue(ctx, desc.value, null);\n      } else {\n        str = formatValue(ctx, desc.value, recurseTimes - 1);\n      }\n      if (str.indexOf('\\n') > -1) {\n        if (array) {\n          str = str.split('\\n').map(function (line) {\n            return '  ' + line;\n          }).join('\\n').substr(2);\n        } else {\n          str = '\\n' + str.split('\\n').map(function (line) {\n            return '   ' + line;\n          }).join('\\n');\n        }\n      }\n    } else {\n      str = ctx.stylize('[Circular]', 'special');\n    }\n  }\n  if (isUndefined(name)) {\n    if (array && key.match(/^\\d+$/)) {\n      return str;\n    }\n    name = JSON.stringify('' + key);\n    if (name.match(/^\"([a-zA-Z_][a-zA-Z_0-9]*)\"$/)) {\n      name = name.substr(1, name.length - 2);\n      name = ctx.stylize(name, 'name');\n    } else {\n      name = name.replace(/'/g, \"\\\\'\").replace(/\\\\\"/g, '\"').replace(/(^\"|\"$)/g, \"'\");\n      name = ctx.stylize(name, 'string');\n    }\n  }\n\n  return name + ': ' + str;\n}\n\nfunction reduceToSingleString(output, base, braces) {\n  var numLinesEst = 0;\n  var length = output.reduce(function (prev, cur) {\n    numLinesEst++;\n    if (cur.indexOf('\\n') >= 0) numLinesEst++;\n    return prev + cur.replace(/\\u001b\\[\\d\\d?m/g, '').length + 1;\n  }, 0);\n\n  if (length > 60) {\n    return braces[0] + (base === '' ? '' : base + '\\n ') + ' ' + output.join(',\\n  ') + ' ' + braces[1];\n  }\n\n  return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];\n}\n\n// NOTE: These type checking functions intentionally don't use `instanceof`\n// because it is fragile and can be easily faked with `Object.create()`.\nfunction isArray(ar) {\n  return Array.isArray(ar);\n}\nexports.isArray = isArray;\n\nfunction isBoolean(arg) {\n  return typeof arg === 'boolean';\n}\nexports.isBoolean = isBoolean;\n\nfunction isNull(arg) {\n  return arg === null;\n}\nexports.isNull = isNull;\n\nfunction isNullOrUndefined(arg) {\n  return arg == null;\n}\nexports.isNullOrUndefined = isNullOrUndefined;\n\nfunction isNumber(arg) {\n  return typeof arg === 'number';\n}\nexports.isNumber = isNumber;\n\nfunction isString(arg) {\n  return typeof arg === 'string';\n}\nexports.isString = isString;\n\nfunction isSymbol(arg) {\n  return (typeof arg === 'undefined' ? 'undefined' : _typeof(arg)) === 'symbol';\n}\nexports.isSymbol = isSymbol;\n\nfunction isUndefined(arg) {\n  return arg === void 0;\n}\nexports.isUndefined = isUndefined;\n\nfunction isRegExp(re) {\n  return isObject(re) && objectToString(re) === '[object RegExp]';\n}\nexports.isRegExp = isRegExp;\n\nfunction isObject(arg) {\n  return (typeof arg === 'undefined' ? 'undefined' : _typeof(arg)) === 'object' && arg !== null;\n}\nexports.isObject = isObject;\n\nfunction isDate(d) {\n  return isObject(d) && objectToString(d) === '[object Date]';\n}\nexports.isDate = isDate;\n\nfunction isError(e) {\n  return isObject(e) && (objectToString(e) === '[object Error]' || e instanceof Error);\n}\nexports.isError = isError;\n\nfunction isFunction(arg) {\n  return typeof arg === 'function';\n}\nexports.isFunction = isFunction;\n\nfunction isPrimitive(arg) {\n  return arg === null || typeof arg === 'boolean' || typeof arg === 'number' || typeof arg === 'string' || (typeof arg === 'undefined' ? 'undefined' : _typeof(arg)) === 'symbol' || // ES6 symbol\n  typeof arg === 'undefined';\n}\nexports.isPrimitive = isPrimitive;\n\nexports.isBuffer = __webpack_require__(65);\n\nfunction objectToString(o) {\n  return Object.prototype.toString.call(o);\n}\n\nfunction pad(n) {\n  return n < 10 ? '0' + n.toString(10) : n.toString(10);\n}\n\nvar months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];\n\n// 26 Feb 16:19:34\nfunction timestamp() {\n  var d = new Date();\n  var time = [pad(d.getHours()), pad(d.getMinutes()), pad(d.getSeconds())].join(':');\n  return [d.getDate(), months[d.getMonth()], time].join(' ');\n}\n\n// log is just a thin wrapper to console.log that prepends a timestamp\nexports.log = function () {\n  console.log('%s - %s', timestamp(), exports.format.apply(exports, arguments));\n};\n\n/**\n * Inherit the prototype methods from one constructor into another.\n *\n * The Function.prototype.inherits from lang.js rewritten as a standalone\n * function (not on Function.prototype). NOTE: If this file is to be loaded\n * during bootstrapping this function needs to be rewritten using some native\n * functions as prototype setup using normal JavaScript does not work as\n * expected during bootstrapping (see mirror.js in r114903).\n *\n * @param {function} ctor Constructor function which needs to inherit the\n *     prototype.\n * @param {function} superCtor Constructor function to inherit prototype from.\n */\nexports.inherits = __webpack_require__(3);\n\nexports._extend = function (origin, add) {\n  // Don't do anything if add isn't an object\n  if (!add || !isObject(add)) return origin;\n\n  var keys = Object.keys(add);\n  var i = keys.length;\n  while (i--) {\n    origin[keys[i]] = add[keys[i]];\n  }\n  return origin;\n};\n\nfunction hasOwnProperty(obj, prop) {\n  return Object.prototype.hasOwnProperty.call(obj, prop);\n}\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(5), __webpack_require__(9)))\n\n/***/ }),\n/* 17 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\n// based on:\n//   https://github.com/cryptocoinjs/keccak/raw/v1.3.0/js.js\n//   https://github.com/cryptocoinjs/keccak/tree/v1.3.0/lib\n\nvar createKeccakHash = __webpack_require__(66)(__webpack_require__(79));\n\nvar toBuffer = __webpack_require__(12).toBuffer;\n\n// ====================\n// ethereumjs-util.sha3\n// ====================\nvar sha3 = function sha3(a, bits) {\n  a = toBuffer(a);\n  if (!bits) bits = 256;\n\n  return createKeccakHash('keccak' + bits).update(a).digest('hex');\n};\n\nmodule.exports = { createKeccakHash: createKeccakHash, sha3: sha3 };\n\n/***/ }),\n/* 18 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; };\n\n// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nfunction EventEmitter() {\n  this._events = this._events || {};\n  this._maxListeners = this._maxListeners || undefined;\n}\nmodule.exports = EventEmitter;\n\n// Backwards-compat with node 0.10.x\nEventEmitter.EventEmitter = EventEmitter;\n\nEventEmitter.prototype._events = undefined;\nEventEmitter.prototype._maxListeners = undefined;\n\n// By default EventEmitters will print a warning if more than 10 listeners are\n// added to it. This is a useful default which helps finding memory leaks.\nEventEmitter.defaultMaxListeners = 10;\n\n// Obviously not all Emitters should be limited to 10. This function allows\n// that to be increased. Set to zero for unlimited.\nEventEmitter.prototype.setMaxListeners = function (n) {\n  if (!isNumber(n) || n < 0 || isNaN(n)) throw TypeError('n must be a positive number');\n  this._maxListeners = n;\n  return this;\n};\n\nEventEmitter.prototype.emit = function (type) {\n  var er, handler, len, args, i, listeners;\n\n  if (!this._events) this._events = {};\n\n  // If there is no 'error' event listener then throw.\n  if (type === 'error') {\n    if (!this._events.error || isObject(this._events.error) && !this._events.error.length) {\n      er = arguments[1];\n      if (er instanceof Error) {\n        throw er; // Unhandled 'error' event\n      } else {\n        // At least give some kind of context to the user\n        var err = new Error('Uncaught, unspecified \"error\" event. (' + er + ')');\n        err.context = er;\n        throw err;\n      }\n    }\n  }\n\n  handler = this._events[type];\n\n  if (isUndefined(handler)) return false;\n\n  if (isFunction(handler)) {\n    switch (arguments.length) {\n      // fast cases\n      case 1:\n        handler.call(this);\n        break;\n      case 2:\n        handler.call(this, arguments[1]);\n        break;\n      case 3:\n        handler.call(this, arguments[1], arguments[2]);\n        break;\n      // slower\n      default:\n        args = Array.prototype.slice.call(arguments, 1);\n        handler.apply(this, args);\n    }\n  } else if (isObject(handler)) {\n    args = Array.prototype.slice.call(arguments, 1);\n    listeners = handler.slice();\n    len = listeners.length;\n    for (i = 0; i < len; i++) {\n      listeners[i].apply(this, args);\n    }\n  }\n\n  return true;\n};\n\nEventEmitter.prototype.addListener = function (type, listener) {\n  var m;\n\n  if (!isFunction(listener)) throw TypeError('listener must be a function');\n\n  if (!this._events) this._events = {};\n\n  // To avoid recursion in the case that type === \"newListener\"! Before\n  // adding it to the listeners, first emit \"newListener\".\n  if (this._events.newListener) this.emit('newListener', type, isFunction(listener.listener) ? listener.listener : listener);\n\n  if (!this._events[type])\n    // Optimize the case of one listener. Don't need the extra array object.\n    this._events[type] = listener;else if (isObject(this._events[type]))\n    // If we've already got an array, just append.\n    this._events[type].push(listener);else\n    // Adding the second element, need to change to array.\n    this._events[type] = [this._events[type], listener];\n\n  // Check for listener leak\n  if (isObject(this._events[type]) && !this._events[type].warned) {\n    if (!isUndefined(this._maxListeners)) {\n      m = this._maxListeners;\n    } else {\n      m = EventEmitter.defaultMaxListeners;\n    }\n\n    if (m && m > 0 && this._events[type].length > m) {\n      this._events[type].warned = true;\n      console.error('(node) warning: possible EventEmitter memory ' + 'leak detected. %d listeners added. ' + 'Use emitter.setMaxListeners() to increase limit.', this._events[type].length);\n      if (typeof console.trace === 'function') {\n        // not supported in IE 10\n        console.trace();\n      }\n    }\n  }\n\n  return this;\n};\n\nEventEmitter.prototype.on = EventEmitter.prototype.addListener;\n\nEventEmitter.prototype.once = function (type, listener) {\n  if (!isFunction(listener)) throw TypeError('listener must be a function');\n\n  var fired = false;\n\n  function g() {\n    this.removeListener(type, g);\n\n    if (!fired) {\n      fired = true;\n      listener.apply(this, arguments);\n    }\n  }\n\n  g.listener = listener;\n  this.on(type, g);\n\n  return this;\n};\n\n// emits a 'removeListener' event iff the listener was removed\nEventEmitter.prototype.removeListener = function (type, listener) {\n  var list, position, length, i;\n\n  if (!isFunction(listener)) throw TypeError('listener must be a function');\n\n  if (!this._events || !this._events[type]) return this;\n\n  list = this._events[type];\n  length = list.length;\n  position = -1;\n\n  if (list === listener || isFunction(list.listener) && list.listener === listener) {\n    delete this._events[type];\n    if (this._events.removeListener) this.emit('removeListener', type, listener);\n  } else if (isObject(list)) {\n    for (i = length; i-- > 0;) {\n      if (list[i] === listener || list[i].listener && list[i].listener === listener) {\n        position = i;\n        break;\n      }\n    }\n\n    if (position < 0) return this;\n\n    if (list.length === 1) {\n      list.length = 0;\n      delete this._events[type];\n    } else {\n      list.splice(position, 1);\n    }\n\n    if (this._events.removeListener) this.emit('removeListener', type, listener);\n  }\n\n  return this;\n};\n\nEventEmitter.prototype.removeAllListeners = function (type) {\n  var key, listeners;\n\n  if (!this._events) return this;\n\n  // not listening for removeListener, no need to emit\n  if (!this._events.removeListener) {\n    if (arguments.length === 0) this._events = {};else if (this._events[type]) delete this._events[type];\n    return this;\n  }\n\n  // emit removeListener for all listeners on all events\n  if (arguments.length === 0) {\n    for (key in this._events) {\n      if (key === 'removeListener') continue;\n      this.removeAllListeners(key);\n    }\n    this.removeAllListeners('removeListener');\n    this._events = {};\n    return this;\n  }\n\n  listeners = this._events[type];\n\n  if (isFunction(listeners)) {\n    this.removeListener(type, listeners);\n  } else if (listeners) {\n    // LIFO order\n    while (listeners.length) {\n      this.removeListener(type, listeners[listeners.length - 1]);\n    }\n  }\n  delete this._events[type];\n\n  return this;\n};\n\nEventEmitter.prototype.listeners = function (type) {\n  var ret;\n  if (!this._events || !this._events[type]) ret = [];else if (isFunction(this._events[type])) ret = [this._events[type]];else ret = this._events[type].slice();\n  return ret;\n};\n\nEventEmitter.prototype.listenerCount = function (type) {\n  if (this._events) {\n    var evlistener = this._events[type];\n\n    if (isFunction(evlistener)) return 1;else if (evlistener) return evlistener.length;\n  }\n  return 0;\n};\n\nEventEmitter.listenerCount = function (emitter, type) {\n  return emitter.listenerCount(type);\n};\n\nfunction isFunction(arg) {\n  return typeof arg === 'function';\n}\n\nfunction isNumber(arg) {\n  return typeof arg === 'number';\n}\n\nfunction isObject(arg) {\n  return (typeof arg === 'undefined' ? 'undefined' : _typeof(arg)) === 'object' && arg !== null;\n}\n\nfunction isUndefined(arg) {\n  return arg === void 0;\n}\n\n/***/ }),\n/* 19 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nexports = module.exports = __webpack_require__(28);\nexports.Stream = exports;\nexports.Readable = exports;\nexports.Writable = __webpack_require__(20);\nexports.Duplex = __webpack_require__(7);\nexports.Transform = __webpack_require__(32);\nexports.PassThrough = __webpack_require__(73);\n\n/***/ }),\n/* 20 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/* WEBPACK VAR INJECTION */(function(process, setImmediate, global) {// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// A bit simpler than readable streams.\n// Implement an async ._write(chunk, encoding, cb), and it'll handle all\n// the drain event emission and buffering.\n\n\n\n/*<replacement>*/\n\nvar processNextTick = __webpack_require__(13);\n/*</replacement>*/\n\nmodule.exports = Writable;\n\n/* <replacement> */\nfunction WriteReq(chunk, encoding, cb) {\n  this.chunk = chunk;\n  this.encoding = encoding;\n  this.callback = cb;\n  this.next = null;\n}\n\n// It seems a linked list but it is not\n// there will be only 2 of these for each stream\nfunction CorkedRequest(state) {\n  var _this = this;\n\n  this.next = null;\n  this.entry = null;\n  this.finish = function () {\n    onCorkedFinish(_this, state);\n  };\n}\n/* </replacement> */\n\n/*<replacement>*/\nvar asyncWrite = !process.browser && ['v0.10', 'v0.9.'].indexOf(process.version.slice(0, 5)) > -1 ? setImmediate : processNextTick;\n/*</replacement>*/\n\n/*<replacement>*/\nvar Duplex;\n/*</replacement>*/\n\nWritable.WritableState = WritableState;\n\n/*<replacement>*/\nvar util = __webpack_require__(10);\nutil.inherits = __webpack_require__(3);\n/*</replacement>*/\n\n/*<replacement>*/\nvar internalUtil = {\n  deprecate: __webpack_require__(72)\n};\n/*</replacement>*/\n\n/*<replacement>*/\nvar Stream = __webpack_require__(29);\n/*</replacement>*/\n\n/*<replacement>*/\nvar Buffer = __webpack_require__(14).Buffer;\nvar OurUint8Array = global.Uint8Array || function () {};\nfunction _uint8ArrayToBuffer(chunk) {\n  return Buffer.from(chunk);\n}\nfunction _isUint8Array(obj) {\n  return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;\n}\n/*</replacement>*/\n\nvar destroyImpl = __webpack_require__(30);\n\nutil.inherits(Writable, Stream);\n\nfunction nop() {}\n\nfunction WritableState(options, stream) {\n  Duplex = Duplex || __webpack_require__(7);\n\n  options = options || {};\n\n  // object stream flag to indicate whether or not this stream\n  // contains buffers or objects.\n  this.objectMode = !!options.objectMode;\n\n  if (stream instanceof Duplex) this.objectMode = this.objectMode || !!options.writableObjectMode;\n\n  // the point at which write() starts returning false\n  // Note: 0 is a valid value, means that we always return false if\n  // the entire buffer is not flushed immediately on write()\n  var hwm = options.highWaterMark;\n  var defaultHwm = this.objectMode ? 16 : 16 * 1024;\n  this.highWaterMark = hwm || hwm === 0 ? hwm : defaultHwm;\n\n  // cast to ints.\n  this.highWaterMark = Math.floor(this.highWaterMark);\n\n  // if _final has been called\n  this.finalCalled = false;\n\n  // drain event flag.\n  this.needDrain = false;\n  // at the start of calling end()\n  this.ending = false;\n  // when end() has been called, and returned\n  this.ended = false;\n  // when 'finish' is emitted\n  this.finished = false;\n\n  // has it been destroyed\n  this.destroyed = false;\n\n  // should we decode strings into buffers before passing to _write?\n  // this is here so that some node-core streams can optimize string\n  // handling at a lower level.\n  var noDecode = options.decodeStrings === false;\n  this.decodeStrings = !noDecode;\n\n  // Crypto is kind of old and crusty.  Historically, its default string\n  // encoding is 'binary' so we have to make this configurable.\n  // Everything else in the universe uses 'utf8', though.\n  this.defaultEncoding = options.defaultEncoding || 'utf8';\n\n  // not an actual buffer we keep track of, but a measurement\n  // of how much we're waiting to get pushed to some underlying\n  // socket or file.\n  this.length = 0;\n\n  // a flag to see when we're in the middle of a write.\n  this.writing = false;\n\n  // when true all writes will be buffered until .uncork() call\n  this.corked = 0;\n\n  // a flag to be able to tell if the onwrite cb is called immediately,\n  // or on a later tick.  We set this to true at first, because any\n  // actions that shouldn't happen until \"later\" should generally also\n  // not happen before the first write call.\n  this.sync = true;\n\n  // a flag to know if we're processing previously buffered items, which\n  // may call the _write() callback in the same tick, so that we don't\n  // end up in an overlapped onwrite situation.\n  this.bufferProcessing = false;\n\n  // the callback that's passed to _write(chunk,cb)\n  this.onwrite = function (er) {\n    onwrite(stream, er);\n  };\n\n  // the callback that the user supplies to write(chunk,encoding,cb)\n  this.writecb = null;\n\n  // the amount that is being written when _write is called.\n  this.writelen = 0;\n\n  this.bufferedRequest = null;\n  this.lastBufferedRequest = null;\n\n  // number of pending user-supplied write callbacks\n  // this must be 0 before 'finish' can be emitted\n  this.pendingcb = 0;\n\n  // emit prefinish if the only thing we're waiting for is _write cbs\n  // This is relevant for synchronous Transform streams\n  this.prefinished = false;\n\n  // True if the error was already emitted and should not be thrown again\n  this.errorEmitted = false;\n\n  // count buffered requests\n  this.bufferedRequestCount = 0;\n\n  // allocate the first CorkedRequest, there is always\n  // one allocated and free to use, and we maintain at most two\n  this.corkedRequestsFree = new CorkedRequest(this);\n}\n\nWritableState.prototype.getBuffer = function getBuffer() {\n  var current = this.bufferedRequest;\n  var out = [];\n  while (current) {\n    out.push(current);\n    current = current.next;\n  }\n  return out;\n};\n\n(function () {\n  try {\n    Object.defineProperty(WritableState.prototype, 'buffer', {\n      get: internalUtil.deprecate(function () {\n        return this.getBuffer();\n      }, '_writableState.buffer is deprecated. Use _writableState.getBuffer ' + 'instead.', 'DEP0003')\n    });\n  } catch (_) {}\n})();\n\n// Test _writableState for inheritance to account for Duplex streams,\n// whose prototype chain only points to Readable.\nvar realHasInstance;\nif (typeof Symbol === 'function' && Symbol.hasInstance && typeof Function.prototype[Symbol.hasInstance] === 'function') {\n  realHasInstance = Function.prototype[Symbol.hasInstance];\n  Object.defineProperty(Writable, Symbol.hasInstance, {\n    value: function value(object) {\n      if (realHasInstance.call(this, object)) return true;\n\n      return object && object._writableState instanceof WritableState;\n    }\n  });\n} else {\n  realHasInstance = function realHasInstance(object) {\n    return object instanceof this;\n  };\n}\n\nfunction Writable(options) {\n  Duplex = Duplex || __webpack_require__(7);\n\n  // Writable ctor is applied to Duplexes, too.\n  // `realHasInstance` is necessary because using plain `instanceof`\n  // would return false, as no `_writableState` property is attached.\n\n  // Trying to use the custom `instanceof` for Writable here will also break the\n  // Node.js LazyTransform implementation, which has a non-trivial getter for\n  // `_writableState` that would lead to infinite recursion.\n  if (!realHasInstance.call(Writable, this) && !(this instanceof Duplex)) {\n    return new Writable(options);\n  }\n\n  this._writableState = new WritableState(options, this);\n\n  // legacy.\n  this.writable = true;\n\n  if (options) {\n    if (typeof options.write === 'function') this._write = options.write;\n\n    if (typeof options.writev === 'function') this._writev = options.writev;\n\n    if (typeof options.destroy === 'function') this._destroy = options.destroy;\n\n    if (typeof options.final === 'function') this._final = options.final;\n  }\n\n  Stream.call(this);\n}\n\n// Otherwise people can pipe Writable streams, which is just wrong.\nWritable.prototype.pipe = function () {\n  this.emit('error', new Error('Cannot pipe, not readable'));\n};\n\nfunction writeAfterEnd(stream, cb) {\n  var er = new Error('write after end');\n  // TODO: defer error events consistently everywhere, not just the cb\n  stream.emit('error', er);\n  processNextTick(cb, er);\n}\n\n// Checks that a user-supplied chunk is valid, especially for the particular\n// mode the stream is in. Currently this means that `null` is never accepted\n// and undefined/non-string values are only allowed in object mode.\nfunction validChunk(stream, state, chunk, cb) {\n  var valid = true;\n  var er = false;\n\n  if (chunk === null) {\n    er = new TypeError('May not write null values to stream');\n  } else if (typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) {\n    er = new TypeError('Invalid non-string/buffer chunk');\n  }\n  if (er) {\n    stream.emit('error', er);\n    processNextTick(cb, er);\n    valid = false;\n  }\n  return valid;\n}\n\nWritable.prototype.write = function (chunk, encoding, cb) {\n  var state = this._writableState;\n  var ret = false;\n  var isBuf = _isUint8Array(chunk) && !state.objectMode;\n\n  if (isBuf && !Buffer.isBuffer(chunk)) {\n    chunk = _uint8ArrayToBuffer(chunk);\n  }\n\n  if (typeof encoding === 'function') {\n    cb = encoding;\n    encoding = null;\n  }\n\n  if (isBuf) encoding = 'buffer';else if (!encoding) encoding = state.defaultEncoding;\n\n  if (typeof cb !== 'function') cb = nop;\n\n  if (state.ended) writeAfterEnd(this, cb);else if (isBuf || validChunk(this, state, chunk, cb)) {\n    state.pendingcb++;\n    ret = writeOrBuffer(this, state, isBuf, chunk, encoding, cb);\n  }\n\n  return ret;\n};\n\nWritable.prototype.cork = function () {\n  var state = this._writableState;\n\n  state.corked++;\n};\n\nWritable.prototype.uncork = function () {\n  var state = this._writableState;\n\n  if (state.corked) {\n    state.corked--;\n\n    if (!state.writing && !state.corked && !state.finished && !state.bufferProcessing && state.bufferedRequest) clearBuffer(this, state);\n  }\n};\n\nWritable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) {\n  // node::ParseEncoding() requires lower case.\n  if (typeof encoding === 'string') encoding = encoding.toLowerCase();\n  if (!(['hex', 'utf8', 'utf-8', 'ascii', 'binary', 'base64', 'ucs2', 'ucs-2', 'utf16le', 'utf-16le', 'raw'].indexOf((encoding + '').toLowerCase()) > -1)) throw new TypeError('Unknown encoding: ' + encoding);\n  this._writableState.defaultEncoding = encoding;\n  return this;\n};\n\nfunction decodeChunk(state, chunk, encoding) {\n  if (!state.objectMode && state.decodeStrings !== false && typeof chunk === 'string') {\n    chunk = Buffer.from(chunk, encoding);\n  }\n  return chunk;\n}\n\n// if we're already writing something, then just put this\n// in the queue, and wait our turn.  Otherwise, call _write\n// If we return false, then we need a drain event, so set that flag.\nfunction writeOrBuffer(stream, state, isBuf, chunk, encoding, cb) {\n  if (!isBuf) {\n    var newChunk = decodeChunk(state, chunk, encoding);\n    if (chunk !== newChunk) {\n      isBuf = true;\n      encoding = 'buffer';\n      chunk = newChunk;\n    }\n  }\n  var len = state.objectMode ? 1 : chunk.length;\n\n  state.length += len;\n\n  var ret = state.length < state.highWaterMark;\n  // we must ensure that previous needDrain will not be reset to false.\n  if (!ret) state.needDrain = true;\n\n  if (state.writing || state.corked) {\n    var last = state.lastBufferedRequest;\n    state.lastBufferedRequest = {\n      chunk: chunk,\n      encoding: encoding,\n      isBuf: isBuf,\n      callback: cb,\n      next: null\n    };\n    if (last) {\n      last.next = state.lastBufferedRequest;\n    } else {\n      state.bufferedRequest = state.lastBufferedRequest;\n    }\n    state.bufferedRequestCount += 1;\n  } else {\n    doWrite(stream, state, false, len, chunk, encoding, cb);\n  }\n\n  return ret;\n}\n\nfunction doWrite(stream, state, writev, len, chunk, encoding, cb) {\n  state.writelen = len;\n  state.writecb = cb;\n  state.writing = true;\n  state.sync = true;\n  if (writev) stream._writev(chunk, state.onwrite);else stream._write(chunk, encoding, state.onwrite);\n  state.sync = false;\n}\n\nfunction onwriteError(stream, state, sync, er, cb) {\n  --state.pendingcb;\n\n  if (sync) {\n    // defer the callback if we are being called synchronously\n    // to avoid piling up things on the stack\n    processNextTick(cb, er);\n    // this can emit finish, and it will always happen\n    // after error\n    processNextTick(finishMaybe, stream, state);\n    stream._writableState.errorEmitted = true;\n    stream.emit('error', er);\n  } else {\n    // the caller expect this to happen before if\n    // it is async\n    cb(er);\n    stream._writableState.errorEmitted = true;\n    stream.emit('error', er);\n    // this can emit finish, but finish must\n    // always follow error\n    finishMaybe(stream, state);\n  }\n}\n\nfunction onwriteStateUpdate(state) {\n  state.writing = false;\n  state.writecb = null;\n  state.length -= state.writelen;\n  state.writelen = 0;\n}\n\nfunction onwrite(stream, er) {\n  var state = stream._writableState;\n  var sync = state.sync;\n  var cb = state.writecb;\n\n  onwriteStateUpdate(state);\n\n  if (er) onwriteError(stream, state, sync, er, cb);else {\n    // Check if we're actually ready to finish, but don't emit yet\n    var finished = needFinish(state);\n\n    if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) {\n      clearBuffer(stream, state);\n    }\n\n    if (sync) {\n      /*<replacement>*/\n      asyncWrite(afterWrite, stream, state, finished, cb);\n      /*</replacement>*/\n    } else {\n      afterWrite(stream, state, finished, cb);\n    }\n  }\n}\n\nfunction afterWrite(stream, state, finished, cb) {\n  if (!finished) onwriteDrain(stream, state);\n  state.pendingcb--;\n  cb();\n  finishMaybe(stream, state);\n}\n\n// Must force callback to be called on nextTick, so that we don't\n// emit 'drain' before the write() consumer gets the 'false' return\n// value, and has a chance to attach a 'drain' listener.\nfunction onwriteDrain(stream, state) {\n  if (state.length === 0 && state.needDrain) {\n    state.needDrain = false;\n    stream.emit('drain');\n  }\n}\n\n// if there's something in the buffer waiting, then process it\nfunction clearBuffer(stream, state) {\n  state.bufferProcessing = true;\n  var entry = state.bufferedRequest;\n\n  if (stream._writev && entry && entry.next) {\n    // Fast case, write everything using _writev()\n    var l = state.bufferedRequestCount;\n    var buffer = new Array(l);\n    var holder = state.corkedRequestsFree;\n    holder.entry = entry;\n\n    var count = 0;\n    var allBuffers = true;\n    while (entry) {\n      buffer[count] = entry;\n      if (!entry.isBuf) allBuffers = false;\n      entry = entry.next;\n      count += 1;\n    }\n    buffer.allBuffers = allBuffers;\n\n    doWrite(stream, state, true, state.length, buffer, '', holder.finish);\n\n    // doWrite is almost always async, defer these to save a bit of time\n    // as the hot path ends with doWrite\n    state.pendingcb++;\n    state.lastBufferedRequest = null;\n    if (holder.next) {\n      state.corkedRequestsFree = holder.next;\n      holder.next = null;\n    } else {\n      state.corkedRequestsFree = new CorkedRequest(state);\n    }\n  } else {\n    // Slow case, write chunks one-by-one\n    while (entry) {\n      var chunk = entry.chunk;\n      var encoding = entry.encoding;\n      var cb = entry.callback;\n      var len = state.objectMode ? 1 : chunk.length;\n\n      doWrite(stream, state, false, len, chunk, encoding, cb);\n      entry = entry.next;\n      // if we didn't call the onwrite immediately, then\n      // it means that we need to wait until it does.\n      // also, that means that the chunk and cb are currently\n      // being processed, so move the buffer counter past them.\n      if (state.writing) {\n        break;\n      }\n    }\n\n    if (entry === null) state.lastBufferedRequest = null;\n  }\n\n  state.bufferedRequestCount = 0;\n  state.bufferedRequest = entry;\n  state.bufferProcessing = false;\n}\n\nWritable.prototype._write = function (chunk, encoding, cb) {\n  cb(new Error('_write() is not implemented'));\n};\n\nWritable.prototype._writev = null;\n\nWritable.prototype.end = function (chunk, encoding, cb) {\n  var state = this._writableState;\n\n  if (typeof chunk === 'function') {\n    cb = chunk;\n    chunk = null;\n    encoding = null;\n  } else if (typeof encoding === 'function') {\n    cb = encoding;\n    encoding = null;\n  }\n\n  if (chunk !== null && chunk !== undefined) this.write(chunk, encoding);\n\n  // .end() fully uncorks\n  if (state.corked) {\n    state.corked = 1;\n    this.uncork();\n  }\n\n  // ignore unnecessary end() calls.\n  if (!state.ending && !state.finished) endWritable(this, state, cb);\n};\n\nfunction needFinish(state) {\n  return state.ending && state.length === 0 && state.bufferedRequest === null && !state.finished && !state.writing;\n}\nfunction callFinal(stream, state) {\n  stream._final(function (err) {\n    state.pendingcb--;\n    if (err) {\n      stream.emit('error', err);\n    }\n    state.prefinished = true;\n    stream.emit('prefinish');\n    finishMaybe(stream, state);\n  });\n}\nfunction prefinish(stream, state) {\n  if (!state.prefinished && !state.finalCalled) {\n    if (typeof stream._final === 'function') {\n      state.pendingcb++;\n      state.finalCalled = true;\n      processNextTick(callFinal, stream, state);\n    } else {\n      state.prefinished = true;\n      stream.emit('prefinish');\n    }\n  }\n}\n\nfunction finishMaybe(stream, state) {\n  var need = needFinish(state);\n  if (need) {\n    prefinish(stream, state);\n    if (state.pendingcb === 0) {\n      state.finished = true;\n      stream.emit('finish');\n    }\n  }\n  return need;\n}\n\nfunction endWritable(stream, state, cb) {\n  state.ending = true;\n  finishMaybe(stream, state);\n  if (cb) {\n    if (state.finished) processNextTick(cb);else stream.once('finish', cb);\n  }\n  state.ended = true;\n  stream.writable = false;\n}\n\nfunction onCorkedFinish(corkReq, state, err) {\n  var entry = corkReq.entry;\n  corkReq.entry = null;\n  while (entry) {\n    var cb = entry.callback;\n    state.pendingcb--;\n    cb(err);\n    entry = entry.next;\n  }\n  if (state.corkedRequestsFree) {\n    state.corkedRequestsFree.next = corkReq;\n  } else {\n    state.corkedRequestsFree = corkReq;\n  }\n}\n\nObject.defineProperty(Writable.prototype, 'destroyed', {\n  get: function get() {\n    if (this._writableState === undefined) {\n      return false;\n    }\n    return this._writableState.destroyed;\n  },\n  set: function set(value) {\n    // we ignore the value if the stream\n    // has not been initialized yet\n    if (!this._writableState) {\n      return;\n    }\n\n    // backward compatibility, the user is explicitly\n    // managing destroyed\n    this._writableState.destroyed = value;\n  }\n});\n\nWritable.prototype.destroy = destroyImpl.destroy;\nWritable.prototype._undestroy = destroyImpl.undestroy;\nWritable.prototype._destroy = function (err, cb) {\n  this.end();\n  cb(err);\n};\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(9), __webpack_require__(70).setImmediate, __webpack_require__(5)))\n\n/***/ }),\n/* 21 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar toString = {}.toString;\n\nmodule.exports = Array.isArray || function (arr) {\n  return toString.call(arr) == '[object Array]';\n};\n\n/***/ }),\n/* 22 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar utils = exports;\n\nfunction toArray(msg, enc) {\n  if (Array.isArray(msg)) return msg.slice();\n  if (!msg) return [];\n  var res = [];\n  if (typeof msg !== 'string') {\n    for (var i = 0; i < msg.length; i++) {\n      res[i] = msg[i] | 0;\n    }return res;\n  }\n  if (enc === 'hex') {\n    msg = msg.replace(/[^a-z0-9]+/ig, '');\n    if (msg.length % 2 !== 0) msg = '0' + msg;\n    for (var i = 0; i < msg.length; i += 2) {\n      res.push(parseInt(msg[i] + msg[i + 1], 16));\n    }\n  } else {\n    for (var i = 0; i < msg.length; i++) {\n      var c = msg.charCodeAt(i);\n      var hi = c >> 8;\n      var lo = c & 0xff;\n      if (hi) res.push(hi, lo);else res.push(lo);\n    }\n  }\n  return res;\n}\nutils.toArray = toArray;\n\nfunction zero2(word) {\n  if (word.length === 1) return '0' + word;else return word;\n}\nutils.zero2 = zero2;\n\nfunction toHex(msg) {\n  var res = '';\n  for (var i = 0; i < msg.length; i++) {\n    res += zero2(msg[i].toString(16));\n  }return res;\n}\nutils.toHex = toHex;\n\nutils.encode = function encode(arr, enc) {\n  if (enc === 'hex') return toHex(arr);else return arr;\n};\n\n/***/ }),\n/* 23 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar utils = __webpack_require__(4);\nvar rotr32 = utils.rotr32;\n\nfunction ft_1(s, x, y, z) {\n  if (s === 0) return ch32(x, y, z);\n  if (s === 1 || s === 3) return p32(x, y, z);\n  if (s === 2) return maj32(x, y, z);\n}\nexports.ft_1 = ft_1;\n\nfunction ch32(x, y, z) {\n  return x & y ^ ~x & z;\n}\nexports.ch32 = ch32;\n\nfunction maj32(x, y, z) {\n  return x & y ^ x & z ^ y & z;\n}\nexports.maj32 = maj32;\n\nfunction p32(x, y, z) {\n  return x ^ y ^ z;\n}\nexports.p32 = p32;\n\nfunction s0_256(x) {\n  return rotr32(x, 2) ^ rotr32(x, 13) ^ rotr32(x, 22);\n}\nexports.s0_256 = s0_256;\n\nfunction s1_256(x) {\n  return rotr32(x, 6) ^ rotr32(x, 11) ^ rotr32(x, 25);\n}\nexports.s1_256 = s1_256;\n\nfunction g0_256(x) {\n  return rotr32(x, 7) ^ rotr32(x, 18) ^ x >>> 3;\n}\nexports.g0_256 = g0_256;\n\nfunction g1_256(x) {\n  return rotr32(x, 17) ^ rotr32(x, 19) ^ x >>> 10;\n}\nexports.g1_256 = g1_256;\n\n/***/ }),\n/* 24 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar utils = __webpack_require__(4);\nvar common = __webpack_require__(8);\nvar shaCommon = __webpack_require__(23);\nvar assert = __webpack_require__(6);\n\nvar sum32 = utils.sum32;\nvar sum32_4 = utils.sum32_4;\nvar sum32_5 = utils.sum32_5;\nvar ch32 = shaCommon.ch32;\nvar maj32 = shaCommon.maj32;\nvar s0_256 = shaCommon.s0_256;\nvar s1_256 = shaCommon.s1_256;\nvar g0_256 = shaCommon.g0_256;\nvar g1_256 = shaCommon.g1_256;\n\nvar BlockHash = common.BlockHash;\n\nvar sha256_K = [0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5, 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174, 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da, 0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967, 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, 0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070, 0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3, 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2];\n\nfunction SHA256() {\n  if (!(this instanceof SHA256)) return new SHA256();\n\n  BlockHash.call(this);\n  this.h = [0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19];\n  this.k = sha256_K;\n  this.W = new Array(64);\n}\nutils.inherits(SHA256, BlockHash);\nmodule.exports = SHA256;\n\nSHA256.blockSize = 512;\nSHA256.outSize = 256;\nSHA256.hmacStrength = 192;\nSHA256.padLength = 64;\n\nSHA256.prototype._update = function _update(msg, start) {\n  var W = this.W;\n\n  for (var i = 0; i < 16; i++) {\n    W[i] = msg[start + i];\n  }for (; i < W.length; i++) {\n    W[i] = sum32_4(g1_256(W[i - 2]), W[i - 7], g0_256(W[i - 15]), W[i - 16]);\n  }var a = this.h[0];\n  var b = this.h[1];\n  var c = this.h[2];\n  var d = this.h[3];\n  var e = this.h[4];\n  var f = this.h[5];\n  var g = this.h[6];\n  var h = this.h[7];\n\n  assert(this.k.length === W.length);\n  for (i = 0; i < W.length; i++) {\n    var T1 = sum32_5(h, s1_256(e), ch32(e, f, g), this.k[i], W[i]);\n    var T2 = sum32(s0_256(a), maj32(a, b, c));\n    h = g;\n    g = f;\n    f = e;\n    e = sum32(d, T1);\n    d = c;\n    c = b;\n    b = a;\n    a = sum32(T1, T2);\n  }\n\n  this.h[0] = sum32(this.h[0], a);\n  this.h[1] = sum32(this.h[1], b);\n  this.h[2] = sum32(this.h[2], c);\n  this.h[3] = sum32(this.h[3], d);\n  this.h[4] = sum32(this.h[4], e);\n  this.h[5] = sum32(this.h[5], f);\n  this.h[6] = sum32(this.h[6], g);\n  this.h[7] = sum32(this.h[7], h);\n};\n\nSHA256.prototype._digest = function digest(enc) {\n  if (enc === 'hex') return utils.toHex32(this.h, 'big');else return utils.split32(this.h, 'big');\n};\n\n/***/ }),\n/* 25 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar utils = __webpack_require__(4);\nvar common = __webpack_require__(8);\nvar assert = __webpack_require__(6);\n\nvar rotr64_hi = utils.rotr64_hi;\nvar rotr64_lo = utils.rotr64_lo;\nvar shr64_hi = utils.shr64_hi;\nvar shr64_lo = utils.shr64_lo;\nvar sum64 = utils.sum64;\nvar sum64_hi = utils.sum64_hi;\nvar sum64_lo = utils.sum64_lo;\nvar sum64_4_hi = utils.sum64_4_hi;\nvar sum64_4_lo = utils.sum64_4_lo;\nvar sum64_5_hi = utils.sum64_5_hi;\nvar sum64_5_lo = utils.sum64_5_lo;\n\nvar BlockHash = common.BlockHash;\n\nvar sha512_K = [0x428a2f98, 0xd728ae22, 0x71374491, 0x23ef65cd, 0xb5c0fbcf, 0xec4d3b2f, 0xe9b5dba5, 0x8189dbbc, 0x3956c25b, 0xf348b538, 0x59f111f1, 0xb605d019, 0x923f82a4, 0xaf194f9b, 0xab1c5ed5, 0xda6d8118, 0xd807aa98, 0xa3030242, 0x12835b01, 0x45706fbe, 0x243185be, 0x4ee4b28c, 0x550c7dc3, 0xd5ffb4e2, 0x72be5d74, 0xf27b896f, 0x80deb1fe, 0x3b1696b1, 0x9bdc06a7, 0x25c71235, 0xc19bf174, 0xcf692694, 0xe49b69c1, 0x9ef14ad2, 0xefbe4786, 0x384f25e3, 0x0fc19dc6, 0x8b8cd5b5, 0x240ca1cc, 0x77ac9c65, 0x2de92c6f, 0x592b0275, 0x4a7484aa, 0x6ea6e483, 0x5cb0a9dc, 0xbd41fbd4, 0x76f988da, 0x831153b5, 0x983e5152, 0xee66dfab, 0xa831c66d, 0x2db43210, 0xb00327c8, 0x98fb213f, 0xbf597fc7, 0xbeef0ee4, 0xc6e00bf3, 0x3da88fc2, 0xd5a79147, 0x930aa725, 0x06ca6351, 0xe003826f, 0x14292967, 0x0a0e6e70, 0x27b70a85, 0x46d22ffc, 0x2e1b2138, 0x5c26c926, 0x4d2c6dfc, 0x5ac42aed, 0x53380d13, 0x9d95b3df, 0x650a7354, 0x8baf63de, 0x766a0abb, 0x3c77b2a8, 0x81c2c92e, 0x47edaee6, 0x92722c85, 0x1482353b, 0xa2bfe8a1, 0x4cf10364, 0xa81a664b, 0xbc423001, 0xc24b8b70, 0xd0f89791, 0xc76c51a3, 0x0654be30, 0xd192e819, 0xd6ef5218, 0xd6990624, 0x5565a910, 0xf40e3585, 0x5771202a, 0x106aa070, 0x32bbd1b8, 0x19a4c116, 0xb8d2d0c8, 0x1e376c08, 0x5141ab53, 0x2748774c, 0xdf8eeb99, 0x34b0bcb5, 0xe19b48a8, 0x391c0cb3, 0xc5c95a63, 0x4ed8aa4a, 0xe3418acb, 0x5b9cca4f, 0x7763e373, 0x682e6ff3, 0xd6b2b8a3, 0x748f82ee, 0x5defb2fc, 0x78a5636f, 0x43172f60, 0x84c87814, 0xa1f0ab72, 0x8cc70208, 0x1a6439ec, 0x90befffa, 0x23631e28, 0xa4506ceb, 0xde82bde9, 0xbef9a3f7, 0xb2c67915, 0xc67178f2, 0xe372532b, 0xca273ece, 0xea26619c, 0xd186b8c7, 0x21c0c207, 0xeada7dd6, 0xcde0eb1e, 0xf57d4f7f, 0xee6ed178, 0x06f067aa, 0x72176fba, 0x0a637dc5, 0xa2c898a6, 0x113f9804, 0xbef90dae, 0x1b710b35, 0x131c471b, 0x28db77f5, 0x23047d84, 0x32caab7b, 0x40c72493, 0x3c9ebe0a, 0x15c9bebc, 0x431d67c4, 0x9c100d4c, 0x4cc5d4be, 0xcb3e42b6, 0x597f299c, 0xfc657e2a, 0x5fcb6fab, 0x3ad6faec, 0x6c44198c, 0x4a475817];\n\nfunction SHA512() {\n  if (!(this instanceof SHA512)) return new SHA512();\n\n  BlockHash.call(this);\n  this.h = [0x6a09e667, 0xf3bcc908, 0xbb67ae85, 0x84caa73b, 0x3c6ef372, 0xfe94f82b, 0xa54ff53a, 0x5f1d36f1, 0x510e527f, 0xade682d1, 0x9b05688c, 0x2b3e6c1f, 0x1f83d9ab, 0xfb41bd6b, 0x5be0cd19, 0x137e2179];\n  this.k = sha512_K;\n  this.W = new Array(160);\n}\nutils.inherits(SHA512, BlockHash);\nmodule.exports = SHA512;\n\nSHA512.blockSize = 1024;\nSHA512.outSize = 512;\nSHA512.hmacStrength = 192;\nSHA512.padLength = 128;\n\nSHA512.prototype._prepareBlock = function _prepareBlock(msg, start) {\n  var W = this.W;\n\n  // 32 x 32bit words\n  for (var i = 0; i < 32; i++) {\n    W[i] = msg[start + i];\n  }for (; i < W.length; i += 2) {\n    var c0_hi = g1_512_hi(W[i - 4], W[i - 3]); // i - 2\n    var c0_lo = g1_512_lo(W[i - 4], W[i - 3]);\n    var c1_hi = W[i - 14]; // i - 7\n    var c1_lo = W[i - 13];\n    var c2_hi = g0_512_hi(W[i - 30], W[i - 29]); // i - 15\n    var c2_lo = g0_512_lo(W[i - 30], W[i - 29]);\n    var c3_hi = W[i - 32]; // i - 16\n    var c3_lo = W[i - 31];\n\n    W[i] = sum64_4_hi(c0_hi, c0_lo, c1_hi, c1_lo, c2_hi, c2_lo, c3_hi, c3_lo);\n    W[i + 1] = sum64_4_lo(c0_hi, c0_lo, c1_hi, c1_lo, c2_hi, c2_lo, c3_hi, c3_lo);\n  }\n};\n\nSHA512.prototype._update = function _update(msg, start) {\n  this._prepareBlock(msg, start);\n\n  var W = this.W;\n\n  var ah = this.h[0];\n  var al = this.h[1];\n  var bh = this.h[2];\n  var bl = this.h[3];\n  var ch = this.h[4];\n  var cl = this.h[5];\n  var dh = this.h[6];\n  var dl = this.h[7];\n  var eh = this.h[8];\n  var el = this.h[9];\n  var fh = this.h[10];\n  var fl = this.h[11];\n  var gh = this.h[12];\n  var gl = this.h[13];\n  var hh = this.h[14];\n  var hl = this.h[15];\n\n  assert(this.k.length === W.length);\n  for (var i = 0; i < W.length; i += 2) {\n    var c0_hi = hh;\n    var c0_lo = hl;\n    var c1_hi = s1_512_hi(eh, el);\n    var c1_lo = s1_512_lo(eh, el);\n    var c2_hi = ch64_hi(eh, el, fh, fl, gh, gl);\n    var c2_lo = ch64_lo(eh, el, fh, fl, gh, gl);\n    var c3_hi = this.k[i];\n    var c3_lo = this.k[i + 1];\n    var c4_hi = W[i];\n    var c4_lo = W[i + 1];\n\n    var T1_hi = sum64_5_hi(c0_hi, c0_lo, c1_hi, c1_lo, c2_hi, c2_lo, c3_hi, c3_lo, c4_hi, c4_lo);\n    var T1_lo = sum64_5_lo(c0_hi, c0_lo, c1_hi, c1_lo, c2_hi, c2_lo, c3_hi, c3_lo, c4_hi, c4_lo);\n\n    c0_hi = s0_512_hi(ah, al);\n    c0_lo = s0_512_lo(ah, al);\n    c1_hi = maj64_hi(ah, al, bh, bl, ch, cl);\n    c1_lo = maj64_lo(ah, al, bh, bl, ch, cl);\n\n    var T2_hi = sum64_hi(c0_hi, c0_lo, c1_hi, c1_lo);\n    var T2_lo = sum64_lo(c0_hi, c0_lo, c1_hi, c1_lo);\n\n    hh = gh;\n    hl = gl;\n\n    gh = fh;\n    gl = fl;\n\n    fh = eh;\n    fl = el;\n\n    eh = sum64_hi(dh, dl, T1_hi, T1_lo);\n    el = sum64_lo(dl, dl, T1_hi, T1_lo);\n\n    dh = ch;\n    dl = cl;\n\n    ch = bh;\n    cl = bl;\n\n    bh = ah;\n    bl = al;\n\n    ah = sum64_hi(T1_hi, T1_lo, T2_hi, T2_lo);\n    al = sum64_lo(T1_hi, T1_lo, T2_hi, T2_lo);\n  }\n\n  sum64(this.h, 0, ah, al);\n  sum64(this.h, 2, bh, bl);\n  sum64(this.h, 4, ch, cl);\n  sum64(this.h, 6, dh, dl);\n  sum64(this.h, 8, eh, el);\n  sum64(this.h, 10, fh, fl);\n  sum64(this.h, 12, gh, gl);\n  sum64(this.h, 14, hh, hl);\n};\n\nSHA512.prototype._digest = function digest(enc) {\n  if (enc === 'hex') return utils.toHex32(this.h, 'big');else return utils.split32(this.h, 'big');\n};\n\nfunction ch64_hi(xh, xl, yh, yl, zh) {\n  var r = xh & yh ^ ~xh & zh;\n  if (r < 0) r += 0x100000000;\n  return r;\n}\n\nfunction ch64_lo(xh, xl, yh, yl, zh, zl) {\n  var r = xl & yl ^ ~xl & zl;\n  if (r < 0) r += 0x100000000;\n  return r;\n}\n\nfunction maj64_hi(xh, xl, yh, yl, zh) {\n  var r = xh & yh ^ xh & zh ^ yh & zh;\n  if (r < 0) r += 0x100000000;\n  return r;\n}\n\nfunction maj64_lo(xh, xl, yh, yl, zh, zl) {\n  var r = xl & yl ^ xl & zl ^ yl & zl;\n  if (r < 0) r += 0x100000000;\n  return r;\n}\n\nfunction s0_512_hi(xh, xl) {\n  var c0_hi = rotr64_hi(xh, xl, 28);\n  var c1_hi = rotr64_hi(xl, xh, 2); // 34\n  var c2_hi = rotr64_hi(xl, xh, 7); // 39\n\n  var r = c0_hi ^ c1_hi ^ c2_hi;\n  if (r < 0) r += 0x100000000;\n  return r;\n}\n\nfunction s0_512_lo(xh, xl) {\n  var c0_lo = rotr64_lo(xh, xl, 28);\n  var c1_lo = rotr64_lo(xl, xh, 2); // 34\n  var c2_lo = rotr64_lo(xl, xh, 7); // 39\n\n  var r = c0_lo ^ c1_lo ^ c2_lo;\n  if (r < 0) r += 0x100000000;\n  return r;\n}\n\nfunction s1_512_hi(xh, xl) {\n  var c0_hi = rotr64_hi(xh, xl, 14);\n  var c1_hi = rotr64_hi(xh, xl, 18);\n  var c2_hi = rotr64_hi(xl, xh, 9); // 41\n\n  var r = c0_hi ^ c1_hi ^ c2_hi;\n  if (r < 0) r += 0x100000000;\n  return r;\n}\n\nfunction s1_512_lo(xh, xl) {\n  var c0_lo = rotr64_lo(xh, xl, 14);\n  var c1_lo = rotr64_lo(xh, xl, 18);\n  var c2_lo = rotr64_lo(xl, xh, 9); // 41\n\n  var r = c0_lo ^ c1_lo ^ c2_lo;\n  if (r < 0) r += 0x100000000;\n  return r;\n}\n\nfunction g0_512_hi(xh, xl) {\n  var c0_hi = rotr64_hi(xh, xl, 1);\n  var c1_hi = rotr64_hi(xh, xl, 8);\n  var c2_hi = shr64_hi(xh, xl, 7);\n\n  var r = c0_hi ^ c1_hi ^ c2_hi;\n  if (r < 0) r += 0x100000000;\n  return r;\n}\n\nfunction g0_512_lo(xh, xl) {\n  var c0_lo = rotr64_lo(xh, xl, 1);\n  var c1_lo = rotr64_lo(xh, xl, 8);\n  var c2_lo = shr64_lo(xh, xl, 7);\n\n  var r = c0_lo ^ c1_lo ^ c2_lo;\n  if (r < 0) r += 0x100000000;\n  return r;\n}\n\nfunction g1_512_hi(xh, xl) {\n  var c0_hi = rotr64_hi(xh, xl, 19);\n  var c1_hi = rotr64_hi(xl, xh, 29); // 61\n  var c2_hi = shr64_hi(xh, xl, 6);\n\n  var r = c0_hi ^ c1_hi ^ c2_hi;\n  if (r < 0) r += 0x100000000;\n  return r;\n}\n\nfunction g1_512_lo(xh, xl) {\n  var c0_lo = rotr64_lo(xh, xl, 19);\n  var c1_lo = rotr64_lo(xl, xh, 29); // 61\n  var c2_lo = shr64_lo(xh, xl, 6);\n\n  var r = c0_lo ^ c1_lo ^ c2_lo;\n  if (r < 0) r += 0x100000000;\n  return r;\n}\n\n/***/ }),\n/* 26 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/* WEBPACK VAR INJECTION */(function(global) {\n\n// compare and isBuffer taken from https://github.com/feross/buffer/blob/680e9e5e488f22aac27599a57dc844a6315928dd/index.js\n// original notice:\n\n/*!\n * The buffer module from node.js, for the browser.\n *\n * @author   Feross Aboukhadijeh <feross@feross.org> <http://feross.org>\n * @license  MIT\n */\n\nvar _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; };\n\nfunction compare(a, b) {\n  if (a === b) {\n    return 0;\n  }\n\n  var x = a.length;\n  var y = b.length;\n\n  for (var i = 0, len = Math.min(x, y); i < len; ++i) {\n    if (a[i] !== b[i]) {\n      x = a[i];\n      y = b[i];\n      break;\n    }\n  }\n\n  if (x < y) {\n    return -1;\n  }\n  if (y < x) {\n    return 1;\n  }\n  return 0;\n}\nfunction isBuffer(b) {\n  if (global.Buffer && typeof global.Buffer.isBuffer === 'function') {\n    return global.Buffer.isBuffer(b);\n  }\n  return !!(b != null && b._isBuffer);\n}\n\n// based on node assert, original notice:\n\n// http://wiki.commonjs.org/wiki/Unit_Testing/1.0\n//\n// THIS IS NOT TESTED NOR LIKELY TO WORK OUTSIDE V8!\n//\n// Originally from narwhal.js (http://narwhaljs.org)\n// Copyright (c) 2009 Thomas Robinson <280north.com>\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the 'Software'), to\n// deal in the Software without restriction, including without limitation the\n// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or\n// sell copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN\n// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION\n// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nvar util = __webpack_require__(16);\nvar hasOwn = Object.prototype.hasOwnProperty;\nvar pSlice = Array.prototype.slice;\nvar functionsHaveNames = function () {\n  return function foo() {}.name === 'foo';\n}();\nfunction pToString(obj) {\n  return Object.prototype.toString.call(obj);\n}\nfunction isView(arrbuf) {\n  if (isBuffer(arrbuf)) {\n    return false;\n  }\n  if (typeof global.ArrayBuffer !== 'function') {\n    return false;\n  }\n  if (typeof ArrayBuffer.isView === 'function') {\n    return ArrayBuffer.isView(arrbuf);\n  }\n  if (!arrbuf) {\n    return false;\n  }\n  if (arrbuf instanceof DataView) {\n    return true;\n  }\n  if (arrbuf.buffer && arrbuf.buffer instanceof ArrayBuffer) {\n    return true;\n  }\n  return false;\n}\n// 1. The assert module provides functions that throw\n// AssertionError's when particular conditions are not met. The\n// assert module must conform to the following interface.\n\nvar assert = module.exports = ok;\n\n// 2. The AssertionError is defined in assert.\n// new assert.AssertionError({ message: message,\n//                             actual: actual,\n//                             expected: expected })\n\nvar regex = /\\s*function\\s+([^\\(\\s]*)\\s*/;\n// based on https://github.com/ljharb/function.prototype.name/blob/adeeeec8bfcc6068b187d7d9fb3d5bb1d3a30899/implementation.js\nfunction getName(func) {\n  if (!util.isFunction(func)) {\n    return;\n  }\n  if (functionsHaveNames) {\n    return func.name;\n  }\n  var str = func.toString();\n  var match = str.match(regex);\n  return match && match[1];\n}\nassert.AssertionError = function AssertionError(options) {\n  this.name = 'AssertionError';\n  this.actual = options.actual;\n  this.expected = options.expected;\n  this.operator = options.operator;\n  if (options.message) {\n    this.message = options.message;\n    this.generatedMessage = false;\n  } else {\n    this.message = getMessage(this);\n    this.generatedMessage = true;\n  }\n  var stackStartFunction = options.stackStartFunction || fail;\n  if (Error.captureStackTrace) {\n    Error.captureStackTrace(this, stackStartFunction);\n  } else {\n    // non v8 browsers so we can have a stacktrace\n    var err = new Error();\n    if (err.stack) {\n      var out = err.stack;\n\n      // try to strip useless frames\n      var fn_name = getName(stackStartFunction);\n      var idx = out.indexOf('\\n' + fn_name);\n      if (idx >= 0) {\n        // once we have located the function frame\n        // we need to strip out everything before it (and its line)\n        var next_line = out.indexOf('\\n', idx + 1);\n        out = out.substring(next_line + 1);\n      }\n\n      this.stack = out;\n    }\n  }\n};\n\n// assert.AssertionError instanceof Error\nutil.inherits(assert.AssertionError, Error);\n\nfunction truncate(s, n) {\n  if (typeof s === 'string') {\n    return s.length < n ? s : s.slice(0, n);\n  } else {\n    return s;\n  }\n}\nfunction inspect(something) {\n  if (functionsHaveNames || !util.isFunction(something)) {\n    return util.inspect(something);\n  }\n  var rawname = getName(something);\n  var name = rawname ? ': ' + rawname : '';\n  return '[Function' + name + ']';\n}\nfunction getMessage(self) {\n  return truncate(inspect(self.actual), 128) + ' ' + self.operator + ' ' + truncate(inspect(self.expected), 128);\n}\n\n// At present only the three keys mentioned above are used and\n// understood by the spec. Implementations or sub modules can pass\n// other keys to the AssertionError's constructor - they will be\n// ignored.\n\n// 3. All of the following functions must throw an AssertionError\n// when a corresponding condition is not met, with a message that\n// may be undefined if not provided.  All assertion methods provide\n// both the actual and expected values to the assertion error for\n// display purposes.\n\nfunction fail(actual, expected, message, operator, stackStartFunction) {\n  throw new assert.AssertionError({\n    message: message,\n    actual: actual,\n    expected: expected,\n    operator: operator,\n    stackStartFunction: stackStartFunction\n  });\n}\n\n// EXTENSION! allows for well behaved errors defined elsewhere.\nassert.fail = fail;\n\n// 4. Pure assertion tests whether a value is truthy, as determined\n// by !!guard.\n// assert.ok(guard, message_opt);\n// This statement is equivalent to assert.equal(true, !!guard,\n// message_opt);. To test strictly for the value true, use\n// assert.strictEqual(true, guard, message_opt);.\n\nfunction ok(value, message) {\n  if (!value) fail(value, true, message, '==', assert.ok);\n}\nassert.ok = ok;\n\n// 5. The equality assertion tests shallow, coercive equality with\n// ==.\n// assert.equal(actual, expected, message_opt);\n\nassert.equal = function equal(actual, expected, message) {\n  if (actual != expected) fail(actual, expected, message, '==', assert.equal);\n};\n\n// 6. The non-equality assertion tests for whether two objects are not equal\n// with != assert.notEqual(actual, expected, message_opt);\n\nassert.notEqual = function notEqual(actual, expected, message) {\n  if (actual == expected) {\n    fail(actual, expected, message, '!=', assert.notEqual);\n  }\n};\n\n// 7. The equivalence assertion tests a deep equality relation.\n// assert.deepEqual(actual, expected, message_opt);\n\nassert.deepEqual = function deepEqual(actual, expected, message) {\n  if (!_deepEqual(actual, expected, false)) {\n    fail(actual, expected, message, 'deepEqual', assert.deepEqual);\n  }\n};\n\nassert.deepStrictEqual = function deepStrictEqual(actual, expected, message) {\n  if (!_deepEqual(actual, expected, true)) {\n    fail(actual, expected, message, 'deepStrictEqual', assert.deepStrictEqual);\n  }\n};\n\nfunction _deepEqual(actual, expected, strict, memos) {\n  // 7.1. All identical values are equivalent, as determined by ===.\n  if (actual === expected) {\n    return true;\n  } else if (isBuffer(actual) && isBuffer(expected)) {\n    return compare(actual, expected) === 0;\n\n    // 7.2. If the expected value is a Date object, the actual value is\n    // equivalent if it is also a Date object that refers to the same time.\n  } else if (util.isDate(actual) && util.isDate(expected)) {\n    return actual.getTime() === expected.getTime();\n\n    // 7.3 If the expected value is a RegExp object, the actual value is\n    // equivalent if it is also a RegExp object with the same source and\n    // properties (`global`, `multiline`, `lastIndex`, `ignoreCase`).\n  } else if (util.isRegExp(actual) && util.isRegExp(expected)) {\n    return actual.source === expected.source && actual.global === expected.global && actual.multiline === expected.multiline && actual.lastIndex === expected.lastIndex && actual.ignoreCase === expected.ignoreCase;\n\n    // 7.4. Other pairs that do not both pass typeof value == 'object',\n    // equivalence is determined by ==.\n  } else if ((actual === null || (typeof actual === 'undefined' ? 'undefined' : _typeof(actual)) !== 'object') && (expected === null || (typeof expected === 'undefined' ? 'undefined' : _typeof(expected)) !== 'object')) {\n    return strict ? actual === expected : actual == expected;\n\n    // If both values are instances of typed arrays, wrap their underlying\n    // ArrayBuffers in a Buffer each to increase performance\n    // This optimization requires the arrays to have the same type as checked by\n    // Object.prototype.toString (aka pToString). Never perform binary\n    // comparisons for Float*Arrays, though, since e.g. +0 === -0 but their\n    // bit patterns are not identical.\n  } else if (isView(actual) && isView(expected) && pToString(actual) === pToString(expected) && !(actual instanceof Float32Array || actual instanceof Float64Array)) {\n    return compare(new Uint8Array(actual.buffer), new Uint8Array(expected.buffer)) === 0;\n\n    // 7.5 For all other Object pairs, including Array objects, equivalence is\n    // determined by having the same number of owned properties (as verified\n    // with Object.prototype.hasOwnProperty.call), the same set of keys\n    // (although not necessarily the same order), equivalent values for every\n    // corresponding key, and an identical 'prototype' property. Note: this\n    // accounts for both named and indexed properties on Arrays.\n  } else if (isBuffer(actual) !== isBuffer(expected)) {\n    return false;\n  } else {\n    memos = memos || { actual: [], expected: [] };\n\n    var actualIndex = memos.actual.indexOf(actual);\n    if (actualIndex !== -1) {\n      if (actualIndex === memos.expected.indexOf(expected)) {\n        return true;\n      }\n    }\n\n    memos.actual.push(actual);\n    memos.expected.push(expected);\n\n    return objEquiv(actual, expected, strict, memos);\n  }\n}\n\nfunction isArguments(object) {\n  return Object.prototype.toString.call(object) == '[object Arguments]';\n}\n\nfunction objEquiv(a, b, strict, actualVisitedObjects) {\n  if (a === null || a === undefined || b === null || b === undefined) return false;\n  // if one is a primitive, the other must be same\n  if (util.isPrimitive(a) || util.isPrimitive(b)) return a === b;\n  if (strict && Object.getPrototypeOf(a) !== Object.getPrototypeOf(b)) return false;\n  var aIsArgs = isArguments(a);\n  var bIsArgs = isArguments(b);\n  if (aIsArgs && !bIsArgs || !aIsArgs && bIsArgs) return false;\n  if (aIsArgs) {\n    a = pSlice.call(a);\n    b = pSlice.call(b);\n    return _deepEqual(a, b, strict);\n  }\n  var ka = objectKeys(a);\n  var kb = objectKeys(b);\n  var key, i;\n  // having the same number of owned properties (keys incorporates\n  // hasOwnProperty)\n  if (ka.length !== kb.length) return false;\n  //the same set of keys (although not necessarily the same order),\n  ka.sort();\n  kb.sort();\n  //~~~cheap key test\n  for (i = ka.length - 1; i >= 0; i--) {\n    if (ka[i] !== kb[i]) return false;\n  }\n  //equivalent values for every corresponding key, and\n  //~~~possibly expensive deep test\n  for (i = ka.length - 1; i >= 0; i--) {\n    key = ka[i];\n    if (!_deepEqual(a[key], b[key], strict, actualVisitedObjects)) return false;\n  }\n  return true;\n}\n\n// 8. The non-equivalence assertion tests for any deep inequality.\n// assert.notDeepEqual(actual, expected, message_opt);\n\nassert.notDeepEqual = function notDeepEqual(actual, expected, message) {\n  if (_deepEqual(actual, expected, false)) {\n    fail(actual, expected, message, 'notDeepEqual', assert.notDeepEqual);\n  }\n};\n\nassert.notDeepStrictEqual = notDeepStrictEqual;\nfunction notDeepStrictEqual(actual, expected, message) {\n  if (_deepEqual(actual, expected, true)) {\n    fail(actual, expected, message, 'notDeepStrictEqual', notDeepStrictEqual);\n  }\n}\n\n// 9. The strict equality assertion tests strict equality, as determined by ===.\n// assert.strictEqual(actual, expected, message_opt);\n\nassert.strictEqual = function strictEqual(actual, expected, message) {\n  if (actual !== expected) {\n    fail(actual, expected, message, '===', assert.strictEqual);\n  }\n};\n\n// 10. The strict non-equality assertion tests for strict inequality, as\n// determined by !==.  assert.notStrictEqual(actual, expected, message_opt);\n\nassert.notStrictEqual = function notStrictEqual(actual, expected, message) {\n  if (actual === expected) {\n    fail(actual, expected, message, '!==', assert.notStrictEqual);\n  }\n};\n\nfunction expectedException(actual, expected) {\n  if (!actual || !expected) {\n    return false;\n  }\n\n  if (Object.prototype.toString.call(expected) == '[object RegExp]') {\n    return expected.test(actual);\n  }\n\n  try {\n    if (actual instanceof expected) {\n      return true;\n    }\n  } catch (e) {\n    // Ignore.  The instanceof check doesn't work for arrow functions.\n  }\n\n  if (Error.isPrototypeOf(expected)) {\n    return false;\n  }\n\n  return expected.call({}, actual) === true;\n}\n\nfunction _tryBlock(block) {\n  var error;\n  try {\n    block();\n  } catch (e) {\n    error = e;\n  }\n  return error;\n}\n\nfunction _throws(shouldThrow, block, expected, message) {\n  var actual;\n\n  if (typeof block !== 'function') {\n    throw new TypeError('\"block\" argument must be a function');\n  }\n\n  if (typeof expected === 'string') {\n    message = expected;\n    expected = null;\n  }\n\n  actual = _tryBlock(block);\n\n  message = (expected && expected.name ? ' (' + expected.name + ').' : '.') + (message ? ' ' + message : '.');\n\n  if (shouldThrow && !actual) {\n    fail(actual, expected, 'Missing expected exception' + message);\n  }\n\n  var userProvidedMessage = typeof message === 'string';\n  var isUnwantedException = !shouldThrow && util.isError(actual);\n  var isUnexpectedException = !shouldThrow && actual && !expected;\n\n  if (isUnwantedException && userProvidedMessage && expectedException(actual, expected) || isUnexpectedException) {\n    fail(actual, expected, 'Got unwanted exception' + message);\n  }\n\n  if (shouldThrow && actual && expected && !expectedException(actual, expected) || !shouldThrow && actual) {\n    throw actual;\n  }\n}\n\n// 11. Expected to throw an error:\n// assert.throws(block, Error_opt, message_opt);\n\nassert.throws = function (block, /*optional*/error, /*optional*/message) {\n  _throws(true, block, error, message);\n};\n\n// EXTENSION! This is annoying to write outside this module.\nassert.doesNotThrow = function (block, /*optional*/error, /*optional*/message) {\n  _throws(false, block, error, message);\n};\n\nassert.ifError = function (err) {\n  if (err) throw err;\n};\n\nvar objectKeys = Object.keys || function (obj) {\n  var keys = [];\n  for (var key in obj) {\n    if (hasOwn.call(obj, key)) keys.push(key);\n  }\n  return keys;\n};\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(5)))\n\n/***/ }),\n/* 27 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\n// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nmodule.exports = Stream;\n\nvar EE = __webpack_require__(18).EventEmitter;\nvar inherits = __webpack_require__(3);\n\ninherits(Stream, EE);\nStream.Readable = __webpack_require__(19);\nStream.Writable = __webpack_require__(74);\nStream.Duplex = __webpack_require__(75);\nStream.Transform = __webpack_require__(76);\nStream.PassThrough = __webpack_require__(77);\n\n// Backwards-compat with node 0.4.x\nStream.Stream = Stream;\n\n// old-style streams.  Note that the pipe method (the only relevant\n// part of this class) is overridden in the Readable class.\n\nfunction Stream() {\n  EE.call(this);\n}\n\nStream.prototype.pipe = function (dest, options) {\n  var source = this;\n\n  function ondata(chunk) {\n    if (dest.writable) {\n      if (false === dest.write(chunk) && source.pause) {\n        source.pause();\n      }\n    }\n  }\n\n  source.on('data', ondata);\n\n  function ondrain() {\n    if (source.readable && source.resume) {\n      source.resume();\n    }\n  }\n\n  dest.on('drain', ondrain);\n\n  // If the 'end' option is not supplied, dest.end() will be called when\n  // source gets the 'end' or 'close' events.  Only dest.end() once.\n  if (!dest._isStdio && (!options || options.end !== false)) {\n    source.on('end', onend);\n    source.on('close', onclose);\n  }\n\n  var didOnEnd = false;\n  function onend() {\n    if (didOnEnd) return;\n    didOnEnd = true;\n\n    dest.end();\n  }\n\n  function onclose() {\n    if (didOnEnd) return;\n    didOnEnd = true;\n\n    if (typeof dest.destroy === 'function') dest.destroy();\n  }\n\n  // don't leave dangling pipes when there are errors.\n  function onerror(er) {\n    cleanup();\n    if (EE.listenerCount(this, 'error') === 0) {\n      throw er; // Unhandled stream error in pipe.\n    }\n  }\n\n  source.on('error', onerror);\n  dest.on('error', onerror);\n\n  // remove all the event listeners that were added.\n  function cleanup() {\n    source.removeListener('data', ondata);\n    dest.removeListener('drain', ondrain);\n\n    source.removeListener('end', onend);\n    source.removeListener('close', onclose);\n\n    source.removeListener('error', onerror);\n    dest.removeListener('error', onerror);\n\n    source.removeListener('end', cleanup);\n    source.removeListener('close', cleanup);\n\n    dest.removeListener('close', cleanup);\n  }\n\n  source.on('end', cleanup);\n  source.on('close', cleanup);\n\n  dest.on('close', cleanup);\n\n  dest.emit('pipe', source);\n\n  // Allow for unix-like usage: A.pipe(B).pipe(C)\n  return dest;\n};\n\n/***/ }),\n/* 28 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/* WEBPACK VAR INJECTION */(function(global, process) {// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n\n\n/*<replacement>*/\n\nvar processNextTick = __webpack_require__(13);\n/*</replacement>*/\n\nmodule.exports = Readable;\n\n/*<replacement>*/\nvar isArray = __webpack_require__(21);\n/*</replacement>*/\n\n/*<replacement>*/\nvar Duplex;\n/*</replacement>*/\n\nReadable.ReadableState = ReadableState;\n\n/*<replacement>*/\nvar EE = __webpack_require__(18).EventEmitter;\n\nvar EElistenerCount = function EElistenerCount(emitter, type) {\n  return emitter.listeners(type).length;\n};\n/*</replacement>*/\n\n/*<replacement>*/\nvar Stream = __webpack_require__(29);\n/*</replacement>*/\n\n// TODO(bmeurer): Change this back to const once hole checks are\n// properly optimized away early in Ignition+TurboFan.\n/*<replacement>*/\nvar Buffer = __webpack_require__(14).Buffer;\nvar OurUint8Array = global.Uint8Array || function () {};\nfunction _uint8ArrayToBuffer(chunk) {\n  return Buffer.from(chunk);\n}\nfunction _isUint8Array(obj) {\n  return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;\n}\n/*</replacement>*/\n\n/*<replacement>*/\nvar util = __webpack_require__(10);\nutil.inherits = __webpack_require__(3);\n/*</replacement>*/\n\n/*<replacement>*/\nvar debugUtil = __webpack_require__(68);\nvar debug = void 0;\nif (debugUtil && debugUtil.debuglog) {\n  debug = debugUtil.debuglog('stream');\n} else {\n  debug = function debug() {};\n}\n/*</replacement>*/\n\nvar BufferList = __webpack_require__(69);\nvar destroyImpl = __webpack_require__(30);\nvar StringDecoder;\n\nutil.inherits(Readable, Stream);\n\nvar kProxyEvents = ['error', 'close', 'destroy', 'pause', 'resume'];\n\nfunction prependListener(emitter, event, fn) {\n  // Sadly this is not cacheable as some libraries bundle their own\n  // event emitter implementation with them.\n  if (typeof emitter.prependListener === 'function') {\n    return emitter.prependListener(event, fn);\n  } else {\n    // This is a hack to make sure that our error handler is attached before any\n    // userland ones.  NEVER DO THIS. This is here only because this code needs\n    // to continue to work with older versions of Node.js that do not include\n    // the prependListener() method. The goal is to eventually remove this hack.\n    if (!emitter._events || !emitter._events[event]) emitter.on(event, fn);else if (isArray(emitter._events[event])) emitter._events[event].unshift(fn);else emitter._events[event] = [fn, emitter._events[event]];\n  }\n}\n\nfunction ReadableState(options, stream) {\n  Duplex = Duplex || __webpack_require__(7);\n\n  options = options || {};\n\n  // object stream flag. Used to make read(n) ignore n and to\n  // make all the buffer merging and length checks go away\n  this.objectMode = !!options.objectMode;\n\n  if (stream instanceof Duplex) this.objectMode = this.objectMode || !!options.readableObjectMode;\n\n  // the point at which it stops calling _read() to fill the buffer\n  // Note: 0 is a valid value, means \"don't call _read preemptively ever\"\n  var hwm = options.highWaterMark;\n  var defaultHwm = this.objectMode ? 16 : 16 * 1024;\n  this.highWaterMark = hwm || hwm === 0 ? hwm : defaultHwm;\n\n  // cast to ints.\n  this.highWaterMark = Math.floor(this.highWaterMark);\n\n  // A linked list is used to store data chunks instead of an array because the\n  // linked list can remove elements from the beginning faster than\n  // array.shift()\n  this.buffer = new BufferList();\n  this.length = 0;\n  this.pipes = null;\n  this.pipesCount = 0;\n  this.flowing = null;\n  this.ended = false;\n  this.endEmitted = false;\n  this.reading = false;\n\n  // a flag to be able to tell if the event 'readable'/'data' is emitted\n  // immediately, or on a later tick.  We set this to true at first, because\n  // any actions that shouldn't happen until \"later\" should generally also\n  // not happen before the first read call.\n  this.sync = true;\n\n  // whenever we return null, then we set a flag to say\n  // that we're awaiting a 'readable' event emission.\n  this.needReadable = false;\n  this.emittedReadable = false;\n  this.readableListening = false;\n  this.resumeScheduled = false;\n\n  // has it been destroyed\n  this.destroyed = false;\n\n  // Crypto is kind of old and crusty.  Historically, its default string\n  // encoding is 'binary' so we have to make this configurable.\n  // Everything else in the universe uses 'utf8', though.\n  this.defaultEncoding = options.defaultEncoding || 'utf8';\n\n  // the number of writers that are awaiting a drain event in .pipe()s\n  this.awaitDrain = 0;\n\n  // if true, a maybeReadMore has been scheduled\n  this.readingMore = false;\n\n  this.decoder = null;\n  this.encoding = null;\n  if (options.encoding) {\n    if (!StringDecoder) StringDecoder = __webpack_require__(31).StringDecoder;\n    this.decoder = new StringDecoder(options.encoding);\n    this.encoding = options.encoding;\n  }\n}\n\nfunction Readable(options) {\n  Duplex = Duplex || __webpack_require__(7);\n\n  if (!(this instanceof Readable)) return new Readable(options);\n\n  this._readableState = new ReadableState(options, this);\n\n  // legacy\n  this.readable = true;\n\n  if (options) {\n    if (typeof options.read === 'function') this._read = options.read;\n\n    if (typeof options.destroy === 'function') this._destroy = options.destroy;\n  }\n\n  Stream.call(this);\n}\n\nObject.defineProperty(Readable.prototype, 'destroyed', {\n  get: function get() {\n    if (this._readableState === undefined) {\n      return false;\n    }\n    return this._readableState.destroyed;\n  },\n  set: function set(value) {\n    // we ignore the value if the stream\n    // has not been initialized yet\n    if (!this._readableState) {\n      return;\n    }\n\n    // backward compatibility, the user is explicitly\n    // managing destroyed\n    this._readableState.destroyed = value;\n  }\n});\n\nReadable.prototype.destroy = destroyImpl.destroy;\nReadable.prototype._undestroy = destroyImpl.undestroy;\nReadable.prototype._destroy = function (err, cb) {\n  this.push(null);\n  cb(err);\n};\n\n// Manually shove something into the read() buffer.\n// This returns true if the highWaterMark has not been hit yet,\n// similar to how Writable.write() returns true if you should\n// write() some more.\nReadable.prototype.push = function (chunk, encoding) {\n  var state = this._readableState;\n  var skipChunkCheck;\n\n  if (!state.objectMode) {\n    if (typeof chunk === 'string') {\n      encoding = encoding || state.defaultEncoding;\n      if (encoding !== state.encoding) {\n        chunk = Buffer.from(chunk, encoding);\n        encoding = '';\n      }\n      skipChunkCheck = true;\n    }\n  } else {\n    skipChunkCheck = true;\n  }\n\n  return readableAddChunk(this, chunk, encoding, false, skipChunkCheck);\n};\n\n// Unshift should *always* be something directly out of read()\nReadable.prototype.unshift = function (chunk) {\n  return readableAddChunk(this, chunk, null, true, false);\n};\n\nfunction readableAddChunk(stream, chunk, encoding, addToFront, skipChunkCheck) {\n  var state = stream._readableState;\n  if (chunk === null) {\n    state.reading = false;\n    onEofChunk(stream, state);\n  } else {\n    var er;\n    if (!skipChunkCheck) er = chunkInvalid(state, chunk);\n    if (er) {\n      stream.emit('error', er);\n    } else if (state.objectMode || chunk && chunk.length > 0) {\n      if (typeof chunk !== 'string' && !state.objectMode && Object.getPrototypeOf(chunk) !== Buffer.prototype) {\n        chunk = _uint8ArrayToBuffer(chunk);\n      }\n\n      if (addToFront) {\n        if (state.endEmitted) stream.emit('error', new Error('stream.unshift() after end event'));else addChunk(stream, state, chunk, true);\n      } else if (state.ended) {\n        stream.emit('error', new Error('stream.push() after EOF'));\n      } else {\n        state.reading = false;\n        if (state.decoder && !encoding) {\n          chunk = state.decoder.write(chunk);\n          if (state.objectMode || chunk.length !== 0) addChunk(stream, state, chunk, false);else maybeReadMore(stream, state);\n        } else {\n          addChunk(stream, state, chunk, false);\n        }\n      }\n    } else if (!addToFront) {\n      state.reading = false;\n    }\n  }\n\n  return needMoreData(state);\n}\n\nfunction addChunk(stream, state, chunk, addToFront) {\n  if (state.flowing && state.length === 0 && !state.sync) {\n    stream.emit('data', chunk);\n    stream.read(0);\n  } else {\n    // update the buffer info.\n    state.length += state.objectMode ? 1 : chunk.length;\n    if (addToFront) state.buffer.unshift(chunk);else state.buffer.push(chunk);\n\n    if (state.needReadable) emitReadable(stream);\n  }\n  maybeReadMore(stream, state);\n}\n\nfunction chunkInvalid(state, chunk) {\n  var er;\n  if (!_isUint8Array(chunk) && typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) {\n    er = new TypeError('Invalid non-string/buffer chunk');\n  }\n  return er;\n}\n\n// if it's past the high water mark, we can push in some more.\n// Also, if we have no data yet, we can stand some\n// more bytes.  This is to work around cases where hwm=0,\n// such as the repl.  Also, if the push() triggered a\n// readable event, and the user called read(largeNumber) such that\n// needReadable was set, then we ought to push more, so that another\n// 'readable' event will be triggered.\nfunction needMoreData(state) {\n  return !state.ended && (state.needReadable || state.length < state.highWaterMark || state.length === 0);\n}\n\nReadable.prototype.isPaused = function () {\n  return this._readableState.flowing === false;\n};\n\n// backwards compatibility.\nReadable.prototype.setEncoding = function (enc) {\n  if (!StringDecoder) StringDecoder = __webpack_require__(31).StringDecoder;\n  this._readableState.decoder = new StringDecoder(enc);\n  this._readableState.encoding = enc;\n  return this;\n};\n\n// Don't raise the hwm > 8MB\nvar MAX_HWM = 0x800000;\nfunction computeNewHighWaterMark(n) {\n  if (n >= MAX_HWM) {\n    n = MAX_HWM;\n  } else {\n    // Get the next highest power of 2 to prevent increasing hwm excessively in\n    // tiny amounts\n    n--;\n    n |= n >>> 1;\n    n |= n >>> 2;\n    n |= n >>> 4;\n    n |= n >>> 8;\n    n |= n >>> 16;\n    n++;\n  }\n  return n;\n}\n\n// This function is designed to be inlinable, so please take care when making\n// changes to the function body.\nfunction howMuchToRead(n, state) {\n  if (n <= 0 || state.length === 0 && state.ended) return 0;\n  if (state.objectMode) return 1;\n  if (n !== n) {\n    // Only flow one buffer at a time\n    if (state.flowing && state.length) return state.buffer.head.data.length;else return state.length;\n  }\n  // If we're asking for more than the current hwm, then raise the hwm.\n  if (n > state.highWaterMark) state.highWaterMark = computeNewHighWaterMark(n);\n  if (n <= state.length) return n;\n  // Don't have enough\n  if (!state.ended) {\n    state.needReadable = true;\n    return 0;\n  }\n  return state.length;\n}\n\n// you can override either this method, or the async _read(n) below.\nReadable.prototype.read = function (n) {\n  debug('read', n);\n  n = parseInt(n, 10);\n  var state = this._readableState;\n  var nOrig = n;\n\n  if (n !== 0) state.emittedReadable = false;\n\n  // if we're doing read(0) to trigger a readable event, but we\n  // already have a bunch of data in the buffer, then just trigger\n  // the 'readable' event and move on.\n  if (n === 0 && state.needReadable && (state.length >= state.highWaterMark || state.ended)) {\n    debug('read: emitReadable', state.length, state.ended);\n    if (state.length === 0 && state.ended) endReadable(this);else emitReadable(this);\n    return null;\n  }\n\n  n = howMuchToRead(n, state);\n\n  // if we've ended, and we're now clear, then finish it up.\n  if (n === 0 && state.ended) {\n    if (state.length === 0) endReadable(this);\n    return null;\n  }\n\n  // All the actual chunk generation logic needs to be\n  // *below* the call to _read.  The reason is that in certain\n  // synthetic stream cases, such as passthrough streams, _read\n  // may be a completely synchronous operation which may change\n  // the state of the read buffer, providing enough data when\n  // before there was *not* enough.\n  //\n  // So, the steps are:\n  // 1. Figure out what the state of things will be after we do\n  // a read from the buffer.\n  //\n  // 2. If that resulting state will trigger a _read, then call _read.\n  // Note that this may be asynchronous, or synchronous.  Yes, it is\n  // deeply ugly to write APIs this way, but that still doesn't mean\n  // that the Readable class should behave improperly, as streams are\n  // designed to be sync/async agnostic.\n  // Take note if the _read call is sync or async (ie, if the read call\n  // has returned yet), so that we know whether or not it's safe to emit\n  // 'readable' etc.\n  //\n  // 3. Actually pull the requested chunks out of the buffer and return.\n\n  // if we need a readable event, then we need to do some reading.\n  var doRead = state.needReadable;\n  debug('need readable', doRead);\n\n  // if we currently have less than the highWaterMark, then also read some\n  if (state.length === 0 || state.length - n < state.highWaterMark) {\n    doRead = true;\n    debug('length less than watermark', doRead);\n  }\n\n  // however, if we've ended, then there's no point, and if we're already\n  // reading, then it's unnecessary.\n  if (state.ended || state.reading) {\n    doRead = false;\n    debug('reading or ended', doRead);\n  } else if (doRead) {\n    debug('do read');\n    state.reading = true;\n    state.sync = true;\n    // if the length is currently zero, then we *need* a readable event.\n    if (state.length === 0) state.needReadable = true;\n    // call internal read method\n    this._read(state.highWaterMark);\n    state.sync = false;\n    // If _read pushed data synchronously, then `reading` will be false,\n    // and we need to re-evaluate how much data we can return to the user.\n    if (!state.reading) n = howMuchToRead(nOrig, state);\n  }\n\n  var ret;\n  if (n > 0) ret = fromList(n, state);else ret = null;\n\n  if (ret === null) {\n    state.needReadable = true;\n    n = 0;\n  } else {\n    state.length -= n;\n  }\n\n  if (state.length === 0) {\n    // If we have nothing in the buffer, then we want to know\n    // as soon as we *do* get something into the buffer.\n    if (!state.ended) state.needReadable = true;\n\n    // If we tried to read() past the EOF, then emit end on the next tick.\n    if (nOrig !== n && state.ended) endReadable(this);\n  }\n\n  if (ret !== null) this.emit('data', ret);\n\n  return ret;\n};\n\nfunction onEofChunk(stream, state) {\n  if (state.ended) return;\n  if (state.decoder) {\n    var chunk = state.decoder.end();\n    if (chunk && chunk.length) {\n      state.buffer.push(chunk);\n      state.length += state.objectMode ? 1 : chunk.length;\n    }\n  }\n  state.ended = true;\n\n  // emit 'readable' now to make sure it gets picked up.\n  emitReadable(stream);\n}\n\n// Don't emit readable right away in sync mode, because this can trigger\n// another read() call => stack overflow.  This way, it might trigger\n// a nextTick recursion warning, but that's not so bad.\nfunction emitReadable(stream) {\n  var state = stream._readableState;\n  state.needReadable = false;\n  if (!state.emittedReadable) {\n    debug('emitReadable', state.flowing);\n    state.emittedReadable = true;\n    if (state.sync) processNextTick(emitReadable_, stream);else emitReadable_(stream);\n  }\n}\n\nfunction emitReadable_(stream) {\n  debug('emit readable');\n  stream.emit('readable');\n  flow(stream);\n}\n\n// at this point, the user has presumably seen the 'readable' event,\n// and called read() to consume some data.  that may have triggered\n// in turn another _read(n) call, in which case reading = true if\n// it's in progress.\n// However, if we're not ended, or reading, and the length < hwm,\n// then go ahead and try to read some more preemptively.\nfunction maybeReadMore(stream, state) {\n  if (!state.readingMore) {\n    state.readingMore = true;\n    processNextTick(maybeReadMore_, stream, state);\n  }\n}\n\nfunction maybeReadMore_(stream, state) {\n  var len = state.length;\n  while (!state.reading && !state.flowing && !state.ended && state.length < state.highWaterMark) {\n    debug('maybeReadMore read 0');\n    stream.read(0);\n    if (len === state.length)\n      // didn't get any data, stop spinning.\n      break;else len = state.length;\n  }\n  state.readingMore = false;\n}\n\n// abstract method.  to be overridden in specific implementation classes.\n// call cb(er, data) where data is <= n in length.\n// for virtual (non-string, non-buffer) streams, \"length\" is somewhat\n// arbitrary, and perhaps not very meaningful.\nReadable.prototype._read = function (n) {\n  this.emit('error', new Error('_read() is not implemented'));\n};\n\nReadable.prototype.pipe = function (dest, pipeOpts) {\n  var src = this;\n  var state = this._readableState;\n\n  switch (state.pipesCount) {\n    case 0:\n      state.pipes = dest;\n      break;\n    case 1:\n      state.pipes = [state.pipes, dest];\n      break;\n    default:\n      state.pipes.push(dest);\n      break;\n  }\n  state.pipesCount += 1;\n  debug('pipe count=%d opts=%j', state.pipesCount, pipeOpts);\n\n  var doEnd = (!pipeOpts || pipeOpts.end !== false) && dest !== process.stdout && dest !== process.stderr;\n\n  var endFn = doEnd ? onend : unpipe;\n  if (state.endEmitted) processNextTick(endFn);else src.once('end', endFn);\n\n  dest.on('unpipe', onunpipe);\n  function onunpipe(readable, unpipeInfo) {\n    debug('onunpipe');\n    if (readable === src) {\n      if (unpipeInfo && unpipeInfo.hasUnpiped === false) {\n        unpipeInfo.hasUnpiped = true;\n        cleanup();\n      }\n    }\n  }\n\n  function onend() {\n    debug('onend');\n    dest.end();\n  }\n\n  // when the dest drains, it reduces the awaitDrain counter\n  // on the source.  This would be more elegant with a .once()\n  // handler in flow(), but adding and removing repeatedly is\n  // too slow.\n  var ondrain = pipeOnDrain(src);\n  dest.on('drain', ondrain);\n\n  var cleanedUp = false;\n  function cleanup() {\n    debug('cleanup');\n    // cleanup event handlers once the pipe is broken\n    dest.removeListener('close', onclose);\n    dest.removeListener('finish', onfinish);\n    dest.removeListener('drain', ondrain);\n    dest.removeListener('error', onerror);\n    dest.removeListener('unpipe', onunpipe);\n    src.removeListener('end', onend);\n    src.removeListener('end', unpipe);\n    src.removeListener('data', ondata);\n\n    cleanedUp = true;\n\n    // if the reader is waiting for a drain event from this\n    // specific writer, then it would cause it to never start\n    // flowing again.\n    // So, if this is awaiting a drain, then we just call it now.\n    // If we don't know, then assume that we are waiting for one.\n    if (state.awaitDrain && (!dest._writableState || dest._writableState.needDrain)) ondrain();\n  }\n\n  // If the user pushes more data while we're writing to dest then we'll end up\n  // in ondata again. However, we only want to increase awaitDrain once because\n  // dest will only emit one 'drain' event for the multiple writes.\n  // => Introduce a guard on increasing awaitDrain.\n  var increasedAwaitDrain = false;\n  src.on('data', ondata);\n  function ondata(chunk) {\n    debug('ondata');\n    increasedAwaitDrain = false;\n    var ret = dest.write(chunk);\n    if (false === ret && !increasedAwaitDrain) {\n      // If the user unpiped during `dest.write()`, it is possible\n      // to get stuck in a permanently paused state if that write\n      // also returned false.\n      // => Check whether `dest` is still a piping destination.\n      if ((state.pipesCount === 1 && state.pipes === dest || state.pipesCount > 1 && indexOf(state.pipes, dest) !== -1) && !cleanedUp) {\n        debug('false write response, pause', src._readableState.awaitDrain);\n        src._readableState.awaitDrain++;\n        increasedAwaitDrain = true;\n      }\n      src.pause();\n    }\n  }\n\n  // if the dest has an error, then stop piping into it.\n  // however, don't suppress the throwing behavior for this.\n  function onerror(er) {\n    debug('onerror', er);\n    unpipe();\n    dest.removeListener('error', onerror);\n    if (EElistenerCount(dest, 'error') === 0) dest.emit('error', er);\n  }\n\n  // Make sure our error handler is attached before userland ones.\n  prependListener(dest, 'error', onerror);\n\n  // Both close and finish should trigger unpipe, but only once.\n  function onclose() {\n    dest.removeListener('finish', onfinish);\n    unpipe();\n  }\n  dest.once('close', onclose);\n  function onfinish() {\n    debug('onfinish');\n    dest.removeListener('close', onclose);\n    unpipe();\n  }\n  dest.once('finish', onfinish);\n\n  function unpipe() {\n    debug('unpipe');\n    src.unpipe(dest);\n  }\n\n  // tell the dest that it's being piped to\n  dest.emit('pipe', src);\n\n  // start the flow if it hasn't been started already.\n  if (!state.flowing) {\n    debug('pipe resume');\n    src.resume();\n  }\n\n  return dest;\n};\n\nfunction pipeOnDrain(src) {\n  return function () {\n    var state = src._readableState;\n    debug('pipeOnDrain', state.awaitDrain);\n    if (state.awaitDrain) state.awaitDrain--;\n    if (state.awaitDrain === 0 && EElistenerCount(src, 'data')) {\n      state.flowing = true;\n      flow(src);\n    }\n  };\n}\n\nReadable.prototype.unpipe = function (dest) {\n  var state = this._readableState;\n  var unpipeInfo = { hasUnpiped: false };\n\n  // if we're not piping anywhere, then do nothing.\n  if (state.pipesCount === 0) return this;\n\n  // just one destination.  most common case.\n  if (state.pipesCount === 1) {\n    // passed in one, but it's not the right one.\n    if (dest && dest !== state.pipes) return this;\n\n    if (!dest) dest = state.pipes;\n\n    // got a match.\n    state.pipes = null;\n    state.pipesCount = 0;\n    state.flowing = false;\n    if (dest) dest.emit('unpipe', this, unpipeInfo);\n    return this;\n  }\n\n  // slow case. multiple pipe destinations.\n\n  if (!dest) {\n    // remove all.\n    var dests = state.pipes;\n    var len = state.pipesCount;\n    state.pipes = null;\n    state.pipesCount = 0;\n    state.flowing = false;\n\n    for (var i = 0; i < len; i++) {\n      dests[i].emit('unpipe', this, unpipeInfo);\n    }return this;\n  }\n\n  // try to find the right one.\n  var index = indexOf(state.pipes, dest);\n  if (index === -1) return this;\n\n  state.pipes.splice(index, 1);\n  state.pipesCount -= 1;\n  if (state.pipesCount === 1) state.pipes = state.pipes[0];\n\n  dest.emit('unpipe', this, unpipeInfo);\n\n  return this;\n};\n\n// set up data events if they are asked for\n// Ensure readable listeners eventually get something\nReadable.prototype.on = function (ev, fn) {\n  var res = Stream.prototype.on.call(this, ev, fn);\n\n  if (ev === 'data') {\n    // Start flowing on next tick if stream isn't explicitly paused\n    if (this._readableState.flowing !== false) this.resume();\n  } else if (ev === 'readable') {\n    var state = this._readableState;\n    if (!state.endEmitted && !state.readableListening) {\n      state.readableListening = state.needReadable = true;\n      state.emittedReadable = false;\n      if (!state.reading) {\n        processNextTick(nReadingNextTick, this);\n      } else if (state.length) {\n        emitReadable(this);\n      }\n    }\n  }\n\n  return res;\n};\nReadable.prototype.addListener = Readable.prototype.on;\n\nfunction nReadingNextTick(self) {\n  debug('readable nexttick read 0');\n  self.read(0);\n}\n\n// pause() and resume() are remnants of the legacy readable stream API\n// If the user uses them, then switch into old mode.\nReadable.prototype.resume = function () {\n  var state = this._readableState;\n  if (!state.flowing) {\n    debug('resume');\n    state.flowing = true;\n    resume(this, state);\n  }\n  return this;\n};\n\nfunction resume(stream, state) {\n  if (!state.resumeScheduled) {\n    state.resumeScheduled = true;\n    processNextTick(resume_, stream, state);\n  }\n}\n\nfunction resume_(stream, state) {\n  if (!state.reading) {\n    debug('resume read 0');\n    stream.read(0);\n  }\n\n  state.resumeScheduled = false;\n  state.awaitDrain = 0;\n  stream.emit('resume');\n  flow(stream);\n  if (state.flowing && !state.reading) stream.read(0);\n}\n\nReadable.prototype.pause = function () {\n  debug('call pause flowing=%j', this._readableState.flowing);\n  if (false !== this._readableState.flowing) {\n    debug('pause');\n    this._readableState.flowing = false;\n    this.emit('pause');\n  }\n  return this;\n};\n\nfunction flow(stream) {\n  var state = stream._readableState;\n  debug('flow', state.flowing);\n  while (state.flowing && stream.read() !== null) {}\n}\n\n// wrap an old-style stream as the async data source.\n// This is *not* part of the readable stream interface.\n// It is an ugly unfortunate mess of history.\nReadable.prototype.wrap = function (stream) {\n  var state = this._readableState;\n  var paused = false;\n\n  var self = this;\n  stream.on('end', function () {\n    debug('wrapped end');\n    if (state.decoder && !state.ended) {\n      var chunk = state.decoder.end();\n      if (chunk && chunk.length) self.push(chunk);\n    }\n\n    self.push(null);\n  });\n\n  stream.on('data', function (chunk) {\n    debug('wrapped data');\n    if (state.decoder) chunk = state.decoder.write(chunk);\n\n    // don't skip over falsy values in objectMode\n    if (state.objectMode && (chunk === null || chunk === undefined)) return;else if (!state.objectMode && (!chunk || !chunk.length)) return;\n\n    var ret = self.push(chunk);\n    if (!ret) {\n      paused = true;\n      stream.pause();\n    }\n  });\n\n  // proxy all the other methods.\n  // important when wrapping filters and duplexes.\n  for (var i in stream) {\n    if (this[i] === undefined && typeof stream[i] === 'function') {\n      this[i] = function (method) {\n        return function () {\n          return stream[method].apply(stream, arguments);\n        };\n      }(i);\n    }\n  }\n\n  // proxy certain important events.\n  for (var n = 0; n < kProxyEvents.length; n++) {\n    stream.on(kProxyEvents[n], self.emit.bind(self, kProxyEvents[n]));\n  }\n\n  // when we try to consume some more bytes, simply unpause the\n  // underlying stream.\n  self._read = function (n) {\n    debug('wrapped _read', n);\n    if (paused) {\n      paused = false;\n      stream.resume();\n    }\n  };\n\n  return self;\n};\n\n// exposed for testing purposes only.\nReadable._fromList = fromList;\n\n// Pluck off n bytes from an array of buffers.\n// Length is the combined lengths of all the buffers in the list.\n// This function is designed to be inlinable, so please take care when making\n// changes to the function body.\nfunction fromList(n, state) {\n  // nothing buffered\n  if (state.length === 0) return null;\n\n  var ret;\n  if (state.objectMode) ret = state.buffer.shift();else if (!n || n >= state.length) {\n    // read it all, truncate the list\n    if (state.decoder) ret = state.buffer.join('');else if (state.buffer.length === 1) ret = state.buffer.head.data;else ret = state.buffer.concat(state.length);\n    state.buffer.clear();\n  } else {\n    // read part of list\n    ret = fromListPartial(n, state.buffer, state.decoder);\n  }\n\n  return ret;\n}\n\n// Extracts only enough buffered data to satisfy the amount requested.\n// This function is designed to be inlinable, so please take care when making\n// changes to the function body.\nfunction fromListPartial(n, list, hasStrings) {\n  var ret;\n  if (n < list.head.data.length) {\n    // slice is the same for buffers and strings\n    ret = list.head.data.slice(0, n);\n    list.head.data = list.head.data.slice(n);\n  } else if (n === list.head.data.length) {\n    // first chunk is a perfect match\n    ret = list.shift();\n  } else {\n    // result spans more than one buffer\n    ret = hasStrings ? copyFromBufferString(n, list) : copyFromBuffer(n, list);\n  }\n  return ret;\n}\n\n// Copies a specified amount of characters from the list of buffered data\n// chunks.\n// This function is designed to be inlinable, so please take care when making\n// changes to the function body.\nfunction copyFromBufferString(n, list) {\n  var p = list.head;\n  var c = 1;\n  var ret = p.data;\n  n -= ret.length;\n  while (p = p.next) {\n    var str = p.data;\n    var nb = n > str.length ? str.length : n;\n    if (nb === str.length) ret += str;else ret += str.slice(0, n);\n    n -= nb;\n    if (n === 0) {\n      if (nb === str.length) {\n        ++c;\n        if (p.next) list.head = p.next;else list.head = list.tail = null;\n      } else {\n        list.head = p;\n        p.data = str.slice(nb);\n      }\n      break;\n    }\n    ++c;\n  }\n  list.length -= c;\n  return ret;\n}\n\n// Copies a specified amount of bytes from the list of buffered data chunks.\n// This function is designed to be inlinable, so please take care when making\n// changes to the function body.\nfunction copyFromBuffer(n, list) {\n  var ret = Buffer.allocUnsafe(n);\n  var p = list.head;\n  var c = 1;\n  p.data.copy(ret);\n  n -= p.data.length;\n  while (p = p.next) {\n    var buf = p.data;\n    var nb = n > buf.length ? buf.length : n;\n    buf.copy(ret, ret.length - n, 0, nb);\n    n -= nb;\n    if (n === 0) {\n      if (nb === buf.length) {\n        ++c;\n        if (p.next) list.head = p.next;else list.head = list.tail = null;\n      } else {\n        list.head = p;\n        p.data = buf.slice(nb);\n      }\n      break;\n    }\n    ++c;\n  }\n  list.length -= c;\n  return ret;\n}\n\nfunction endReadable(stream) {\n  var state = stream._readableState;\n\n  // If we get here before consuming all the bytes, then that is a\n  // bug in node.  Should never happen.\n  if (state.length > 0) throw new Error('\"endReadable()\" called on non-empty stream');\n\n  if (!state.endEmitted) {\n    state.ended = true;\n    processNextTick(endReadableNT, state, stream);\n  }\n}\n\nfunction endReadableNT(state, stream) {\n  // Check that we didn't get one last unshift.\n  if (!state.endEmitted && state.length === 0) {\n    state.endEmitted = true;\n    stream.readable = false;\n    stream.emit('end');\n  }\n}\n\nfunction forEach(xs, f) {\n  for (var i = 0, l = xs.length; i < l; i++) {\n    f(xs[i], i);\n  }\n}\n\nfunction indexOf(xs, x) {\n  for (var i = 0, l = xs.length; i < l; i++) {\n    if (xs[i] === x) return i;\n  }\n  return -1;\n}\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(5), __webpack_require__(9)))\n\n/***/ }),\n/* 29 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nmodule.exports = __webpack_require__(18).EventEmitter;\n\n/***/ }),\n/* 30 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\n/*<replacement>*/\n\nvar processNextTick = __webpack_require__(13);\n/*</replacement>*/\n\n// undocumented cb() API, needed for core, not for public API\nfunction destroy(err, cb) {\n  var _this = this;\n\n  var readableDestroyed = this._readableState && this._readableState.destroyed;\n  var writableDestroyed = this._writableState && this._writableState.destroyed;\n\n  if (readableDestroyed || writableDestroyed) {\n    if (cb) {\n      cb(err);\n    } else if (err && (!this._writableState || !this._writableState.errorEmitted)) {\n      processNextTick(emitErrorNT, this, err);\n    }\n    return;\n  }\n\n  // we set destroyed to true before firing error callbacks in order\n  // to make it re-entrance safe in case destroy() is called within callbacks\n\n  if (this._readableState) {\n    this._readableState.destroyed = true;\n  }\n\n  // if this is a duplex stream mark the writable part as destroyed as well\n  if (this._writableState) {\n    this._writableState.destroyed = true;\n  }\n\n  this._destroy(err || null, function (err) {\n    if (!cb && err) {\n      processNextTick(emitErrorNT, _this, err);\n      if (_this._writableState) {\n        _this._writableState.errorEmitted = true;\n      }\n    } else if (cb) {\n      cb(err);\n    }\n  });\n}\n\nfunction undestroy() {\n  if (this._readableState) {\n    this._readableState.destroyed = false;\n    this._readableState.reading = false;\n    this._readableState.ended = false;\n    this._readableState.endEmitted = false;\n  }\n\n  if (this._writableState) {\n    this._writableState.destroyed = false;\n    this._writableState.ended = false;\n    this._writableState.ending = false;\n    this._writableState.finished = false;\n    this._writableState.errorEmitted = false;\n  }\n}\n\nfunction emitErrorNT(self, err) {\n  self.emit('error', err);\n}\n\nmodule.exports = {\n  destroy: destroy,\n  undestroy: undestroy\n};\n\n/***/ }),\n/* 31 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar Buffer = __webpack_require__(14).Buffer;\n\nvar isEncoding = Buffer.isEncoding || function (encoding) {\n  encoding = '' + encoding;\n  switch (encoding && encoding.toLowerCase()) {\n    case 'hex':case 'utf8':case 'utf-8':case 'ascii':case 'binary':case 'base64':case 'ucs2':case 'ucs-2':case 'utf16le':case 'utf-16le':case 'raw':\n      return true;\n    default:\n      return false;\n  }\n};\n\nfunction _normalizeEncoding(enc) {\n  if (!enc) return 'utf8';\n  var retried;\n  while (true) {\n    switch (enc) {\n      case 'utf8':\n      case 'utf-8':\n        return 'utf8';\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return 'utf16le';\n      case 'latin1':\n      case 'binary':\n        return 'latin1';\n      case 'base64':\n      case 'ascii':\n      case 'hex':\n        return enc;\n      default:\n        if (retried) return; // undefined\n        enc = ('' + enc).toLowerCase();\n        retried = true;\n    }\n  }\n};\n\n// Do not cache `Buffer.isEncoding` when checking encoding names as some\n// modules monkey-patch it to support additional encodings\nfunction normalizeEncoding(enc) {\n  var nenc = _normalizeEncoding(enc);\n  if (typeof nenc !== 'string' && (Buffer.isEncoding === isEncoding || !isEncoding(enc))) throw new Error('Unknown encoding: ' + enc);\n  return nenc || enc;\n}\n\n// StringDecoder provides an interface for efficiently splitting a series of\n// buffers into a series of JS strings without breaking apart multi-byte\n// characters.\nexports.StringDecoder = StringDecoder;\nfunction StringDecoder(encoding) {\n  this.encoding = normalizeEncoding(encoding);\n  var nb;\n  switch (this.encoding) {\n    case 'utf16le':\n      this.text = utf16Text;\n      this.end = utf16End;\n      nb = 4;\n      break;\n    case 'utf8':\n      this.fillLast = utf8FillLast;\n      nb = 4;\n      break;\n    case 'base64':\n      this.text = base64Text;\n      this.end = base64End;\n      nb = 3;\n      break;\n    default:\n      this.write = simpleWrite;\n      this.end = simpleEnd;\n      return;\n  }\n  this.lastNeed = 0;\n  this.lastTotal = 0;\n  this.lastChar = Buffer.allocUnsafe(nb);\n}\n\nStringDecoder.prototype.write = function (buf) {\n  if (buf.length === 0) return '';\n  var r;\n  var i;\n  if (this.lastNeed) {\n    r = this.fillLast(buf);\n    if (r === undefined) return '';\n    i = this.lastNeed;\n    this.lastNeed = 0;\n  } else {\n    i = 0;\n  }\n  if (i < buf.length) return r ? r + this.text(buf, i) : this.text(buf, i);\n  return r || '';\n};\n\nStringDecoder.prototype.end = utf8End;\n\n// Returns only complete characters in a Buffer\nStringDecoder.prototype.text = utf8Text;\n\n// Attempts to complete a partial non-UTF-8 character using bytes from a Buffer\nStringDecoder.prototype.fillLast = function (buf) {\n  if (this.lastNeed <= buf.length) {\n    buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, this.lastNeed);\n    return this.lastChar.toString(this.encoding, 0, this.lastTotal);\n  }\n  buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, buf.length);\n  this.lastNeed -= buf.length;\n};\n\n// Checks the type of a UTF-8 byte, whether it's ASCII, a leading byte, or a\n// continuation byte.\nfunction utf8CheckByte(byte) {\n  if (byte <= 0x7F) return 0;else if (byte >> 5 === 0x06) return 2;else if (byte >> 4 === 0x0E) return 3;else if (byte >> 3 === 0x1E) return 4;\n  return -1;\n}\n\n// Checks at most 3 bytes at the end of a Buffer in order to detect an\n// incomplete multi-byte UTF-8 character. The total number of bytes (2, 3, or 4)\n// needed to complete the UTF-8 character (if applicable) are returned.\nfunction utf8CheckIncomplete(self, buf, i) {\n  var j = buf.length - 1;\n  if (j < i) return 0;\n  var nb = utf8CheckByte(buf[j]);\n  if (nb >= 0) {\n    if (nb > 0) self.lastNeed = nb - 1;\n    return nb;\n  }\n  if (--j < i) return 0;\n  nb = utf8CheckByte(buf[j]);\n  if (nb >= 0) {\n    if (nb > 0) self.lastNeed = nb - 2;\n    return nb;\n  }\n  if (--j < i) return 0;\n  nb = utf8CheckByte(buf[j]);\n  if (nb >= 0) {\n    if (nb > 0) {\n      if (nb === 2) nb = 0;else self.lastNeed = nb - 3;\n    }\n    return nb;\n  }\n  return 0;\n}\n\n// Validates as many continuation bytes for a multi-byte UTF-8 character as\n// needed or are available. If we see a non-continuation byte where we expect\n// one, we \"replace\" the validated continuation bytes we've seen so far with\n// UTF-8 replacement characters ('\\ufffd'), to match v8's UTF-8 decoding\n// behavior. The continuation byte check is included three times in the case\n// where all of the continuation bytes for a character exist in the same buffer.\n// It is also done this way as a slight performance increase instead of using a\n// loop.\nfunction utf8CheckExtraBytes(self, buf, p) {\n  if ((buf[0] & 0xC0) !== 0x80) {\n    self.lastNeed = 0;\n    return '\\uFFFD'.repeat(p);\n  }\n  if (self.lastNeed > 1 && buf.length > 1) {\n    if ((buf[1] & 0xC0) !== 0x80) {\n      self.lastNeed = 1;\n      return '\\uFFFD'.repeat(p + 1);\n    }\n    if (self.lastNeed > 2 && buf.length > 2) {\n      if ((buf[2] & 0xC0) !== 0x80) {\n        self.lastNeed = 2;\n        return '\\uFFFD'.repeat(p + 2);\n      }\n    }\n  }\n}\n\n// Attempts to complete a multi-byte UTF-8 character using bytes from a Buffer.\nfunction utf8FillLast(buf) {\n  var p = this.lastTotal - this.lastNeed;\n  var r = utf8CheckExtraBytes(this, buf, p);\n  if (r !== undefined) return r;\n  if (this.lastNeed <= buf.length) {\n    buf.copy(this.lastChar, p, 0, this.lastNeed);\n    return this.lastChar.toString(this.encoding, 0, this.lastTotal);\n  }\n  buf.copy(this.lastChar, p, 0, buf.length);\n  this.lastNeed -= buf.length;\n}\n\n// Returns all complete UTF-8 characters in a Buffer. If the Buffer ended on a\n// partial character, the character's bytes are buffered until the required\n// number of bytes are available.\nfunction utf8Text(buf, i) {\n  var total = utf8CheckIncomplete(this, buf, i);\n  if (!this.lastNeed) return buf.toString('utf8', i);\n  this.lastTotal = total;\n  var end = buf.length - (total - this.lastNeed);\n  buf.copy(this.lastChar, 0, end);\n  return buf.toString('utf8', i, end);\n}\n\n// For UTF-8, a replacement character for each buffered byte of a (partial)\n// character needs to be added to the output.\nfunction utf8End(buf) {\n  var r = buf && buf.length ? this.write(buf) : '';\n  if (this.lastNeed) return r + '\\uFFFD'.repeat(this.lastTotal - this.lastNeed);\n  return r;\n}\n\n// UTF-16LE typically needs two bytes per character, but even if we have an even\n// number of bytes available, we need to check if we end on a leading/high\n// surrogate. In that case, we need to wait for the next two bytes in order to\n// decode the last character properly.\nfunction utf16Text(buf, i) {\n  if ((buf.length - i) % 2 === 0) {\n    var r = buf.toString('utf16le', i);\n    if (r) {\n      var c = r.charCodeAt(r.length - 1);\n      if (c >= 0xD800 && c <= 0xDBFF) {\n        this.lastNeed = 2;\n        this.lastTotal = 4;\n        this.lastChar[0] = buf[buf.length - 2];\n        this.lastChar[1] = buf[buf.length - 1];\n        return r.slice(0, -1);\n      }\n    }\n    return r;\n  }\n  this.lastNeed = 1;\n  this.lastTotal = 2;\n  this.lastChar[0] = buf[buf.length - 1];\n  return buf.toString('utf16le', i, buf.length - 1);\n}\n\n// For UTF-16LE we do not explicitly append special replacement characters if we\n// end on a partial character, we simply let v8 handle that.\nfunction utf16End(buf) {\n  var r = buf && buf.length ? this.write(buf) : '';\n  if (this.lastNeed) {\n    var end = this.lastTotal - this.lastNeed;\n    return r + this.lastChar.toString('utf16le', 0, end);\n  }\n  return r;\n}\n\nfunction base64Text(buf, i) {\n  var n = (buf.length - i) % 3;\n  if (n === 0) return buf.toString('base64', i);\n  this.lastNeed = 3 - n;\n  this.lastTotal = 3;\n  if (n === 1) {\n    this.lastChar[0] = buf[buf.length - 1];\n  } else {\n    this.lastChar[0] = buf[buf.length - 2];\n    this.lastChar[1] = buf[buf.length - 1];\n  }\n  return buf.toString('base64', i, buf.length - n);\n}\n\nfunction base64End(buf) {\n  var r = buf && buf.length ? this.write(buf) : '';\n  if (this.lastNeed) return r + this.lastChar.toString('base64', 0, 3 - this.lastNeed);\n  return r;\n}\n\n// Pass bytes on through for single-byte encodings (e.g. ascii, latin1, hex)\nfunction simpleWrite(buf) {\n  return buf.toString(this.encoding);\n}\n\nfunction simpleEnd(buf) {\n  return buf && buf.length ? this.write(buf) : '';\n}\n\n/***/ }),\n/* 32 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// a transform stream is a readable/writable stream where you do\n// something with the data.  Sometimes it's called a \"filter\",\n// but that's not a great name for it, since that implies a thing where\n// some bits pass through, and others are simply ignored.  (That would\n// be a valid example of a transform, of course.)\n//\n// While the output is causally related to the input, it's not a\n// necessarily symmetric or synchronous transformation.  For example,\n// a zlib stream might take multiple plain-text writes(), and then\n// emit a single compressed chunk some time in the future.\n//\n// Here's how this works:\n//\n// The Transform stream has all the aspects of the readable and writable\n// stream classes.  When you write(chunk), that calls _write(chunk,cb)\n// internally, and returns false if there's a lot of pending writes\n// buffered up.  When you call read(), that calls _read(n) until\n// there's enough pending readable data buffered up.\n//\n// In a transform stream, the written data is placed in a buffer.  When\n// _read(n) is called, it transforms the queued up data, calling the\n// buffered _write cb's as it consumes chunks.  If consuming a single\n// written chunk would result in multiple output chunks, then the first\n// outputted bit calls the readcb, and subsequent chunks just go into\n// the read buffer, and will cause it to emit 'readable' if necessary.\n//\n// This way, back-pressure is actually determined by the reading side,\n// since _read has to be called to start processing a new chunk.  However,\n// a pathological inflate type of transform can cause excessive buffering\n// here.  For example, imagine a stream where every byte of input is\n// interpreted as an integer from 0-255, and then results in that many\n// bytes of output.  Writing the 4 bytes {ff,ff,ff,ff} would result in\n// 1kb of data being output.  In this case, you could write a very small\n// amount of input, and end up with a very large amount of output.  In\n// such a pathological inflating mechanism, there'd be no way to tell\n// the system to stop doing the transform.  A single 4MB write could\n// cause the system to run out of memory.\n//\n// However, even in such a pathological case, only a single written chunk\n// would be consumed, and then the rest would wait (un-transformed) until\n// the results of the previous transformed chunk were consumed.\n\n\n\nmodule.exports = Transform;\n\nvar Duplex = __webpack_require__(7);\n\n/*<replacement>*/\nvar util = __webpack_require__(10);\nutil.inherits = __webpack_require__(3);\n/*</replacement>*/\n\nutil.inherits(Transform, Duplex);\n\nfunction TransformState(stream) {\n  this.afterTransform = function (er, data) {\n    return afterTransform(stream, er, data);\n  };\n\n  this.needTransform = false;\n  this.transforming = false;\n  this.writecb = null;\n  this.writechunk = null;\n  this.writeencoding = null;\n}\n\nfunction afterTransform(stream, er, data) {\n  var ts = stream._transformState;\n  ts.transforming = false;\n\n  var cb = ts.writecb;\n\n  if (!cb) {\n    return stream.emit('error', new Error('write callback called multiple times'));\n  }\n\n  ts.writechunk = null;\n  ts.writecb = null;\n\n  if (data !== null && data !== undefined) stream.push(data);\n\n  cb(er);\n\n  var rs = stream._readableState;\n  rs.reading = false;\n  if (rs.needReadable || rs.length < rs.highWaterMark) {\n    stream._read(rs.highWaterMark);\n  }\n}\n\nfunction Transform(options) {\n  if (!(this instanceof Transform)) return new Transform(options);\n\n  Duplex.call(this, options);\n\n  this._transformState = new TransformState(this);\n\n  var stream = this;\n\n  // start out asking for a readable event once data is transformed.\n  this._readableState.needReadable = true;\n\n  // we have implemented the _read method, and done the other things\n  // that Readable wants before the first _read call, so unset the\n  // sync guard flag.\n  this._readableState.sync = false;\n\n  if (options) {\n    if (typeof options.transform === 'function') this._transform = options.transform;\n\n    if (typeof options.flush === 'function') this._flush = options.flush;\n  }\n\n  // When the writable side finishes, then flush out anything remaining.\n  this.once('prefinish', function () {\n    if (typeof this._flush === 'function') this._flush(function (er, data) {\n      done(stream, er, data);\n    });else done(stream);\n  });\n}\n\nTransform.prototype.push = function (chunk, encoding) {\n  this._transformState.needTransform = false;\n  return Duplex.prototype.push.call(this, chunk, encoding);\n};\n\n// This is the part where you do stuff!\n// override this function in implementation classes.\n// 'chunk' is an input chunk.\n//\n// Call `push(newChunk)` to pass along transformed output\n// to the readable side.  You may call 'push' zero or more times.\n//\n// Call `cb(err)` when you are done with this chunk.  If you pass\n// an error, then that'll put the hurt on the whole operation.  If you\n// never call cb(), then you'll never get another chunk.\nTransform.prototype._transform = function (chunk, encoding, cb) {\n  throw new Error('_transform() is not implemented');\n};\n\nTransform.prototype._write = function (chunk, encoding, cb) {\n  var ts = this._transformState;\n  ts.writecb = cb;\n  ts.writechunk = chunk;\n  ts.writeencoding = encoding;\n  if (!ts.transforming) {\n    var rs = this._readableState;\n    if (ts.needTransform || rs.needReadable || rs.length < rs.highWaterMark) this._read(rs.highWaterMark);\n  }\n};\n\n// Doesn't matter what the args are here.\n// _transform does all the work.\n// That we got here means that the readable side wants more data.\nTransform.prototype._read = function (n) {\n  var ts = this._transformState;\n\n  if (ts.writechunk !== null && ts.writecb && !ts.transforming) {\n    ts.transforming = true;\n    this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform);\n  } else {\n    // mark that we need a transform, so that any data that comes in\n    // will get processed, now that we've asked for it.\n    ts.needTransform = true;\n  }\n};\n\nTransform.prototype._destroy = function (err, cb) {\n  var _this = this;\n\n  Duplex.prototype._destroy.call(this, err, function (err2) {\n    cb(err2);\n    _this.emit('close');\n  });\n};\n\nfunction done(stream, er, data) {\n  if (er) return stream.emit('error', er);\n\n  if (data !== null && data !== undefined) stream.push(data);\n\n  // if there's nothing in the write buffer, then that means\n  // that nothing more will ever be provided\n  var ws = stream._writableState;\n  var ts = stream._transformState;\n\n  if (ws.length) throw new Error('Calling transform done when ws.length != 0');\n\n  if (ts.transforming) throw new Error('Calling transform done when still transforming');\n\n  return stream.push(null);\n}\n\n/***/ }),\n/* 33 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/* WEBPACK VAR INJECTION */(function(Buffer) {\n\nvar EC = __webpack_require__(0).ec;\nvar ec = new EC('secp256k1');\nvar ecparams = ec.curve;\n\nvar BN = __webpack_require__(1);\n\nvar rlp = __webpack_require__(12);\n\nvar _require = __webpack_require__(17),\n    sha3 = _require.sha3;\n\n// ===============================\n// ethereumjs-util.privateToPublic\n// ===============================\n\n\nvar privateToPublic = function privateToPublic(privateKey) {\n  var compressed = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;\n\n  if (typeof privateKey === 'string') privateKey = rlp.toBuffer('0x' + rlp.stripHexPrefix(privateKey));\n\n  if (!Buffer.isBuffer(privateKey)) throw new Error('invalid private key');\n\n  var d = new BN(privateKey);\n  if (d.cmp(ecparams.n) >= 0 || d.isZero()) throw new Error('invalid private key');\n\n  var publicKey = Buffer.from(ec.keyFromPrivate(privateKey).getPublic(compressed, true));\n  return publicKey.toString('hex');\n};\n\n// ===============================\n// ethereumjs-util.publicToAddress\n// ===============================\nvar publicToAddress = function publicToAddress(publicKey) {\n  if (typeof publicKey === 'string') publicKey = rlp.toBuffer('0x' + rlp.stripHexPrefix(publicKey));\n\n  if (!Buffer.isBuffer(publicKey)) throw new Error('invalid public key');\n\n  if (publicKey.length === 65) publicKey = publicKey.slice(1);\n\n  if (publicKey.length !== 64) throw new Error('Length of public key is ' + publicKey.length + ' bytes. Expected length is 64 bytes.');\n\n  // address contains the lower 160bits of the hash => 20 bytes => 40 hex-encoded string characters\n  return sha3(publicKey).slice(-40);\n};\n\nvar genKeyPair = function genKeyPair() {\n  var key = ec.genKeyPair();\n\n  var privateKey = key.getPrivate('hex');\n  var publicKey = key.getPublic().encode('hex');\n  var address = publicToAddress(publicKey);\n\n  return { privateKey: privateKey, publicKey: publicKey, address: address };\n};\n\nmodule.exports = { privateToPublic: privateToPublic, publicToAddress: publicToAddress, genKeyPair: genKeyPair };\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(2).Buffer))\n\n/***/ }),\n/* 34 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar _require = __webpack_require__(2),\n    Buffer = _require.Buffer;\n\nvar BN = __webpack_require__(1);\n\nvar _require2 = __webpack_require__(39),\n    sign = _require2.sign,\n    verify = _require2.verify,\n    unsign = _require2.unsign;\n\nvar _require3 = __webpack_require__(33),\n    privateToPublic = _require3.privateToPublic,\n    publicToAddress = _require3.publicToAddress,\n    genKeyPair = _require3.genKeyPair;\n\nvar _require4 = __webpack_require__(12),\n    encode = _require4.encode,\n    isHexPrefixed = _require4.isHexPrefixed,\n    stripHexPrefix = _require4.stripHexPrefix,\n    stripZeros = _require4.stripZeros,\n    intToHex = _require4.intToHex,\n    padToEven = _require4.padToEven,\n    intToBuffer = _require4.intToBuffer,\n    toBuffer = _require4.toBuffer,\n    bufferToHex = _require4.bufferToHex,\n    bufferToInt = _require4.bufferToInt;\n\nvar _require5 = __webpack_require__(17),\n    createKeccakHash = _require5.createKeccakHash,\n    sha3 = _require5.sha3;\n\nvar ethereumjs_tx_sign = {\n  sign: sign,\n  verify: verify,\n  unsign: unsign,\n  keypairs: { privateToPublic: privateToPublic, publicToAddress: publicToAddress, genKeyPair: genKeyPair },\n  rlp: { encode: encode, isHexPrefixed: isHexPrefixed, stripHexPrefix: stripHexPrefix, stripZeros: stripZeros, intToHex: intToHex, padToEven: padToEven, intToBuffer: intToBuffer, toBuffer: toBuffer, bufferToHex: bufferToHex, bufferToInt: bufferToInt },\n  keccak: { createKeccakHash: createKeccakHash, sha3: sha3 }\n};\n\nwindow.Buffer = Buffer;\n\nwindow.BN = BN;\n\nwindow.ethereumjs_tx_sign = ethereumjs_tx_sign;\n\n/***/ }),\n/* 35 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\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\nrevLookup['-'.charCodeAt(0)] = 62;\nrevLookup['_'.charCodeAt(0)] = 63;\n\nfunction placeHoldersCount(b64) {\n  var len = b64.length;\n  if (len % 4 > 0) {\n    throw new Error('Invalid string. Length must be a multiple of 4');\n  }\n\n  // the number of equal signs (place holders)\n  // if there are two placeholders, than the two characters before it\n  // represent one byte\n  // if there is only one, then the three characters before it represent 2 bytes\n  // this is just a cheap hack to not do indexOf twice\n  return b64[len - 2] === '=' ? 2 : b64[len - 1] === '=' ? 1 : 0;\n}\n\nfunction byteLength(b64) {\n  // base64 is 4/3 + up to two characters of the original data\n  return b64.length * 3 / 4 - placeHoldersCount(b64);\n}\n\nfunction toByteArray(b64) {\n  var i, l, tmp, placeHolders, arr;\n  var len = b64.length;\n  placeHolders = placeHoldersCount(b64);\n\n  arr = new Arr(len * 3 / 4 - placeHolders);\n\n  // if there are placeholders, only get up to the last complete 4 chars\n  l = placeHolders > 0 ? len - 4 : len;\n\n  var L = 0;\n\n  for (i = 0; i < l; i += 4) {\n    tmp = revLookup[b64.charCodeAt(i)] << 18 | revLookup[b64.charCodeAt(i + 1)] << 12 | revLookup[b64.charCodeAt(i + 2)] << 6 | revLookup[b64.charCodeAt(i + 3)];\n    arr[L++] = tmp >> 16 & 0xFF;\n    arr[L++] = tmp >> 8 & 0xFF;\n    arr[L++] = tmp & 0xFF;\n  }\n\n  if (placeHolders === 2) {\n    tmp = revLookup[b64.charCodeAt(i)] << 2 | revLookup[b64.charCodeAt(i + 1)] >> 4;\n    arr[L++] = tmp & 0xFF;\n  } else if (placeHolders === 1) {\n    tmp = revLookup[b64.charCodeAt(i)] << 10 | revLookup[b64.charCodeAt(i + 1)] << 4 | revLookup[b64.charCodeAt(i + 2)] >> 2;\n    arr[L++] = tmp >> 8 & 0xFF;\n    arr[L++] = tmp & 0xFF;\n  }\n\n  return arr;\n}\n\nfunction tripletToBase64(num) {\n  return lookup[num >> 18 & 0x3F] + lookup[num >> 12 & 0x3F] + lookup[num >> 6 & 0x3F] + 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 = (uint8[i] << 16) + (uint8[i + 1] << 8) + uint8[i + 2];\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 output = '';\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    output += lookup[tmp >> 2];\n    output += lookup[tmp << 4 & 0x3F];\n    output += '==';\n  } else if (extraBytes === 2) {\n    tmp = (uint8[len - 2] << 8) + uint8[len - 1];\n    output += lookup[tmp >> 10];\n    output += lookup[tmp >> 4 & 0x3F];\n    output += lookup[tmp << 2 & 0x3F];\n    output += '=';\n  }\n\n  parts.push(output);\n\n  return parts.join('');\n}\n\n/***/ }),\n/* 36 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nexports.read = function (buffer, offset, isLE, mLen, nBytes) {\n  var e, m;\n  var eLen = nBytes * 8 - mLen - 1;\n  var eMax = (1 << eLen) - 1;\n  var eBias = eMax >> 1;\n  var nBits = -7;\n  var i = isLE ? nBytes - 1 : 0;\n  var d = isLE ? -1 : 1;\n  var s = buffer[offset + i];\n\n  i += d;\n\n  e = s & (1 << -nBits) - 1;\n  s >>= -nBits;\n  nBits += eLen;\n  for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8) {}\n\n  m = e & (1 << -nBits) - 1;\n  e >>= -nBits;\n  nBits += mLen;\n  for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8) {}\n\n  if (e === 0) {\n    e = 1 - eBias;\n  } else if (e === eMax) {\n    return m ? NaN : (s ? -1 : 1) * Infinity;\n  } else {\n    m = m + Math.pow(2, mLen);\n    e = e - eBias;\n  }\n  return (s ? -1 : 1) * m * Math.pow(2, e - mLen);\n};\n\nexports.write = function (buffer, value, offset, isLE, mLen, nBytes) {\n  var e, m, c;\n  var eLen = nBytes * 8 - mLen - 1;\n  var eMax = (1 << eLen) - 1;\n  var eBias = eMax >> 1;\n  var rt = mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0;\n  var i = isLE ? 0 : nBytes - 1;\n  var d = isLE ? 1 : -1;\n  var s = value < 0 || value === 0 && 1 / value < 0 ? 1 : 0;\n\n  value = Math.abs(value);\n\n  if (isNaN(value) || value === Infinity) {\n    m = isNaN(value) ? 1 : 0;\n    e = eMax;\n  } else {\n    e = Math.floor(Math.log(value) / Math.LN2);\n    if (value * (c = Math.pow(2, -e)) < 1) {\n      e--;\n      c *= 2;\n    }\n    if (e + eBias >= 1) {\n      value += rt / c;\n    } else {\n      value += rt * Math.pow(2, 1 - eBias);\n    }\n    if (value * c >= 2) {\n      e++;\n      c /= 2;\n    }\n\n    if (e + eBias >= eMax) {\n      m = 0;\n      e = eMax;\n    } else if (e + eBias >= 1) {\n      m = (value * c - 1) * Math.pow(2, mLen);\n      e = e + eBias;\n    } else {\n      m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen);\n      e = 0;\n    }\n  }\n\n  for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}\n\n  e = e << mLen | m;\n  eLen += mLen;\n  for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}\n\n  buffer[offset + i - d] |= s * 128;\n};\n\n/***/ }),\n/* 37 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nmodule.exports = function (module) {\n\tif (!module.webpackPolyfill) {\n\t\tmodule.deprecate = function () {};\n\t\tmodule.paths = [];\n\t\t// module.parent = undefined by default\n\t\tif (!module.children) module.children = [];\n\t\tObject.defineProperty(module, \"loaded\", {\n\t\t\tenumerable: true,\n\t\t\tget: function get() {\n\t\t\t\treturn module.l;\n\t\t\t}\n\t\t});\n\t\tObject.defineProperty(module, \"id\", {\n\t\t\tenumerable: true,\n\t\t\tget: function get() {\n\t\t\t\treturn module.i;\n\t\t\t}\n\t\t});\n\t\tmodule.webpackPolyfill = 1;\n\t}\n\treturn module;\n};\n\n/***/ }),\n/* 38 */\n/***/ (function(module, exports) {\n\n/* (ignored) */\n\n/***/ }),\n/* 39 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/* WEBPACK VAR INJECTION */(function(Buffer) {\n\nvar EC = __webpack_require__(0).ec;\nvar ec = new EC('secp256k1');\nvar ecparams = ec.curve;\n\nvar BN = __webpack_require__(1);\n\nvar unsignRawTx = __webpack_require__(63);\n\nvar rlp = __webpack_require__(12); // {encode, isHexPrefixed, stripHexPrefix, stripZeros, intToHex, padToEven, intToBuffer, toBuffer, bufferToHex, bufferToInt}\n\nvar _require = __webpack_require__(17),\n    sha3 = _require.sha3;\n\nvar _require2 = __webpack_require__(33),\n    publicToAddress = _require2.publicToAddress;\n\nvar assert = __webpack_require__(26);\n\n// ----------------------------------------------------------------------\n\n// =========================\n// ethereumjs-tx.constructor\n// =========================\nvar fields = [{\n  name: 'nonce',\n  length: 32,\n  allowLess: true,\n  default: new Buffer([])\n}, {\n  name: 'gasPrice',\n  length: 32,\n  allowLess: true,\n  default: new Buffer([])\n}, {\n  name: 'gasLimit',\n  alias: 'gas',\n  length: 32,\n  allowLess: true,\n  default: new Buffer([])\n}, {\n  name: 'to',\n  allowZero: true,\n  length: 20,\n  default: new Buffer([])\n}, {\n  name: 'value',\n  length: 32,\n  allowLess: true,\n  default: new Buffer([])\n}, {\n  name: 'data',\n  alias: 'input',\n  allowZero: true,\n  default: new Buffer([])\n}, {\n  name: 'v',\n  allowZero: true,\n  default: new Buffer([0x1c])\n}, {\n  name: 'r',\n  length: 32,\n  allowZero: true,\n  allowLess: true,\n  default: new Buffer([])\n}, {\n  name: 's',\n  length: 32,\n  allowZero: true,\n  allowLess: true,\n  default: new Buffer([])\n}];\n\n// ================================\n// ethereumjs-util.defineProperties\n// ================================\nvar process_data = function process_data(data) {\n  var use_defaults = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;\n\n  var raw = [];\n  var keys = Object.keys(data);\n\n  fields.forEach(function (field, index) {\n    var value = void 0;\n    if (keys.indexOf(field.name) !== -1) value = get_field_value(field, data[field.name]);else if (keys.indexOf(field.alias) !== -1) value = get_field_value(field, data[field.alias]);else if (use_defaults && field.default !== undefined) value = field.default;\n    if (value !== undefined) raw[index] = value;\n  });\n\n  return raw;\n};\n\nvar get_field_value = function get_field_value(field, value) {\n  var v = rlp.toBuffer(value);\n  var isZero = v.toString('hex').match(/^0+$/) !== null;\n\n  // modify value\n  if (isZero) {\n    if (!field.allowZero) v = Buffer.allocUnsafe(0);else if (field.allowLess) v = Buffer.alloc(1, 0);else if (field.length) v = Buffer.alloc(field.length, 0);\n  } else {\n    if (field.allowLess) v = rlp.stripZeros(v);\n  }\n\n  // validate value\n  if (field.length) {\n    if (field.allowLess) assert(field.length >= v.length, 'The field ' + field.name + ' must not have more ' + field.length + ' bytes');else assert(field.length === v.length, 'The field ' + field.name + ' must have byte length of ' + field.length);\n  }\n\n  return v;\n};\n\n// ==================\n// ethereumjs-tx.sign\n// ==================\nvar get_signature = function get_signature(rawData, chainId, privateKey) {\n  var msgHash = get_hash(rawData, chainId);\n\n  var _get_raw_signature = get_raw_signature(msgHash, privateKey),\n      DER = _get_raw_signature.DER,\n      sig = _get_raw_signature.sig;\n\n  var rawSigData = format_raw_signature(sig);\n  if (chainId) rawSigData.v += chainId * 2 + 8;\n  rawSigData = process_data(rawSigData, false);\n  rawSigData.forEach(function (value, index) {\n    if (value !== undefined) rawData[index] = value;\n  });\n\n  return { msgHash: msgHash, DER: DER, signature: sig.signature };\n};\n\n// ==================\n// ethereumjs-tx.hash\n// ==================\nvar get_hash = function get_hash(rawData, chainId) {\n  var items = rawData.slice(0, 6); // \"nonce\",\"gasPrice\",\"gasLimit\",\"to\",\"value\",\"data\"\n  if (chainId) {\n    var rawSigData = { v: chainId, r: null, s: null };\n    rawSigData = process_data(rawSigData, false);\n    rawSigData.forEach(function (value, index) {\n      if (value !== undefined) items[index] = value;\n    });\n  }\n\n  var msgHash = sha3(rlp.encode(items));\n  return rlp.stripHexPrefix(msgHash);\n};\n\n// ===================\n// secp256k1-node.sign\n// ===================\nvar get_raw_signature = function get_raw_signature(msgHash, privateKey) {\n  var d = new BN(rlp.bufferToHex(privateKey, false), 16);\n  if (d.cmp(ecparams.n) >= 0 || d.isZero()) throw new Error(\"nonce generation function failed or private key is invalid\");\n\n  var signed_msgHash = ec.sign(msgHash, privateKey, { canonical: true });\n  var DER = signed_msgHash.toDER();\n  var sig = {\n    signature: Buffer.concat([signed_msgHash.r.toArrayLike(Buffer, 'be', 32), signed_msgHash.s.toArrayLike(Buffer, 'be', 32)]),\n    recovery: signed_msgHash.recoveryParam\n  };\n  return { DER: DER, sig: sig };\n};\n\n// ======================\n// ethereumjs-util.ecsign\n// ======================\nvar format_raw_signature = function format_raw_signature(sig) {\n  var data = {};\n  data.v = sig.recovery + 27;\n  data.r = sig.signature.slice(0, 32);\n  data.s = sig.signature.slice(32, 64);\n  return data;\n};\n\n// ===\n// API\n// ===\nvar sign = function sign(data, privateKey) {\n  privateKey = rlp.toBuffer('0x' + rlp.stripHexPrefix(privateKey));\n  var rawData = process_data(data);\n\n  var _get_signature = get_signature(rawData, data.chainId, privateKey),\n      msgHash = _get_signature.msgHash,\n      DER = _get_signature.DER,\n      signature = _get_signature.signature;\n\n  var rawTx = rlp.encode(rawData).toString('hex');\n  return { rawData: rawData, msgHash: msgHash, DER: DER, signature: signature, rawTx: rawTx };\n};\n\n// =====================\n// secp256k1-node.verify\n// =====================\nvar verify = function verify(msgHash, signature, publicKey) {\n  publicKey = rlp.toBuffer('0x' + rlp.stripHexPrefix(publicKey));\n\n  // skip this step if signature is DER encoded\n  if (Buffer.isBuffer(signature) && signature.length === 64) {\n    var sigObj = { r: signature.slice(0, 32), s: signature.slice(32, 64) };\n\n    var sigr = new BN(sigObj.r.toString('hex'), 16);\n    var sigs = new BN(sigObj.s.toString('hex'), 16);\n    if (sigr.cmp(ecparams.n) >= 0 || sigs.cmp(ecparams.n) >= 0) throw new Error(\"couldn't parse signature\");\n    if (sigs.cmp(ec.nh) === 1 || sigr.isZero() || sigs.isZero()) return false;\n\n    signature = sigObj;\n  }\n\n  return ec.verify(msgHash, signature, publicKey);\n};\n\nvar unsign = function unsign(rawTx) {\n  var _unsignRawTx = unsignRawTx(rawTx, true, true, false),\n      txData = _unsignRawTx.txData,\n      signature = _unsignRawTx.signature;\n\n  var rawData = process_data(txData);\n  var msgHash = get_hash(rawData, txData.chainId);\n\n  var ec_msgHash = new BN(msgHash, 16);\n  var ec_signature = {\n    r: signature.r,\n    s: signature.s\n  };\n  var ec_recovery = parseInt(signature.v, 16) - 27;\n  if (txData.chainId) ec_recovery -= txData.chainId * 2 + 8;\n\n  var publicKey = ec.recoverPubKey(ec_msgHash, ec_signature, ec_recovery).encode('hex');\n  var address = publicToAddress(publicKey);\n\n  return { txData: txData, signature: signature, msgHash: msgHash, publicKey: publicKey, address: address };\n};\n\nmodule.exports = { sign: sign, verify: verify, unsign: unsign\n\n  // ----------------------------------------------------------------------\n\n};\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(2).Buffer))\n\n/***/ }),\n/* 40 */\n/***/ (function(module, exports) {\n\nmodule.exports = {\"_args\":[[\"elliptic@6.4.0\",\"c:\\\\_z\\\\ethereumjs-tx-sign\\\\browser-build\"]],\"_development\":true,\"_from\":\"elliptic@6.4.0\",\"_id\":\"elliptic@6.4.0\",\"_inBundle\":false,\"_integrity\":\"sha1-ysmvh2LIWDYYcAPI3+GT5eLq5d8=\",\"_location\":\"/elliptic\",\"_phantomChildren\":{},\"_requested\":{\"type\":\"version\",\"registry\":true,\"raw\":\"elliptic@6.4.0\",\"name\":\"elliptic\",\"escapedName\":\"elliptic\",\"rawSpec\":\"6.4.0\",\"saveSpec\":null,\"fetchSpec\":\"6.4.0\"},\"_requiredBy\":[\"/browserify-sign\",\"/create-ecdh\"],\"_resolved\":\"https://registry.npmjs.org/elliptic/-/elliptic-6.4.0.tgz\",\"_spec\":\"6.4.0\",\"_where\":\"c:\\\\_z\\\\ethereumjs-tx-sign\\\\browser-build\",\"author\":{\"name\":\"Fedor Indutny\",\"email\":\"fedor@indutny.com\"},\"bugs\":{\"url\":\"https://github.com/indutny/elliptic/issues\"},\"dependencies\":{\"bn.js\":\"^4.4.0\",\"brorand\":\"^1.0.1\",\"hash.js\":\"^1.0.0\",\"hmac-drbg\":\"^1.0.0\",\"inherits\":\"^2.0.1\",\"minimalistic-assert\":\"^1.0.0\",\"minimalistic-crypto-utils\":\"^1.0.0\"},\"description\":\"EC cryptography\",\"devDependencies\":{\"brfs\":\"^1.4.3\",\"coveralls\":\"^2.11.3\",\"grunt\":\"^0.4.5\",\"grunt-browserify\":\"^5.0.0\",\"grunt-cli\":\"^1.2.0\",\"grunt-contrib-connect\":\"^1.0.0\",\"grunt-contrib-copy\":\"^1.0.0\",\"grunt-contrib-uglify\":\"^1.0.1\",\"grunt-mocha-istanbul\":\"^3.0.1\",\"grunt-saucelabs\":\"^8.6.2\",\"istanbul\":\"^0.4.2\",\"jscs\":\"^2.9.0\",\"jshint\":\"^2.6.0\",\"mocha\":\"^2.1.0\"},\"files\":[\"lib\"],\"homepage\":\"https://github.com/indutny/elliptic\",\"keywords\":[\"EC\",\"Elliptic\",\"curve\",\"Cryptography\"],\"license\":\"MIT\",\"main\":\"lib/elliptic.js\",\"name\":\"elliptic\",\"repository\":{\"type\":\"git\",\"url\":\"git+ssh://git@github.com/indutny/elliptic.git\"},\"scripts\":{\"jscs\":\"jscs benchmarks/*.js lib/*.js lib/**/*.js lib/**/**/*.js test/index.js\",\"jshint\":\"jscs benchmarks/*.js lib/*.js lib/**/*.js lib/**/**/*.js test/index.js\",\"lint\":\"npm run jscs && npm run jshint\",\"test\":\"npm run lint && npm run unit\",\"unit\":\"istanbul test _mocha --reporter=spec test/index.js\",\"version\":\"grunt dist && git add dist/\"},\"version\":\"6.4.0\"}\n\n/***/ }),\n/* 41 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar utils = exports;\nvar BN = __webpack_require__(1);\nvar minAssert = __webpack_require__(6);\nvar minUtils = __webpack_require__(22);\n\nutils.assert = minAssert;\nutils.toArray = minUtils.toArray;\nutils.zero2 = minUtils.zero2;\nutils.toHex = minUtils.toHex;\nutils.encode = minUtils.encode;\n\n// Represent num in a w-NAF form\nfunction getNAF(num, w) {\n  var naf = [];\n  var ws = 1 << w + 1;\n  var k = num.clone();\n  while (k.cmpn(1) >= 0) {\n    var z;\n    if (k.isOdd()) {\n      var mod = k.andln(ws - 1);\n      if (mod > (ws >> 1) - 1) z = (ws >> 1) - mod;else z = mod;\n      k.isubn(z);\n    } else {\n      z = 0;\n    }\n    naf.push(z);\n\n    // Optimization, shift by word if possible\n    var shift = k.cmpn(0) !== 0 && k.andln(ws - 1) === 0 ? w + 1 : 1;\n    for (var i = 1; i < shift; i++) {\n      naf.push(0);\n    }k.iushrn(shift);\n  }\n\n  return naf;\n}\nutils.getNAF = getNAF;\n\n// Represent k1, k2 in a Joint Sparse Form\nfunction getJSF(k1, k2) {\n  var jsf = [[], []];\n\n  k1 = k1.clone();\n  k2 = k2.clone();\n  var d1 = 0;\n  var d2 = 0;\n  while (k1.cmpn(-d1) > 0 || k2.cmpn(-d2) > 0) {\n\n    // First phase\n    var m14 = k1.andln(3) + d1 & 3;\n    var m24 = k2.andln(3) + d2 & 3;\n    if (m14 === 3) m14 = -1;\n    if (m24 === 3) m24 = -1;\n    var u1;\n    if ((m14 & 1) === 0) {\n      u1 = 0;\n    } else {\n      var m8 = k1.andln(7) + d1 & 7;\n      if ((m8 === 3 || m8 === 5) && m24 === 2) u1 = -m14;else u1 = m14;\n    }\n    jsf[0].push(u1);\n\n    var u2;\n    if ((m24 & 1) === 0) {\n      u2 = 0;\n    } else {\n      var m8 = k2.andln(7) + d2 & 7;\n      if ((m8 === 3 || m8 === 5) && m14 === 2) u2 = -m24;else u2 = m24;\n    }\n    jsf[1].push(u2);\n\n    // Second phase\n    if (2 * d1 === u1 + 1) d1 = 1 - d1;\n    if (2 * d2 === u2 + 1) d2 = 1 - d2;\n    k1.iushrn(1);\n    k2.iushrn(1);\n  }\n\n  return jsf;\n}\nutils.getJSF = getJSF;\n\nfunction cachedProperty(obj, name, computer) {\n  var key = '_' + name;\n  obj.prototype[name] = function cachedProperty() {\n    return this[key] !== undefined ? this[key] : this[key] = computer.call(this);\n  };\n}\nutils.cachedProperty = cachedProperty;\n\nfunction parseBytes(bytes) {\n  return typeof bytes === 'string' ? utils.toArray(bytes, 'hex') : bytes;\n}\nutils.parseBytes = parseBytes;\n\nfunction intFromLE(bytes) {\n  return new BN(bytes, 'hex', 'le');\n}\nutils.intFromLE = intFromLE;\n\n/***/ }),\n/* 42 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; };\n\nvar r;\n\nmodule.exports = function rand(len) {\n  if (!r) r = new Rand(null);\n\n  return r.generate(len);\n};\n\nfunction Rand(rand) {\n  this.rand = rand;\n}\nmodule.exports.Rand = Rand;\n\nRand.prototype.generate = function generate(len) {\n  return this._rand(len);\n};\n\n// Emulate crypto API using randy\nRand.prototype._rand = function _rand(n) {\n  if (this.rand.getBytes) return this.rand.getBytes(n);\n\n  var res = new Uint8Array(n);\n  for (var i = 0; i < res.length; i++) {\n    res[i] = this.rand.getByte();\n  }return res;\n};\n\nif ((typeof self === 'undefined' ? 'undefined' : _typeof(self)) === 'object') {\n  if (self.crypto && self.crypto.getRandomValues) {\n    // Modern browsers\n    Rand.prototype._rand = function _rand(n) {\n      var arr = new Uint8Array(n);\n      self.crypto.getRandomValues(arr);\n      return arr;\n    };\n  } else if (self.msCrypto && self.msCrypto.getRandomValues) {\n    // IE\n    Rand.prototype._rand = function _rand(n) {\n      var arr = new Uint8Array(n);\n      self.msCrypto.getRandomValues(arr);\n      return arr;\n    };\n\n    // Safari's WebWorkers do not have `crypto`\n  } else if ((typeof window === 'undefined' ? 'undefined' : _typeof(window)) === 'object') {\n    // Old junk\n    Rand.prototype._rand = function () {\n      throw new Error('Not implemented yet');\n    };\n  }\n} else {\n  // Node.js or Web worker with no crypto support\n  try {\n    var crypto = __webpack_require__(43);\n    if (typeof crypto.randomBytes !== 'function') throw new Error('Not supported');\n\n    Rand.prototype._rand = function _rand(n) {\n      return crypto.randomBytes(n);\n    };\n  } catch (e) {}\n}\n\n/***/ }),\n/* 43 */\n/***/ (function(module, exports) {\n\n/* (ignored) */\n\n/***/ }),\n/* 44 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar BN = __webpack_require__(1);\nvar elliptic = __webpack_require__(0);\nvar utils = elliptic.utils;\nvar getNAF = utils.getNAF;\nvar getJSF = utils.getJSF;\nvar assert = utils.assert;\n\nfunction BaseCurve(type, conf) {\n  this.type = type;\n  this.p = new BN(conf.p, 16);\n\n  // Use Montgomery, when there is no fast reduction for the prime\n  this.red = conf.prime ? BN.red(conf.prime) : BN.mont(this.p);\n\n  // Useful for many curves\n  this.zero = new BN(0).toRed(this.red);\n  this.one = new BN(1).toRed(this.red);\n  this.two = new BN(2).toRed(this.red);\n\n  // Curve configuration, optional\n  this.n = conf.n && new BN(conf.n, 16);\n  this.g = conf.g && this.pointFromJSON(conf.g, conf.gRed);\n\n  // Temporary arrays\n  this._wnafT1 = new Array(4);\n  this._wnafT2 = new Array(4);\n  this._wnafT3 = new Array(4);\n  this._wnafT4 = new Array(4);\n\n  // Generalized Greg Maxwell's trick\n  var adjustCount = this.n && this.p.div(this.n);\n  if (!adjustCount || adjustCount.cmpn(100) > 0) {\n    this.redN = null;\n  } else {\n    this._maxwellTrick = true;\n    this.redN = this.n.toRed(this.red);\n  }\n}\nmodule.exports = BaseCurve;\n\nBaseCurve.prototype.point = function point() {\n  throw new Error('Not implemented');\n};\n\nBaseCurve.prototype.validate = function validate() {\n  throw new Error('Not implemented');\n};\n\nBaseCurve.prototype._fixedNafMul = function _fixedNafMul(p, k) {\n  assert(p.precomputed);\n  var doubles = p._getDoubles();\n\n  var naf = getNAF(k, 1);\n  var I = (1 << doubles.step + 1) - (doubles.step % 2 === 0 ? 2 : 1);\n  I /= 3;\n\n  // Translate into more windowed form\n  var repr = [];\n  for (var j = 0; j < naf.length; j += doubles.step) {\n    var nafW = 0;\n    for (var k = j + doubles.step - 1; k >= j; k--) {\n      nafW = (nafW << 1) + naf[k];\n    }repr.push(nafW);\n  }\n\n  var a = this.jpoint(null, null, null);\n  var b = this.jpoint(null, null, null);\n  for (var i = I; i > 0; i--) {\n    for (var j = 0; j < repr.length; j++) {\n      var nafW = repr[j];\n      if (nafW === i) b = b.mixedAdd(doubles.points[j]);else if (nafW === -i) b = b.mixedAdd(doubles.points[j].neg());\n    }\n    a = a.add(b);\n  }\n  return a.toP();\n};\n\nBaseCurve.prototype._wnafMul = function _wnafMul(p, k) {\n  var w = 4;\n\n  // Precompute window\n  var nafPoints = p._getNAFPoints(w);\n  w = nafPoints.wnd;\n  var wnd = nafPoints.points;\n\n  // Get NAF form\n  var naf = getNAF(k, w);\n\n  // Add `this`*(N+1) for every w-NAF index\n  var acc = this.jpoint(null, null, null);\n  for (var i = naf.length - 1; i >= 0; i--) {\n    // Count zeroes\n    for (var k = 0; i >= 0 && naf[i] === 0; i--) {\n      k++;\n    }if (i >= 0) k++;\n    acc = acc.dblp(k);\n\n    if (i < 0) break;\n    var z = naf[i];\n    assert(z !== 0);\n    if (p.type === 'affine') {\n      // J +- P\n      if (z > 0) acc = acc.mixedAdd(wnd[z - 1 >> 1]);else acc = acc.mixedAdd(wnd[-z - 1 >> 1].neg());\n    } else {\n      // J +- J\n      if (z > 0) acc = acc.add(wnd[z - 1 >> 1]);else acc = acc.add(wnd[-z - 1 >> 1].neg());\n    }\n  }\n  return p.type === 'affine' ? acc.toP() : acc;\n};\n\nBaseCurve.prototype._wnafMulAdd = function _wnafMulAdd(defW, points, coeffs, len, jacobianResult) {\n  var wndWidth = this._wnafT1;\n  var wnd = this._wnafT2;\n  var naf = this._wnafT3;\n\n  // Fill all arrays\n  var max = 0;\n  for (var i = 0; i < len; i++) {\n    var p = points[i];\n    var nafPoints = p._getNAFPoints(defW);\n    wndWidth[i] = nafPoints.wnd;\n    wnd[i] = nafPoints.points;\n  }\n\n  // Comb small window NAFs\n  for (var i = len - 1; i >= 1; i -= 2) {\n    var a = i - 1;\n    var b = i;\n    if (wndWidth[a] !== 1 || wndWidth[b] !== 1) {\n      naf[a] = getNAF(coeffs[a], wndWidth[a]);\n      naf[b] = getNAF(coeffs[b], wndWidth[b]);\n      max = Math.max(naf[a].length, max);\n      max = Math.max(naf[b].length, max);\n      continue;\n    }\n\n    var comb = [points[a], /* 1 */\n    null, /* 3 */\n    null, /* 5 */\n    points[b] /* 7 */\n    ];\n\n    // Try to avoid Projective points, if possible\n    if (points[a].y.cmp(points[b].y) === 0) {\n      comb[1] = points[a].add(points[b]);\n      comb[2] = points[a].toJ().mixedAdd(points[b].neg());\n    } else if (points[a].y.cmp(points[b].y.redNeg()) === 0) {\n      comb[1] = points[a].toJ().mixedAdd(points[b]);\n      comb[2] = points[a].add(points[b].neg());\n    } else {\n      comb[1] = points[a].toJ().mixedAdd(points[b]);\n      comb[2] = points[a].toJ().mixedAdd(points[b].neg());\n    }\n\n    var index = [-3, /* -1 -1 */\n    -1, /* -1 0 */\n    -5, /* -1 1 */\n    -7, /* 0 -1 */\n    0, /* 0 0 */\n    7, /* 0 1 */\n    5, /* 1 -1 */\n    1, /* 1 0 */\n    3 /* 1 1 */\n    ];\n\n    var jsf = getJSF(coeffs[a], coeffs[b]);\n    max = Math.max(jsf[0].length, max);\n    naf[a] = new Array(max);\n    naf[b] = new Array(max);\n    for (var j = 0; j < max; j++) {\n      var ja = jsf[0][j] | 0;\n      var jb = jsf[1][j] | 0;\n\n      naf[a][j] = index[(ja + 1) * 3 + (jb + 1)];\n      naf[b][j] = 0;\n      wnd[a] = comb;\n    }\n  }\n\n  var acc = this.jpoint(null, null, null);\n  var tmp = this._wnafT4;\n  for (var i = max; i >= 0; i--) {\n    var k = 0;\n\n    while (i >= 0) {\n      var zero = true;\n      for (var j = 0; j < len; j++) {\n        tmp[j] = naf[j][i] | 0;\n        if (tmp[j] !== 0) zero = false;\n      }\n      if (!zero) break;\n      k++;\n      i--;\n    }\n    if (i >= 0) k++;\n    acc = acc.dblp(k);\n    if (i < 0) break;\n\n    for (var j = 0; j < len; j++) {\n      var z = tmp[j];\n      var p;\n      if (z === 0) continue;else if (z > 0) p = wnd[j][z - 1 >> 1];else if (z < 0) p = wnd[j][-z - 1 >> 1].neg();\n\n      if (p.type === 'affine') acc = acc.mixedAdd(p);else acc = acc.add(p);\n    }\n  }\n  // Zeroify references\n  for (var i = 0; i < len; i++) {\n    wnd[i] = null;\n  }if (jacobianResult) return acc;else return acc.toP();\n};\n\nfunction BasePoint(curve, type) {\n  this.curve = curve;\n  this.type = type;\n  this.precomputed = null;\n}\nBaseCurve.BasePoint = BasePoint;\n\nBasePoint.prototype.eq = function eq() /*other*/{\n  throw new Error('Not implemented');\n};\n\nBasePoint.prototype.validate = function validate() {\n  return this.curve.validate(this);\n};\n\nBaseCurve.prototype.decodePoint = function decodePoint(bytes, enc) {\n  bytes = utils.toArray(bytes, enc);\n\n  var len = this.p.byteLength();\n\n  // uncompressed, hybrid-odd, hybrid-even\n  if ((bytes[0] === 0x04 || bytes[0] === 0x06 || bytes[0] === 0x07) && bytes.length - 1 === 2 * len) {\n    if (bytes[0] === 0x06) assert(bytes[bytes.length - 1] % 2 === 0);else if (bytes[0] === 0x07) assert(bytes[bytes.length - 1] % 2 === 1);\n\n    var res = this.point(bytes.slice(1, 1 + len), bytes.slice(1 + len, 1 + 2 * len));\n\n    return res;\n  } else if ((bytes[0] === 0x02 || bytes[0] === 0x03) && bytes.length - 1 === len) {\n    return this.pointFromX(bytes.slice(1, 1 + len), bytes[0] === 0x03);\n  }\n  throw new Error('Unknown point format');\n};\n\nBasePoint.prototype.encodeCompressed = function encodeCompressed(enc) {\n  return this.encode(enc, true);\n};\n\nBasePoint.prototype._encode = function _encode(compact) {\n  var len = this.curve.p.byteLength();\n  var x = this.getX().toArray('be', len);\n\n  if (compact) return [this.getY().isEven() ? 0x02 : 0x03].concat(x);\n\n  return [0x04].concat(x, this.getY().toArray('be', len));\n};\n\nBasePoint.prototype.encode = function encode(enc, compact) {\n  return utils.encode(this._encode(compact), enc);\n};\n\nBasePoint.prototype.precompute = function precompute(power) {\n  if (this.precomputed) return this;\n\n  var precomputed = {\n    doubles: null,\n    naf: null,\n    beta: null\n  };\n  precomputed.naf = this._getNAFPoints(8);\n  precomputed.doubles = this._getDoubles(4, power);\n  precomputed.beta = this._getBeta();\n  this.precomputed = precomputed;\n\n  return this;\n};\n\nBasePoint.prototype._hasDoubles = function _hasDoubles(k) {\n  if (!this.precomputed) return false;\n\n  var doubles = this.precomputed.doubles;\n  if (!doubles) return false;\n\n  return doubles.points.length >= Math.ceil((k.bitLength() + 1) / doubles.step);\n};\n\nBasePoint.prototype._getDoubles = function _getDoubles(step, power) {\n  if (this.precomputed && this.precomputed.doubles) return this.precomputed.doubles;\n\n  var doubles = [this];\n  var acc = this;\n  for (var i = 0; i < power; i += step) {\n    for (var j = 0; j < step; j++) {\n      acc = acc.dbl();\n    }doubles.push(acc);\n  }\n  return {\n    step: step,\n    points: doubles\n  };\n};\n\nBasePoint.prototype._getNAFPoints = function _getNAFPoints(wnd) {\n  if (this.precomputed && this.precomputed.naf) return this.precomputed.naf;\n\n  var res = [this];\n  var max = (1 << wnd) - 1;\n  var dbl = max === 1 ? null : this.dbl();\n  for (var i = 1; i < max; i++) {\n    res[i] = res[i - 1].add(dbl);\n  }return {\n    wnd: wnd,\n    points: res\n  };\n};\n\nBasePoint.prototype._getBeta = function _getBeta() {\n  return null;\n};\n\nBasePoint.prototype.dblp = function dblp(k) {\n  var r = this;\n  for (var i = 0; i < k; i++) {\n    r = r.dbl();\n  }return r;\n};\n\n/***/ }),\n/* 45 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar curve = __webpack_require__(11);\nvar elliptic = __webpack_require__(0);\nvar BN = __webpack_require__(1);\nvar inherits = __webpack_require__(3);\nvar Base = curve.base;\n\nvar assert = elliptic.utils.assert;\n\nfunction ShortCurve(conf) {\n  Base.call(this, 'short', conf);\n\n  this.a = new BN(conf.a, 16).toRed(this.red);\n  this.b = new BN(conf.b, 16).toRed(this.red);\n  this.tinv = this.two.redInvm();\n\n  this.zeroA = this.a.fromRed().cmpn(0) === 0;\n  this.threeA = this.a.fromRed().sub(this.p).cmpn(-3) === 0;\n\n  // If the curve is endomorphic, precalculate beta and lambda\n  this.endo = this._getEndomorphism(conf);\n  this._endoWnafT1 = new Array(4);\n  this._endoWnafT2 = new Array(4);\n}\ninherits(ShortCurve, Base);\nmodule.exports = ShortCurve;\n\nShortCurve.prototype._getEndomorphism = function _getEndomorphism(conf) {\n  // No efficient endomorphism\n  if (!this.zeroA || !this.g || !this.n || this.p.modn(3) !== 1) return;\n\n  // Compute beta and lambda, that lambda * P = (beta * Px; Py)\n  var beta;\n  var lambda;\n  if (conf.beta) {\n    beta = new BN(conf.beta, 16).toRed(this.red);\n  } else {\n    var betas = this._getEndoRoots(this.p);\n    // Choose the smallest beta\n    beta = betas[0].cmp(betas[1]) < 0 ? betas[0] : betas[1];\n    beta = beta.toRed(this.red);\n  }\n  if (conf.lambda) {\n    lambda = new BN(conf.lambda, 16);\n  } else {\n    // Choose the lambda that is matching selected beta\n    var lambdas = this._getEndoRoots(this.n);\n    if (this.g.mul(lambdas[0]).x.cmp(this.g.x.redMul(beta)) === 0) {\n      lambda = lambdas[0];\n    } else {\n      lambda = lambdas[1];\n      assert(this.g.mul(lambda).x.cmp(this.g.x.redMul(beta)) === 0);\n    }\n  }\n\n  // Get basis vectors, used for balanced length-two representation\n  var basis;\n  if (conf.basis) {\n    basis = conf.basis.map(function (vec) {\n      return {\n        a: new BN(vec.a, 16),\n        b: new BN(vec.b, 16)\n      };\n    });\n  } else {\n    basis = this._getEndoBasis(lambda);\n  }\n\n  return {\n    beta: beta,\n    lambda: lambda,\n    basis: basis\n  };\n};\n\nShortCurve.prototype._getEndoRoots = function _getEndoRoots(num) {\n  // Find roots of for x^2 + x + 1 in F\n  // Root = (-1 +- Sqrt(-3)) / 2\n  //\n  var red = num === this.p ? this.red : BN.mont(num);\n  var tinv = new BN(2).toRed(red).redInvm();\n  var ntinv = tinv.redNeg();\n\n  var s = new BN(3).toRed(red).redNeg().redSqrt().redMul(tinv);\n\n  var l1 = ntinv.redAdd(s).fromRed();\n  var l2 = ntinv.redSub(s).fromRed();\n  return [l1, l2];\n};\n\nShortCurve.prototype._getEndoBasis = function _getEndoBasis(lambda) {\n  // aprxSqrt >= sqrt(this.n)\n  var aprxSqrt = this.n.ushrn(Math.floor(this.n.bitLength() / 2));\n\n  // 3.74\n  // Run EGCD, until r(L + 1) < aprxSqrt\n  var u = lambda;\n  var v = this.n.clone();\n  var x1 = new BN(1);\n  var y1 = new BN(0);\n  var x2 = new BN(0);\n  var y2 = new BN(1);\n\n  // NOTE: all vectors are roots of: a + b * lambda = 0 (mod n)\n  var a0;\n  var b0;\n  // First vector\n  var a1;\n  var b1;\n  // Second vector\n  var a2;\n  var b2;\n\n  var prevR;\n  var i = 0;\n  var r;\n  var x;\n  while (u.cmpn(0) !== 0) {\n    var q = v.div(u);\n    r = v.sub(q.mul(u));\n    x = x2.sub(q.mul(x1));\n    var y = y2.sub(q.mul(y1));\n\n    if (!a1 && r.cmp(aprxSqrt) < 0) {\n      a0 = prevR.neg();\n      b0 = x1;\n      a1 = r.neg();\n      b1 = x;\n    } else if (a1 && ++i === 2) {\n      break;\n    }\n    prevR = r;\n\n    v = u;\n    u = r;\n    x2 = x1;\n    x1 = x;\n    y2 = y1;\n    y1 = y;\n  }\n  a2 = r.neg();\n  b2 = x;\n\n  var len1 = a1.sqr().add(b1.sqr());\n  var len2 = a2.sqr().add(b2.sqr());\n  if (len2.cmp(len1) >= 0) {\n    a2 = a0;\n    b2 = b0;\n  }\n\n  // Normalize signs\n  if (a1.negative) {\n    a1 = a1.neg();\n    b1 = b1.neg();\n  }\n  if (a2.negative) {\n    a2 = a2.neg();\n    b2 = b2.neg();\n  }\n\n  return [{ a: a1, b: b1 }, { a: a2, b: b2 }];\n};\n\nShortCurve.prototype._endoSplit = function _endoSplit(k) {\n  var basis = this.endo.basis;\n  var v1 = basis[0];\n  var v2 = basis[1];\n\n  var c1 = v2.b.mul(k).divRound(this.n);\n  var c2 = v1.b.neg().mul(k).divRound(this.n);\n\n  var p1 = c1.mul(v1.a);\n  var p2 = c2.mul(v2.a);\n  var q1 = c1.mul(v1.b);\n  var q2 = c2.mul(v2.b);\n\n  // Calculate answer\n  var k1 = k.sub(p1).sub(p2);\n  var k2 = q1.add(q2).neg();\n  return { k1: k1, k2: k2 };\n};\n\nShortCurve.prototype.pointFromX = function pointFromX(x, odd) {\n  x = new BN(x, 16);\n  if (!x.red) x = x.toRed(this.red);\n\n  var y2 = x.redSqr().redMul(x).redIAdd(x.redMul(this.a)).redIAdd(this.b);\n  var y = y2.redSqrt();\n  if (y.redSqr().redSub(y2).cmp(this.zero) !== 0) throw new Error('invalid point');\n\n  // XXX Is there any way to tell if the number is odd without converting it\n  // to non-red form?\n  var isOdd = y.fromRed().isOdd();\n  if (odd && !isOdd || !odd && isOdd) y = y.redNeg();\n\n  return this.point(x, y);\n};\n\nShortCurve.prototype.validate = function validate(point) {\n  if (point.inf) return true;\n\n  var x = point.x;\n  var y = point.y;\n\n  var ax = this.a.redMul(x);\n  var rhs = x.redSqr().redMul(x).redIAdd(ax).redIAdd(this.b);\n  return y.redSqr().redISub(rhs).cmpn(0) === 0;\n};\n\nShortCurve.prototype._endoWnafMulAdd = function _endoWnafMulAdd(points, coeffs, jacobianResult) {\n  var npoints = this._endoWnafT1;\n  var ncoeffs = this._endoWnafT2;\n  for (var i = 0; i < points.length; i++) {\n    var split = this._endoSplit(coeffs[i]);\n    var p = points[i];\n    var beta = p._getBeta();\n\n    if (split.k1.negative) {\n      split.k1.ineg();\n      p = p.neg(true);\n    }\n    if (split.k2.negative) {\n      split.k2.ineg();\n      beta = beta.neg(true);\n    }\n\n    npoints[i * 2] = p;\n    npoints[i * 2 + 1] = beta;\n    ncoeffs[i * 2] = split.k1;\n    ncoeffs[i * 2 + 1] = split.k2;\n  }\n  var res = this._wnafMulAdd(1, npoints, ncoeffs, i * 2, jacobianResult);\n\n  // Clean-up references to points and coefficients\n  for (var j = 0; j < i * 2; j++) {\n    npoints[j] = null;\n    ncoeffs[j] = null;\n  }\n  return res;\n};\n\nfunction Point(curve, x, y, isRed) {\n  Base.BasePoint.call(this, curve, 'affine');\n  if (x === null && y === null) {\n    this.x = null;\n    this.y = null;\n    this.inf = true;\n  } else {\n    this.x = new BN(x, 16);\n    this.y = new BN(y, 16);\n    // Force redgomery representation when loading from JSON\n    if (isRed) {\n      this.x.forceRed(this.curve.red);\n      this.y.forceRed(this.curve.red);\n    }\n    if (!this.x.red) this.x = this.x.toRed(this.curve.red);\n    if (!this.y.red) this.y = this.y.toRed(this.curve.red);\n    this.inf = false;\n  }\n}\ninherits(Point, Base.BasePoint);\n\nShortCurve.prototype.point = function point(x, y, isRed) {\n  return new Point(this, x, y, isRed);\n};\n\nShortCurve.prototype.pointFromJSON = function pointFromJSON(obj, red) {\n  return Point.fromJSON(this, obj, red);\n};\n\nPoint.prototype._getBeta = function _getBeta() {\n  if (!this.curve.endo) return;\n\n  var pre = this.precomputed;\n  if (pre && pre.beta) return pre.beta;\n\n  var beta = this.curve.point(this.x.redMul(this.curve.endo.beta), this.y);\n  if (pre) {\n    var curve = this.curve;\n    var endoMul = function endoMul(p) {\n      return curve.point(p.x.redMul(curve.endo.beta), p.y);\n    };\n    pre.beta = beta;\n    beta.precomputed = {\n      beta: null,\n      naf: pre.naf && {\n        wnd: pre.naf.wnd,\n        points: pre.naf.points.map(endoMul)\n      },\n      doubles: pre.doubles && {\n        step: pre.doubles.step,\n        points: pre.doubles.points.map(endoMul)\n      }\n    };\n  }\n  return beta;\n};\n\nPoint.prototype.toJSON = function toJSON() {\n  if (!this.precomputed) return [this.x, this.y];\n\n  return [this.x, this.y, this.precomputed && {\n    doubles: this.precomputed.doubles && {\n      step: this.precomputed.doubles.step,\n      points: this.precomputed.doubles.points.slice(1)\n    },\n    naf: this.precomputed.naf && {\n      wnd: this.precomputed.naf.wnd,\n      points: this.precomputed.naf.points.slice(1)\n    }\n  }];\n};\n\nPoint.fromJSON = function fromJSON(curve, obj, red) {\n  if (typeof obj === 'string') obj = JSON.parse(obj);\n  var res = curve.point(obj[0], obj[1], red);\n  if (!obj[2]) return res;\n\n  function obj2point(obj) {\n    return curve.point(obj[0], obj[1], red);\n  }\n\n  var pre = obj[2];\n  res.precomputed = {\n    beta: null,\n    doubles: pre.doubles && {\n      step: pre.doubles.step,\n      points: [res].concat(pre.doubles.points.map(obj2point))\n    },\n    naf: pre.naf && {\n      wnd: pre.naf.wnd,\n      points: [res].concat(pre.naf.points.map(obj2point))\n    }\n  };\n  return res;\n};\n\nPoint.prototype.inspect = function inspect() {\n  if (this.isInfinity()) return '<EC Point Infinity>';\n  return '<EC Point x: ' + this.x.fromRed().toString(16, 2) + ' y: ' + this.y.fromRed().toString(16, 2) + '>';\n};\n\nPoint.prototype.isInfinity = function isInfinity() {\n  return this.inf;\n};\n\nPoint.prototype.add = function add(p) {\n  // O + P = P\n  if (this.inf) return p;\n\n  // P + O = P\n  if (p.inf) return this;\n\n  // P + P = 2P\n  if (this.eq(p)) return this.dbl();\n\n  // P + (-P) = O\n  if (this.neg().eq(p)) return this.curve.point(null, null);\n\n  // P + Q = O\n  if (this.x.cmp(p.x) === 0) return this.curve.point(null, null);\n\n  var c = this.y.redSub(p.y);\n  if (c.cmpn(0) !== 0) c = c.redMul(this.x.redSub(p.x).redInvm());\n  var nx = c.redSqr().redISub(this.x).redISub(p.x);\n  var ny = c.redMul(this.x.redSub(nx)).redISub(this.y);\n  return this.curve.point(nx, ny);\n};\n\nPoint.prototype.dbl = function dbl() {\n  if (this.inf) return this;\n\n  // 2P = O\n  var ys1 = this.y.redAdd(this.y);\n  if (ys1.cmpn(0) === 0) return this.curve.point(null, null);\n\n  var a = this.curve.a;\n\n  var x2 = this.x.redSqr();\n  var dyinv = ys1.redInvm();\n  var c = x2.redAdd(x2).redIAdd(x2).redIAdd(a).redMul(dyinv);\n\n  var nx = c.redSqr().redISub(this.x.redAdd(this.x));\n  var ny = c.redMul(this.x.redSub(nx)).redISub(this.y);\n  return this.curve.point(nx, ny);\n};\n\nPoint.prototype.getX = function getX() {\n  return this.x.fromRed();\n};\n\nPoint.prototype.getY = function getY() {\n  return this.y.fromRed();\n};\n\nPoint.prototype.mul = function mul(k) {\n  k = new BN(k, 16);\n\n  if (this._hasDoubles(k)) return this.curve._fixedNafMul(this, k);else if (this.curve.endo) return this.curve._endoWnafMulAdd([this], [k]);else return this.curve._wnafMul(this, k);\n};\n\nPoint.prototype.mulAdd = function mulAdd(k1, p2, k2) {\n  var points = [this, p2];\n  var coeffs = [k1, k2];\n  if (this.curve.endo) return this.curve._endoWnafMulAdd(points, coeffs);else return this.curve._wnafMulAdd(1, points, coeffs, 2);\n};\n\nPoint.prototype.jmulAdd = function jmulAdd(k1, p2, k2) {\n  var points = [this, p2];\n  var coeffs = [k1, k2];\n  if (this.curve.endo) return this.curve._endoWnafMulAdd(points, coeffs, true);else return this.curve._wnafMulAdd(1, points, coeffs, 2, true);\n};\n\nPoint.prototype.eq = function eq(p) {\n  return this === p || this.inf === p.inf && (this.inf || this.x.cmp(p.x) === 0 && this.y.cmp(p.y) === 0);\n};\n\nPoint.prototype.neg = function neg(_precompute) {\n  if (this.inf) return this;\n\n  var res = this.curve.point(this.x, this.y.redNeg());\n  if (_precompute && this.precomputed) {\n    var pre = this.precomputed;\n    var negate = function negate(p) {\n      return p.neg();\n    };\n    res.precomputed = {\n      naf: pre.naf && {\n        wnd: pre.naf.wnd,\n        points: pre.naf.points.map(negate)\n      },\n      doubles: pre.doubles && {\n        step: pre.doubles.step,\n        points: pre.doubles.points.map(negate)\n      }\n    };\n  }\n  return res;\n};\n\nPoint.prototype.toJ = function toJ() {\n  if (this.inf) return this.curve.jpoint(null, null, null);\n\n  var res = this.curve.jpoint(this.x, this.y, this.curve.one);\n  return res;\n};\n\nfunction JPoint(curve, x, y, z) {\n  Base.BasePoint.call(this, curve, 'jacobian');\n  if (x === null && y === null && z === null) {\n    this.x = this.curve.one;\n    this.y = this.curve.one;\n    this.z = new BN(0);\n  } else {\n    this.x = new BN(x, 16);\n    this.y = new BN(y, 16);\n    this.z = new BN(z, 16);\n  }\n  if (!this.x.red) this.x = this.x.toRed(this.curve.red);\n  if (!this.y.red) this.y = this.y.toRed(this.curve.red);\n  if (!this.z.red) this.z = this.z.toRed(this.curve.red);\n\n  this.zOne = this.z === this.curve.one;\n}\ninherits(JPoint, Base.BasePoint);\n\nShortCurve.prototype.jpoint = function jpoint(x, y, z) {\n  return new JPoint(this, x, y, z);\n};\n\nJPoint.prototype.toP = function toP() {\n  if (this.isInfinity()) return this.curve.point(null, null);\n\n  var zinv = this.z.redInvm();\n  var zinv2 = zinv.redSqr();\n  var ax = this.x.redMul(zinv2);\n  var ay = this.y.redMul(zinv2).redMul(zinv);\n\n  return this.curve.point(ax, ay);\n};\n\nJPoint.prototype.neg = function neg() {\n  return this.curve.jpoint(this.x, this.y.redNeg(), this.z);\n};\n\nJPoint.prototype.add = function add(p) {\n  // O + P = P\n  if (this.isInfinity()) return p;\n\n  // P + O = P\n  if (p.isInfinity()) return this;\n\n  // 12M + 4S + 7A\n  var pz2 = p.z.redSqr();\n  var z2 = this.z.redSqr();\n  var u1 = this.x.redMul(pz2);\n  var u2 = p.x.redMul(z2);\n  var s1 = this.y.redMul(pz2.redMul(p.z));\n  var s2 = p.y.redMul(z2.redMul(this.z));\n\n  var h = u1.redSub(u2);\n  var r = s1.redSub(s2);\n  if (h.cmpn(0) === 0) {\n    if (r.cmpn(0) !== 0) return this.curve.jpoint(null, null, null);else return this.dbl();\n  }\n\n  var h2 = h.redSqr();\n  var h3 = h2.redMul(h);\n  var v = u1.redMul(h2);\n\n  var nx = r.redSqr().redIAdd(h3).redISub(v).redISub(v);\n  var ny = r.redMul(v.redISub(nx)).redISub(s1.redMul(h3));\n  var nz = this.z.redMul(p.z).redMul(h);\n\n  return this.curve.jpoint(nx, ny, nz);\n};\n\nJPoint.prototype.mixedAdd = function mixedAdd(p) {\n  // O + P = P\n  if (this.isInfinity()) return p.toJ();\n\n  // P + O = P\n  if (p.isInfinity()) return this;\n\n  // 8M + 3S + 7A\n  var z2 = this.z.redSqr();\n  var u1 = this.x;\n  var u2 = p.x.redMul(z2);\n  var s1 = this.y;\n  var s2 = p.y.redMul(z2).redMul(this.z);\n\n  var h = u1.redSub(u2);\n  var r = s1.redSub(s2);\n  if (h.cmpn(0) === 0) {\n    if (r.cmpn(0) !== 0) return this.curve.jpoint(null, null, null);else return this.dbl();\n  }\n\n  var h2 = h.redSqr();\n  var h3 = h2.redMul(h);\n  var v = u1.redMul(h2);\n\n  var nx = r.redSqr().redIAdd(h3).redISub(v).redISub(v);\n  var ny = r.redMul(v.redISub(nx)).redISub(s1.redMul(h3));\n  var nz = this.z.redMul(h);\n\n  return this.curve.jpoint(nx, ny, nz);\n};\n\nJPoint.prototype.dblp = function dblp(pow) {\n  if (pow === 0) return this;\n  if (this.isInfinity()) return this;\n  if (!pow) return this.dbl();\n\n  if (this.curve.zeroA || this.curve.threeA) {\n    var r = this;\n    for (var i = 0; i < pow; i++) {\n      r = r.dbl();\n    }return r;\n  }\n\n  // 1M + 2S + 1A + N * (4S + 5M + 8A)\n  // N = 1 => 6M + 6S + 9A\n  var a = this.curve.a;\n  var tinv = this.curve.tinv;\n\n  var jx = this.x;\n  var jy = this.y;\n  var jz = this.z;\n  var jz4 = jz.redSqr().redSqr();\n\n  // Reuse results\n  var jyd = jy.redAdd(jy);\n  for (var i = 0; i < pow; i++) {\n    var jx2 = jx.redSqr();\n    var jyd2 = jyd.redSqr();\n    var jyd4 = jyd2.redSqr();\n    var c = jx2.redAdd(jx2).redIAdd(jx2).redIAdd(a.redMul(jz4));\n\n    var t1 = jx.redMul(jyd2);\n    var nx = c.redSqr().redISub(t1.redAdd(t1));\n    var t2 = t1.redISub(nx);\n    var dny = c.redMul(t2);\n    dny = dny.redIAdd(dny).redISub(jyd4);\n    var nz = jyd.redMul(jz);\n    if (i + 1 < pow) jz4 = jz4.redMul(jyd4);\n\n    jx = nx;\n    jz = nz;\n    jyd = dny;\n  }\n\n  return this.curve.jpoint(jx, jyd.redMul(tinv), jz);\n};\n\nJPoint.prototype.dbl = function dbl() {\n  if (this.isInfinity()) return this;\n\n  if (this.curve.zeroA) return this._zeroDbl();else if (this.curve.threeA) return this._threeDbl();else return this._dbl();\n};\n\nJPoint.prototype._zeroDbl = function _zeroDbl() {\n  var nx;\n  var ny;\n  var nz;\n  // Z = 1\n  if (this.zOne) {\n    // hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-0.html\n    //     #doubling-mdbl-2007-bl\n    // 1M + 5S + 14A\n\n    // XX = X1^2\n    var xx = this.x.redSqr();\n    // YY = Y1^2\n    var yy = this.y.redSqr();\n    // YYYY = YY^2\n    var yyyy = yy.redSqr();\n    // S = 2 * ((X1 + YY)^2 - XX - YYYY)\n    var s = this.x.redAdd(yy).redSqr().redISub(xx).redISub(yyyy);\n    s = s.redIAdd(s);\n    // M = 3 * XX + a; a = 0\n    var m = xx.redAdd(xx).redIAdd(xx);\n    // T = M ^ 2 - 2*S\n    var t = m.redSqr().redISub(s).redISub(s);\n\n    // 8 * YYYY\n    var yyyy8 = yyyy.redIAdd(yyyy);\n    yyyy8 = yyyy8.redIAdd(yyyy8);\n    yyyy8 = yyyy8.redIAdd(yyyy8);\n\n    // X3 = T\n    nx = t;\n    // Y3 = M * (S - T) - 8 * YYYY\n    ny = m.redMul(s.redISub(t)).redISub(yyyy8);\n    // Z3 = 2*Y1\n    nz = this.y.redAdd(this.y);\n  } else {\n    // hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-0.html\n    //     #doubling-dbl-2009-l\n    // 2M + 5S + 13A\n\n    // A = X1^2\n    var a = this.x.redSqr();\n    // B = Y1^2\n    var b = this.y.redSqr();\n    // C = B^2\n    var c = b.redSqr();\n    // D = 2 * ((X1 + B)^2 - A - C)\n    var d = this.x.redAdd(b).redSqr().redISub(a).redISub(c);\n    d = d.redIAdd(d);\n    // E = 3 * A\n    var e = a.redAdd(a).redIAdd(a);\n    // F = E^2\n    var f = e.redSqr();\n\n    // 8 * C\n    var c8 = c.redIAdd(c);\n    c8 = c8.redIAdd(c8);\n    c8 = c8.redIAdd(c8);\n\n    // X3 = F - 2 * D\n    nx = f.redISub(d).redISub(d);\n    // Y3 = E * (D - X3) - 8 * C\n    ny = e.redMul(d.redISub(nx)).redISub(c8);\n    // Z3 = 2 * Y1 * Z1\n    nz = this.y.redMul(this.z);\n    nz = nz.redIAdd(nz);\n  }\n\n  return this.curve.jpoint(nx, ny, nz);\n};\n\nJPoint.prototype._threeDbl = function _threeDbl() {\n  var nx;\n  var ny;\n  var nz;\n  // Z = 1\n  if (this.zOne) {\n    // hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-3.html\n    //     #doubling-mdbl-2007-bl\n    // 1M + 5S + 15A\n\n    // XX = X1^2\n    var xx = this.x.redSqr();\n    // YY = Y1^2\n    var yy = this.y.redSqr();\n    // YYYY = YY^2\n    var yyyy = yy.redSqr();\n    // S = 2 * ((X1 + YY)^2 - XX - YYYY)\n    var s = this.x.redAdd(yy).redSqr().redISub(xx).redISub(yyyy);\n    s = s.redIAdd(s);\n    // M = 3 * XX + a\n    var m = xx.redAdd(xx).redIAdd(xx).redIAdd(this.curve.a);\n    // T = M^2 - 2 * S\n    var t = m.redSqr().redISub(s).redISub(s);\n    // X3 = T\n    nx = t;\n    // Y3 = M * (S - T) - 8 * YYYY\n    var yyyy8 = yyyy.redIAdd(yyyy);\n    yyyy8 = yyyy8.redIAdd(yyyy8);\n    yyyy8 = yyyy8.redIAdd(yyyy8);\n    ny = m.redMul(s.redISub(t)).redISub(yyyy8);\n    // Z3 = 2 * Y1\n    nz = this.y.redAdd(this.y);\n  } else {\n    // hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-3.html#doubling-dbl-2001-b\n    // 3M + 5S\n\n    // delta = Z1^2\n    var delta = this.z.redSqr();\n    // gamma = Y1^2\n    var gamma = this.y.redSqr();\n    // beta = X1 * gamma\n    var beta = this.x.redMul(gamma);\n    // alpha = 3 * (X1 - delta) * (X1 + delta)\n    var alpha = this.x.redSub(delta).redMul(this.x.redAdd(delta));\n    alpha = alpha.redAdd(alpha).redIAdd(alpha);\n    // X3 = alpha^2 - 8 * beta\n    var beta4 = beta.redIAdd(beta);\n    beta4 = beta4.redIAdd(beta4);\n    var beta8 = beta4.redAdd(beta4);\n    nx = alpha.redSqr().redISub(beta8);\n    // Z3 = (Y1 + Z1)^2 - gamma - delta\n    nz = this.y.redAdd(this.z).redSqr().redISub(gamma).redISub(delta);\n    // Y3 = alpha * (4 * beta - X3) - 8 * gamma^2\n    var ggamma8 = gamma.redSqr();\n    ggamma8 = ggamma8.redIAdd(ggamma8);\n    ggamma8 = ggamma8.redIAdd(ggamma8);\n    ggamma8 = ggamma8.redIAdd(ggamma8);\n    ny = alpha.redMul(beta4.redISub(nx)).redISub(ggamma8);\n  }\n\n  return this.curve.jpoint(nx, ny, nz);\n};\n\nJPoint.prototype._dbl = function _dbl() {\n  var a = this.curve.a;\n\n  // 4M + 6S + 10A\n  var jx = this.x;\n  var jy = this.y;\n  var jz = this.z;\n  var jz4 = jz.redSqr().redSqr();\n\n  var jx2 = jx.redSqr();\n  var jy2 = jy.redSqr();\n\n  var c = jx2.redAdd(jx2).redIAdd(jx2).redIAdd(a.redMul(jz4));\n\n  var jxd4 = jx.redAdd(jx);\n  jxd4 = jxd4.redIAdd(jxd4);\n  var t1 = jxd4.redMul(jy2);\n  var nx = c.redSqr().redISub(t1.redAdd(t1));\n  var t2 = t1.redISub(nx);\n\n  var jyd8 = jy2.redSqr();\n  jyd8 = jyd8.redIAdd(jyd8);\n  jyd8 = jyd8.redIAdd(jyd8);\n  jyd8 = jyd8.redIAdd(jyd8);\n  var ny = c.redMul(t2).redISub(jyd8);\n  var nz = jy.redAdd(jy).redMul(jz);\n\n  return this.curve.jpoint(nx, ny, nz);\n};\n\nJPoint.prototype.trpl = function trpl() {\n  if (!this.curve.zeroA) return this.dbl().add(this);\n\n  // hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-0.html#tripling-tpl-2007-bl\n  // 5M + 10S + ...\n\n  // XX = X1^2\n  var xx = this.x.redSqr();\n  // YY = Y1^2\n  var yy = this.y.redSqr();\n  // ZZ = Z1^2\n  var zz = this.z.redSqr();\n  // YYYY = YY^2\n  var yyyy = yy.redSqr();\n  // M = 3 * XX + a * ZZ2; a = 0\n  var m = xx.redAdd(xx).redIAdd(xx);\n  // MM = M^2\n  var mm = m.redSqr();\n  // E = 6 * ((X1 + YY)^2 - XX - YYYY) - MM\n  var e = this.x.redAdd(yy).redSqr().redISub(xx).redISub(yyyy);\n  e = e.redIAdd(e);\n  e = e.redAdd(e).redIAdd(e);\n  e = e.redISub(mm);\n  // EE = E^2\n  var ee = e.redSqr();\n  // T = 16*YYYY\n  var t = yyyy.redIAdd(yyyy);\n  t = t.redIAdd(t);\n  t = t.redIAdd(t);\n  t = t.redIAdd(t);\n  // U = (M + E)^2 - MM - EE - T\n  var u = m.redIAdd(e).redSqr().redISub(mm).redISub(ee).redISub(t);\n  // X3 = 4 * (X1 * EE - 4 * YY * U)\n  var yyu4 = yy.redMul(u);\n  yyu4 = yyu4.redIAdd(yyu4);\n  yyu4 = yyu4.redIAdd(yyu4);\n  var nx = this.x.redMul(ee).redISub(yyu4);\n  nx = nx.redIAdd(nx);\n  nx = nx.redIAdd(nx);\n  // Y3 = 8 * Y1 * (U * (T - U) - E * EE)\n  var ny = this.y.redMul(u.redMul(t.redISub(u)).redISub(e.redMul(ee)));\n  ny = ny.redIAdd(ny);\n  ny = ny.redIAdd(ny);\n  ny = ny.redIAdd(ny);\n  // Z3 = (Z1 + E)^2 - ZZ - EE\n  var nz = this.z.redAdd(e).redSqr().redISub(zz).redISub(ee);\n\n  return this.curve.jpoint(nx, ny, nz);\n};\n\nJPoint.prototype.mul = function mul(k, kbase) {\n  k = new BN(k, kbase);\n\n  return this.curve._wnafMul(this, k);\n};\n\nJPoint.prototype.eq = function eq(p) {\n  if (p.type === 'affine') return this.eq(p.toJ());\n\n  if (this === p) return true;\n\n  // x1 * z2^2 == x2 * z1^2\n  var z2 = this.z.redSqr();\n  var pz2 = p.z.redSqr();\n  if (this.x.redMul(pz2).redISub(p.x.redMul(z2)).cmpn(0) !== 0) return false;\n\n  // y1 * z2^3 == y2 * z1^3\n  var z3 = z2.redMul(this.z);\n  var pz3 = pz2.redMul(p.z);\n  return this.y.redMul(pz3).redISub(p.y.redMul(z3)).cmpn(0) === 0;\n};\n\nJPoint.prototype.eqXToP = function eqXToP(x) {\n  var zs = this.z.redSqr();\n  var rx = x.toRed(this.curve.red).redMul(zs);\n  if (this.x.cmp(rx) === 0) return true;\n\n  var xc = x.clone();\n  var t = this.curve.redN.redMul(zs);\n  for (;;) {\n    xc.iadd(this.curve.n);\n    if (xc.cmp(this.curve.p) >= 0) return false;\n\n    rx.redIAdd(t);\n    if (this.x.cmp(rx) === 0) return true;\n  }\n  return false;\n};\n\nJPoint.prototype.inspect = function inspect() {\n  if (this.isInfinity()) return '<EC JPoint Infinity>';\n  return '<EC JPoint x: ' + this.x.toString(16, 2) + ' y: ' + this.y.toString(16, 2) + ' z: ' + this.z.toString(16, 2) + '>';\n};\n\nJPoint.prototype.isInfinity = function isInfinity() {\n  // XXX This code assumes that zero is always zero in red\n  return this.z.cmpn(0) === 0;\n};\n\n/***/ }),\n/* 46 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar curve = __webpack_require__(11);\nvar BN = __webpack_require__(1);\nvar inherits = __webpack_require__(3);\nvar Base = curve.base;\n\nvar elliptic = __webpack_require__(0);\nvar utils = elliptic.utils;\n\nfunction MontCurve(conf) {\n  Base.call(this, 'mont', conf);\n\n  this.a = new BN(conf.a, 16).toRed(this.red);\n  this.b = new BN(conf.b, 16).toRed(this.red);\n  this.i4 = new BN(4).toRed(this.red).redInvm();\n  this.two = new BN(2).toRed(this.red);\n  this.a24 = this.i4.redMul(this.a.redAdd(this.two));\n}\ninherits(MontCurve, Base);\nmodule.exports = MontCurve;\n\nMontCurve.prototype.validate = function validate(point) {\n  var x = point.normalize().x;\n  var x2 = x.redSqr();\n  var rhs = x2.redMul(x).redAdd(x2.redMul(this.a)).redAdd(x);\n  var y = rhs.redSqrt();\n\n  return y.redSqr().cmp(rhs) === 0;\n};\n\nfunction Point(curve, x, z) {\n  Base.BasePoint.call(this, curve, 'projective');\n  if (x === null && z === null) {\n    this.x = this.curve.one;\n    this.z = this.curve.zero;\n  } else {\n    this.x = new BN(x, 16);\n    this.z = new BN(z, 16);\n    if (!this.x.red) this.x = this.x.toRed(this.curve.red);\n    if (!this.z.red) this.z = this.z.toRed(this.curve.red);\n  }\n}\ninherits(Point, Base.BasePoint);\n\nMontCurve.prototype.decodePoint = function decodePoint(bytes, enc) {\n  return this.point(utils.toArray(bytes, enc), 1);\n};\n\nMontCurve.prototype.point = function point(x, z) {\n  return new Point(this, x, z);\n};\n\nMontCurve.prototype.pointFromJSON = function pointFromJSON(obj) {\n  return Point.fromJSON(this, obj);\n};\n\nPoint.prototype.precompute = function precompute() {\n  // No-op\n};\n\nPoint.prototype._encode = function _encode() {\n  return this.getX().toArray('be', this.curve.p.byteLength());\n};\n\nPoint.fromJSON = function fromJSON(curve, obj) {\n  return new Point(curve, obj[0], obj[1] || curve.one);\n};\n\nPoint.prototype.inspect = function inspect() {\n  if (this.isInfinity()) return '<EC Point Infinity>';\n  return '<EC Point x: ' + this.x.fromRed().toString(16, 2) + ' z: ' + this.z.fromRed().toString(16, 2) + '>';\n};\n\nPoint.prototype.isInfinity = function isInfinity() {\n  // XXX This code assumes that zero is always zero in red\n  return this.z.cmpn(0) === 0;\n};\n\nPoint.prototype.dbl = function dbl() {\n  // http://hyperelliptic.org/EFD/g1p/auto-montgom-xz.html#doubling-dbl-1987-m-3\n  // 2M + 2S + 4A\n\n  // A = X1 + Z1\n  var a = this.x.redAdd(this.z);\n  // AA = A^2\n  var aa = a.redSqr();\n  // B = X1 - Z1\n  var b = this.x.redSub(this.z);\n  // BB = B^2\n  var bb = b.redSqr();\n  // C = AA - BB\n  var c = aa.redSub(bb);\n  // X3 = AA * BB\n  var nx = aa.redMul(bb);\n  // Z3 = C * (BB + A24 * C)\n  var nz = c.redMul(bb.redAdd(this.curve.a24.redMul(c)));\n  return this.curve.point(nx, nz);\n};\n\nPoint.prototype.add = function add() {\n  throw new Error('Not supported on Montgomery curve');\n};\n\nPoint.prototype.diffAdd = function diffAdd(p, diff) {\n  // http://hyperelliptic.org/EFD/g1p/auto-montgom-xz.html#diffadd-dadd-1987-m-3\n  // 4M + 2S + 6A\n\n  // A = X2 + Z2\n  var a = this.x.redAdd(this.z);\n  // B = X2 - Z2\n  var b = this.x.redSub(this.z);\n  // C = X3 + Z3\n  var c = p.x.redAdd(p.z);\n  // D = X3 - Z3\n  var d = p.x.redSub(p.z);\n  // DA = D * A\n  var da = d.redMul(a);\n  // CB = C * B\n  var cb = c.redMul(b);\n  // X5 = Z1 * (DA + CB)^2\n  var nx = diff.z.redMul(da.redAdd(cb).redSqr());\n  // Z5 = X1 * (DA - CB)^2\n  var nz = diff.x.redMul(da.redISub(cb).redSqr());\n  return this.curve.point(nx, nz);\n};\n\nPoint.prototype.mul = function mul(k) {\n  var t = k.clone();\n  var a = this; // (N / 2) * Q + Q\n  var b = this.curve.point(null, null); // (N / 2) * Q\n  var c = this; // Q\n\n  for (var bits = []; t.cmpn(0) !== 0; t.iushrn(1)) {\n    bits.push(t.andln(1));\n  }for (var i = bits.length - 1; i >= 0; i--) {\n    if (bits[i] === 0) {\n      // N * Q + Q = ((N / 2) * Q + Q)) + (N / 2) * Q\n      a = a.diffAdd(b, c);\n      // N * Q = 2 * ((N / 2) * Q + Q))\n      b = b.dbl();\n    } else {\n      // N * Q = ((N / 2) * Q + Q) + ((N / 2) * Q)\n      b = a.diffAdd(b, c);\n      // N * Q + Q = 2 * ((N / 2) * Q + Q)\n      a = a.dbl();\n    }\n  }\n  return b;\n};\n\nPoint.prototype.mulAdd = function mulAdd() {\n  throw new Error('Not supported on Montgomery curve');\n};\n\nPoint.prototype.jumlAdd = function jumlAdd() {\n  throw new Error('Not supported on Montgomery curve');\n};\n\nPoint.prototype.eq = function eq(other) {\n  return this.getX().cmp(other.getX()) === 0;\n};\n\nPoint.prototype.normalize = function normalize() {\n  this.x = this.x.redMul(this.z.redInvm());\n  this.z = this.curve.one;\n  return this;\n};\n\nPoint.prototype.getX = function getX() {\n  // Normalize coordinates\n  this.normalize();\n\n  return this.x.fromRed();\n};\n\n/***/ }),\n/* 47 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar curve = __webpack_require__(11);\nvar elliptic = __webpack_require__(0);\nvar BN = __webpack_require__(1);\nvar inherits = __webpack_require__(3);\nvar Base = curve.base;\n\nvar assert = elliptic.utils.assert;\n\nfunction EdwardsCurve(conf) {\n  // NOTE: Important as we are creating point in Base.call()\n  this.twisted = (conf.a | 0) !== 1;\n  this.mOneA = this.twisted && (conf.a | 0) === -1;\n  this.extended = this.mOneA;\n\n  Base.call(this, 'edwards', conf);\n\n  this.a = new BN(conf.a, 16).umod(this.red.m);\n  this.a = this.a.toRed(this.red);\n  this.c = new BN(conf.c, 16).toRed(this.red);\n  this.c2 = this.c.redSqr();\n  this.d = new BN(conf.d, 16).toRed(this.red);\n  this.dd = this.d.redAdd(this.d);\n\n  assert(!this.twisted || this.c.fromRed().cmpn(1) === 0);\n  this.oneC = (conf.c | 0) === 1;\n}\ninherits(EdwardsCurve, Base);\nmodule.exports = EdwardsCurve;\n\nEdwardsCurve.prototype._mulA = function _mulA(num) {\n  if (this.mOneA) return num.redNeg();else return this.a.redMul(num);\n};\n\nEdwardsCurve.prototype._mulC = function _mulC(num) {\n  if (this.oneC) return num;else return this.c.redMul(num);\n};\n\n// Just for compatibility with Short curve\nEdwardsCurve.prototype.jpoint = function jpoint(x, y, z, t) {\n  return this.point(x, y, z, t);\n};\n\nEdwardsCurve.prototype.pointFromX = function pointFromX(x, odd) {\n  x = new BN(x, 16);\n  if (!x.red) x = x.toRed(this.red);\n\n  var x2 = x.redSqr();\n  var rhs = this.c2.redSub(this.a.redMul(x2));\n  var lhs = this.one.redSub(this.c2.redMul(this.d).redMul(x2));\n\n  var y2 = rhs.redMul(lhs.redInvm());\n  var y = y2.redSqrt();\n  if (y.redSqr().redSub(y2).cmp(this.zero) !== 0) throw new Error('invalid point');\n\n  var isOdd = y.fromRed().isOdd();\n  if (odd && !isOdd || !odd && isOdd) y = y.redNeg();\n\n  return this.point(x, y);\n};\n\nEdwardsCurve.prototype.pointFromY = function pointFromY(y, odd) {\n  y = new BN(y, 16);\n  if (!y.red) y = y.toRed(this.red);\n\n  // x^2 = (y^2 - 1) / (d y^2 + 1)\n  var y2 = y.redSqr();\n  var lhs = y2.redSub(this.one);\n  var rhs = y2.redMul(this.d).redAdd(this.one);\n  var x2 = lhs.redMul(rhs.redInvm());\n\n  if (x2.cmp(this.zero) === 0) {\n    if (odd) throw new Error('invalid point');else return this.point(this.zero, y);\n  }\n\n  var x = x2.redSqrt();\n  if (x.redSqr().redSub(x2).cmp(this.zero) !== 0) throw new Error('invalid point');\n\n  if (x.isOdd() !== odd) x = x.redNeg();\n\n  return this.point(x, y);\n};\n\nEdwardsCurve.prototype.validate = function validate(point) {\n  if (point.isInfinity()) return true;\n\n  // Curve: A * X^2 + Y^2 = C^2 * (1 + D * X^2 * Y^2)\n  point.normalize();\n\n  var x2 = point.x.redSqr();\n  var y2 = point.y.redSqr();\n  var lhs = x2.redMul(this.a).redAdd(y2);\n  var rhs = this.c2.redMul(this.one.redAdd(this.d.redMul(x2).redMul(y2)));\n\n  return lhs.cmp(rhs) === 0;\n};\n\nfunction Point(curve, x, y, z, t) {\n  Base.BasePoint.call(this, curve, 'projective');\n  if (x === null && y === null && z === null) {\n    this.x = this.curve.zero;\n    this.y = this.curve.one;\n    this.z = this.curve.one;\n    this.t = this.curve.zero;\n    this.zOne = true;\n  } else {\n    this.x = new BN(x, 16);\n    this.y = new BN(y, 16);\n    this.z = z ? new BN(z, 16) : this.curve.one;\n    this.t = t && new BN(t, 16);\n    if (!this.x.red) this.x = this.x.toRed(this.curve.red);\n    if (!this.y.red) this.y = this.y.toRed(this.curve.red);\n    if (!this.z.red) this.z = this.z.toRed(this.curve.red);\n    if (this.t && !this.t.red) this.t = this.t.toRed(this.curve.red);\n    this.zOne = this.z === this.curve.one;\n\n    // Use extended coordinates\n    if (this.curve.extended && !this.t) {\n      this.t = this.x.redMul(this.y);\n      if (!this.zOne) this.t = this.t.redMul(this.z.redInvm());\n    }\n  }\n}\ninherits(Point, Base.BasePoint);\n\nEdwardsCurve.prototype.pointFromJSON = function pointFromJSON(obj) {\n  return Point.fromJSON(this, obj);\n};\n\nEdwardsCurve.prototype.point = function point(x, y, z, t) {\n  return new Point(this, x, y, z, t);\n};\n\nPoint.fromJSON = function fromJSON(curve, obj) {\n  return new Point(curve, obj[0], obj[1], obj[2]);\n};\n\nPoint.prototype.inspect = function inspect() {\n  if (this.isInfinity()) return '<EC Point Infinity>';\n  return '<EC Point x: ' + this.x.fromRed().toString(16, 2) + ' y: ' + this.y.fromRed().toString(16, 2) + ' z: ' + this.z.fromRed().toString(16, 2) + '>';\n};\n\nPoint.prototype.isInfinity = function isInfinity() {\n  // XXX This code assumes that zero is always zero in red\n  return this.x.cmpn(0) === 0 && this.y.cmp(this.z) === 0;\n};\n\nPoint.prototype._extDbl = function _extDbl() {\n  // hyperelliptic.org/EFD/g1p/auto-twisted-extended-1.html\n  //     #doubling-dbl-2008-hwcd\n  // 4M + 4S\n\n  // A = X1^2\n  var a = this.x.redSqr();\n  // B = Y1^2\n  var b = this.y.redSqr();\n  // C = 2 * Z1^2\n  var c = this.z.redSqr();\n  c = c.redIAdd(c);\n  // D = a * A\n  var d = this.curve._mulA(a);\n  // E = (X1 + Y1)^2 - A - B\n  var e = this.x.redAdd(this.y).redSqr().redISub(a).redISub(b);\n  // G = D + B\n  var g = d.redAdd(b);\n  // F = G - C\n  var f = g.redSub(c);\n  // H = D - B\n  var h = d.redSub(b);\n  // X3 = E * F\n  var nx = e.redMul(f);\n  // Y3 = G * H\n  var ny = g.redMul(h);\n  // T3 = E * H\n  var nt = e.redMul(h);\n  // Z3 = F * G\n  var nz = f.redMul(g);\n  return this.curve.point(nx, ny, nz, nt);\n};\n\nPoint.prototype._projDbl = function _projDbl() {\n  // hyperelliptic.org/EFD/g1p/auto-twisted-projective.html\n  //     #doubling-dbl-2008-bbjlp\n  //     #doubling-dbl-2007-bl\n  // and others\n  // Generally 3M + 4S or 2M + 4S\n\n  // B = (X1 + Y1)^2\n  var b = this.x.redAdd(this.y).redSqr();\n  // C = X1^2\n  var c = this.x.redSqr();\n  // D = Y1^2\n  var d = this.y.redSqr();\n\n  var nx;\n  var ny;\n  var nz;\n  if (this.curve.twisted) {\n    // E = a * C\n    var e = this.curve._mulA(c);\n    // F = E + D\n    var f = e.redAdd(d);\n    if (this.zOne) {\n      // X3 = (B - C - D) * (F - 2)\n      nx = b.redSub(c).redSub(d).redMul(f.redSub(this.curve.two));\n      // Y3 = F * (E - D)\n      ny = f.redMul(e.redSub(d));\n      // Z3 = F^2 - 2 * F\n      nz = f.redSqr().redSub(f).redSub(f);\n    } else {\n      // H = Z1^2\n      var h = this.z.redSqr();\n      // J = F - 2 * H\n      var j = f.redSub(h).redISub(h);\n      // X3 = (B-C-D)*J\n      nx = b.redSub(c).redISub(d).redMul(j);\n      // Y3 = F * (E - D)\n      ny = f.redMul(e.redSub(d));\n      // Z3 = F * J\n      nz = f.redMul(j);\n    }\n  } else {\n    // E = C + D\n    var e = c.redAdd(d);\n    // H = (c * Z1)^2\n    var h = this.curve._mulC(this.c.redMul(this.z)).redSqr();\n    // J = E - 2 * H\n    var j = e.redSub(h).redSub(h);\n    // X3 = c * (B - E) * J\n    nx = this.curve._mulC(b.redISub(e)).redMul(j);\n    // Y3 = c * E * (C - D)\n    ny = this.curve._mulC(e).redMul(c.redISub(d));\n    // Z3 = E * J\n    nz = e.redMul(j);\n  }\n  return this.curve.point(nx, ny, nz);\n};\n\nPoint.prototype.dbl = function dbl() {\n  if (this.isInfinity()) return this;\n\n  // Double in extended coordinates\n  if (this.curve.extended) return this._extDbl();else return this._projDbl();\n};\n\nPoint.prototype._extAdd = function _extAdd(p) {\n  // hyperelliptic.org/EFD/g1p/auto-twisted-extended-1.html\n  //     #addition-add-2008-hwcd-3\n  // 8M\n\n  // A = (Y1 - X1) * (Y2 - X2)\n  var a = this.y.redSub(this.x).redMul(p.y.redSub(p.x));\n  // B = (Y1 + X1) * (Y2 + X2)\n  var b = this.y.redAdd(this.x).redMul(p.y.redAdd(p.x));\n  // C = T1 * k * T2\n  var c = this.t.redMul(this.curve.dd).redMul(p.t);\n  // D = Z1 * 2 * Z2\n  var d = this.z.redMul(p.z.redAdd(p.z));\n  // E = B - A\n  var e = b.redSub(a);\n  // F = D - C\n  var f = d.redSub(c);\n  // G = D + C\n  var g = d.redAdd(c);\n  // H = B + A\n  var h = b.redAdd(a);\n  // X3 = E * F\n  var nx = e.redMul(f);\n  // Y3 = G * H\n  var ny = g.redMul(h);\n  // T3 = E * H\n  var nt = e.redMul(h);\n  // Z3 = F * G\n  var nz = f.redMul(g);\n  return this.curve.point(nx, ny, nz, nt);\n};\n\nPoint.prototype._projAdd = function _projAdd(p) {\n  // hyperelliptic.org/EFD/g1p/auto-twisted-projective.html\n  //     #addition-add-2008-bbjlp\n  //     #addition-add-2007-bl\n  // 10M + 1S\n\n  // A = Z1 * Z2\n  var a = this.z.redMul(p.z);\n  // B = A^2\n  var b = a.redSqr();\n  // C = X1 * X2\n  var c = this.x.redMul(p.x);\n  // D = Y1 * Y2\n  var d = this.y.redMul(p.y);\n  // E = d * C * D\n  var e = this.curve.d.redMul(c).redMul(d);\n  // F = B - E\n  var f = b.redSub(e);\n  // G = B + E\n  var g = b.redAdd(e);\n  // X3 = A * F * ((X1 + Y1) * (X2 + Y2) - C - D)\n  var tmp = this.x.redAdd(this.y).redMul(p.x.redAdd(p.y)).redISub(c).redISub(d);\n  var nx = a.redMul(f).redMul(tmp);\n  var ny;\n  var nz;\n  if (this.curve.twisted) {\n    // Y3 = A * G * (D - a * C)\n    ny = a.redMul(g).redMul(d.redSub(this.curve._mulA(c)));\n    // Z3 = F * G\n    nz = f.redMul(g);\n  } else {\n    // Y3 = A * G * (D - C)\n    ny = a.redMul(g).redMul(d.redSub(c));\n    // Z3 = c * F * G\n    nz = this.curve._mulC(f).redMul(g);\n  }\n  return this.curve.point(nx, ny, nz);\n};\n\nPoint.prototype.add = function add(p) {\n  if (this.isInfinity()) return p;\n  if (p.isInfinity()) return this;\n\n  if (this.curve.extended) return this._extAdd(p);else return this._projAdd(p);\n};\n\nPoint.prototype.mul = function mul(k) {\n  if (this._hasDoubles(k)) return this.curve._fixedNafMul(this, k);else return this.curve._wnafMul(this, k);\n};\n\nPoint.prototype.mulAdd = function mulAdd(k1, p, k2) {\n  return this.curve._wnafMulAdd(1, [this, p], [k1, k2], 2, false);\n};\n\nPoint.prototype.jmulAdd = function jmulAdd(k1, p, k2) {\n  return this.curve._wnafMulAdd(1, [this, p], [k1, k2], 2, true);\n};\n\nPoint.prototype.normalize = function normalize() {\n  if (this.zOne) return this;\n\n  // Normalize coordinates\n  var zi = this.z.redInvm();\n  this.x = this.x.redMul(zi);\n  this.y = this.y.redMul(zi);\n  if (this.t) this.t = this.t.redMul(zi);\n  this.z = this.curve.one;\n  this.zOne = true;\n  return this;\n};\n\nPoint.prototype.neg = function neg() {\n  return this.curve.point(this.x.redNeg(), this.y, this.z, this.t && this.t.redNeg());\n};\n\nPoint.prototype.getX = function getX() {\n  this.normalize();\n  return this.x.fromRed();\n};\n\nPoint.prototype.getY = function getY() {\n  this.normalize();\n  return this.y.fromRed();\n};\n\nPoint.prototype.eq = function eq(other) {\n  return this === other || this.getX().cmp(other.getX()) === 0 && this.getY().cmp(other.getY()) === 0;\n};\n\nPoint.prototype.eqXToP = function eqXToP(x) {\n  var rx = x.toRed(this.curve.red).redMul(this.z);\n  if (this.x.cmp(rx) === 0) return true;\n\n  var xc = x.clone();\n  var t = this.curve.redN.redMul(this.z);\n  for (;;) {\n    xc.iadd(this.curve.n);\n    if (xc.cmp(this.curve.p) >= 0) return false;\n\n    rx.redIAdd(t);\n    if (this.x.cmp(rx) === 0) return true;\n  }\n  return false;\n};\n\n// Compatibility with BaseCurve\nPoint.prototype.toP = Point.prototype.normalize;\nPoint.prototype.mixedAdd = Point.prototype.add;\n\n/***/ }),\n/* 48 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar curves = exports;\n\nvar hash = __webpack_require__(15);\nvar elliptic = __webpack_require__(0);\n\nvar assert = elliptic.utils.assert;\n\nfunction PresetCurve(options) {\n  if (options.type === 'short') this.curve = new elliptic.curve.short(options);else if (options.type === 'edwards') this.curve = new elliptic.curve.edwards(options);else this.curve = new elliptic.curve.mont(options);\n  this.g = this.curve.g;\n  this.n = this.curve.n;\n  this.hash = options.hash;\n\n  assert(this.g.validate(), 'Invalid curve');\n  assert(this.g.mul(this.n).isInfinity(), 'Invalid curve, G*N != O');\n}\ncurves.PresetCurve = PresetCurve;\n\nfunction defineCurve(name, options) {\n  Object.defineProperty(curves, name, {\n    configurable: true,\n    enumerable: true,\n    get: function get() {\n      var curve = new PresetCurve(options);\n      Object.defineProperty(curves, name, {\n        configurable: true,\n        enumerable: true,\n        value: curve\n      });\n      return curve;\n    }\n  });\n}\n\ndefineCurve('p192', {\n  type: 'short',\n  prime: 'p192',\n  p: 'ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff',\n  a: 'ffffffff ffffffff ffffffff fffffffe ffffffff fffffffc',\n  b: '64210519 e59c80e7 0fa7e9ab 72243049 feb8deec c146b9b1',\n  n: 'ffffffff ffffffff ffffffff 99def836 146bc9b1 b4d22831',\n  hash: hash.sha256,\n  gRed: false,\n  g: ['188da80e b03090f6 7cbf20eb 43a18800 f4ff0afd 82ff1012', '07192b95 ffc8da78 631011ed 6b24cdd5 73f977a1 1e794811']\n});\n\ndefineCurve('p224', {\n  type: 'short',\n  prime: 'p224',\n  p: 'ffffffff ffffffff ffffffff ffffffff 00000000 00000000 00000001',\n  a: 'ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff fffffffe',\n  b: 'b4050a85 0c04b3ab f5413256 5044b0b7 d7bfd8ba 270b3943 2355ffb4',\n  n: 'ffffffff ffffffff ffffffff ffff16a2 e0b8f03e 13dd2945 5c5c2a3d',\n  hash: hash.sha256,\n  gRed: false,\n  g: ['b70e0cbd 6bb4bf7f 321390b9 4a03c1d3 56c21122 343280d6 115c1d21', 'bd376388 b5f723fb 4c22dfe6 cd4375a0 5a074764 44d58199 85007e34']\n});\n\ndefineCurve('p256', {\n  type: 'short',\n  prime: null,\n  p: 'ffffffff 00000001 00000000 00000000 00000000 ffffffff ffffffff ffffffff',\n  a: 'ffffffff 00000001 00000000 00000000 00000000 ffffffff ffffffff fffffffc',\n  b: '5ac635d8 aa3a93e7 b3ebbd55 769886bc 651d06b0 cc53b0f6 3bce3c3e 27d2604b',\n  n: 'ffffffff 00000000 ffffffff ffffffff bce6faad a7179e84 f3b9cac2 fc632551',\n  hash: hash.sha256,\n  gRed: false,\n  g: ['6b17d1f2 e12c4247 f8bce6e5 63a440f2 77037d81 2deb33a0 f4a13945 d898c296', '4fe342e2 fe1a7f9b 8ee7eb4a 7c0f9e16 2bce3357 6b315ece cbb64068 37bf51f5']\n});\n\ndefineCurve('p384', {\n  type: 'short',\n  prime: null,\n  p: 'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ' + 'fffffffe ffffffff 00000000 00000000 ffffffff',\n  a: 'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ' + 'fffffffe ffffffff 00000000 00000000 fffffffc',\n  b: 'b3312fa7 e23ee7e4 988e056b e3f82d19 181d9c6e fe814112 0314088f ' + '5013875a c656398d 8a2ed19d 2a85c8ed d3ec2aef',\n  n: 'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff c7634d81 ' + 'f4372ddf 581a0db2 48b0a77a ecec196a ccc52973',\n  hash: hash.sha384,\n  gRed: false,\n  g: ['aa87ca22 be8b0537 8eb1c71e f320ad74 6e1d3b62 8ba79b98 59f741e0 82542a38 ' + '5502f25d bf55296c 3a545e38 72760ab7', '3617de4a 96262c6f 5d9e98bf 9292dc29 f8f41dbd 289a147c e9da3113 b5f0b8c0 ' + '0a60b1ce 1d7e819d 7a431d7c 90ea0e5f']\n});\n\ndefineCurve('p521', {\n  type: 'short',\n  prime: null,\n  p: '000001ff ffffffff ffffffff ffffffff ffffffff ffffffff ' + 'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ' + 'ffffffff ffffffff ffffffff ffffffff ffffffff',\n  a: '000001ff ffffffff ffffffff ffffffff ffffffff ffffffff ' + 'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ' + 'ffffffff ffffffff ffffffff ffffffff fffffffc',\n  b: '00000051 953eb961 8e1c9a1f 929a21a0 b68540ee a2da725b ' + '99b315f3 b8b48991 8ef109e1 56193951 ec7e937b 1652c0bd ' + '3bb1bf07 3573df88 3d2c34f1 ef451fd4 6b503f00',\n  n: '000001ff ffffffff ffffffff ffffffff ffffffff ffffffff ' + 'ffffffff ffffffff fffffffa 51868783 bf2f966b 7fcc0148 ' + 'f709a5d0 3bb5c9b8 899c47ae bb6fb71e 91386409',\n  hash: hash.sha512,\n  gRed: false,\n  g: ['000000c6 858e06b7 0404e9cd 9e3ecb66 2395b442 9c648139 ' + '053fb521 f828af60 6b4d3dba a14b5e77 efe75928 fe1dc127 ' + 'a2ffa8de 3348b3c1 856a429b f97e7e31 c2e5bd66', '00000118 39296a78 9a3bc004 5c8a5fb4 2c7d1bd9 98f54449 ' + '579b4468 17afbd17 273e662c 97ee7299 5ef42640 c550b901 ' + '3fad0761 353c7086 a272c240 88be9476 9fd16650']\n});\n\ndefineCurve('curve25519', {\n  type: 'mont',\n  prime: 'p25519',\n  p: '7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed',\n  a: '76d06',\n  b: '1',\n  n: '1000000000000000 0000000000000000 14def9dea2f79cd6 5812631a5cf5d3ed',\n  hash: hash.sha256,\n  gRed: false,\n  g: ['9']\n});\n\ndefineCurve('ed25519', {\n  type: 'edwards',\n  prime: 'p25519',\n  p: '7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed',\n  a: '-1',\n  c: '1',\n  // -121665 * (121666^(-1)) (mod P)\n  d: '52036cee2b6ffe73 8cc740797779e898 00700a4d4141d8ab 75eb4dca135978a3',\n  n: '1000000000000000 0000000000000000 14def9dea2f79cd6 5812631a5cf5d3ed',\n  hash: hash.sha256,\n  gRed: false,\n  g: ['216936d3cd6e53fec0a4e231fdd6dc5c692cc7609525a7b2c9562d608f25d51a',\n\n  // 4/5\n  '6666666666666666666666666666666666666666666666666666666666666658']\n});\n\nvar pre;\ntry {\n  pre = __webpack_require__(55);\n} catch (e) {\n  pre = undefined;\n}\n\ndefineCurve('secp256k1', {\n  type: 'short',\n  prime: 'k256',\n  p: 'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffe fffffc2f',\n  a: '0',\n  b: '7',\n  n: 'ffffffff ffffffff ffffffff fffffffe baaedce6 af48a03b bfd25e8c d0364141',\n  h: '1',\n  hash: hash.sha256,\n\n  // Precomputed endomorphism\n  beta: '7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee',\n  lambda: '5363ad4cc05c30e0a5261c028812645a122e22ea20816678df02967c1b23bd72',\n  basis: [{\n    a: '3086d221a7d46bcde86c90e49284eb15',\n    b: '-e4437ed6010e88286f547fa90abfe4c3'\n  }, {\n    a: '114ca50f7a8e2f3f657c1108d9d44cfd8',\n    b: '3086d221a7d46bcde86c90e49284eb15'\n  }],\n\n  gRed: false,\n  g: ['79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798', '483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8', pre]\n});\n\n/***/ }),\n/* 49 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nexports.sha1 = __webpack_require__(50);\nexports.sha224 = __webpack_require__(51);\nexports.sha256 = __webpack_require__(24);\nexports.sha384 = __webpack_require__(52);\nexports.sha512 = __webpack_require__(25);\n\n/***/ }),\n/* 50 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar utils = __webpack_require__(4);\nvar common = __webpack_require__(8);\nvar shaCommon = __webpack_require__(23);\n\nvar rotl32 = utils.rotl32;\nvar sum32 = utils.sum32;\nvar sum32_5 = utils.sum32_5;\nvar ft_1 = shaCommon.ft_1;\nvar BlockHash = common.BlockHash;\n\nvar sha1_K = [0x5A827999, 0x6ED9EBA1, 0x8F1BBCDC, 0xCA62C1D6];\n\nfunction SHA1() {\n  if (!(this instanceof SHA1)) return new SHA1();\n\n  BlockHash.call(this);\n  this.h = [0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0];\n  this.W = new Array(80);\n}\n\nutils.inherits(SHA1, BlockHash);\nmodule.exports = SHA1;\n\nSHA1.blockSize = 512;\nSHA1.outSize = 160;\nSHA1.hmacStrength = 80;\nSHA1.padLength = 64;\n\nSHA1.prototype._update = function _update(msg, start) {\n  var W = this.W;\n\n  for (var i = 0; i < 16; i++) {\n    W[i] = msg[start + i];\n  }for (; i < W.length; i++) {\n    W[i] = rotl32(W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16], 1);\n  }var a = this.h[0];\n  var b = this.h[1];\n  var c = this.h[2];\n  var d = this.h[3];\n  var e = this.h[4];\n\n  for (i = 0; i < W.length; i++) {\n    var s = ~~(i / 20);\n    var t = sum32_5(rotl32(a, 5), ft_1(s, b, c, d), e, W[i], sha1_K[s]);\n    e = d;\n    d = c;\n    c = rotl32(b, 30);\n    b = a;\n    a = t;\n  }\n\n  this.h[0] = sum32(this.h[0], a);\n  this.h[1] = sum32(this.h[1], b);\n  this.h[2] = sum32(this.h[2], c);\n  this.h[3] = sum32(this.h[3], d);\n  this.h[4] = sum32(this.h[4], e);\n};\n\nSHA1.prototype._digest = function digest(enc) {\n  if (enc === 'hex') return utils.toHex32(this.h, 'big');else return utils.split32(this.h, 'big');\n};\n\n/***/ }),\n/* 51 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar utils = __webpack_require__(4);\nvar SHA256 = __webpack_require__(24);\n\nfunction SHA224() {\n  if (!(this instanceof SHA224)) return new SHA224();\n\n  SHA256.call(this);\n  this.h = [0xc1059ed8, 0x367cd507, 0x3070dd17, 0xf70e5939, 0xffc00b31, 0x68581511, 0x64f98fa7, 0xbefa4fa4];\n}\nutils.inherits(SHA224, SHA256);\nmodule.exports = SHA224;\n\nSHA224.blockSize = 512;\nSHA224.outSize = 224;\nSHA224.hmacStrength = 192;\nSHA224.padLength = 64;\n\nSHA224.prototype._digest = function digest(enc) {\n  // Just truncate output\n  if (enc === 'hex') return utils.toHex32(this.h.slice(0, 7), 'big');else return utils.split32(this.h.slice(0, 7), 'big');\n};\n\n/***/ }),\n/* 52 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar utils = __webpack_require__(4);\n\nvar SHA512 = __webpack_require__(25);\n\nfunction SHA384() {\n  if (!(this instanceof SHA384)) return new SHA384();\n\n  SHA512.call(this);\n  this.h = [0xcbbb9d5d, 0xc1059ed8, 0x629a292a, 0x367cd507, 0x9159015a, 0x3070dd17, 0x152fecd8, 0xf70e5939, 0x67332667, 0xffc00b31, 0x8eb44a87, 0x68581511, 0xdb0c2e0d, 0x64f98fa7, 0x47b5481d, 0xbefa4fa4];\n}\nutils.inherits(SHA384, SHA512);\nmodule.exports = SHA384;\n\nSHA384.blockSize = 1024;\nSHA384.outSize = 384;\nSHA384.hmacStrength = 192;\nSHA384.padLength = 128;\n\nSHA384.prototype._digest = function digest(enc) {\n  if (enc === 'hex') return utils.toHex32(this.h.slice(0, 12), 'big');else return utils.split32(this.h.slice(0, 12), 'big');\n};\n\n/***/ }),\n/* 53 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar utils = __webpack_require__(4);\nvar common = __webpack_require__(8);\n\nvar rotl32 = utils.rotl32;\nvar sum32 = utils.sum32;\nvar sum32_3 = utils.sum32_3;\nvar sum32_4 = utils.sum32_4;\nvar BlockHash = common.BlockHash;\n\nfunction RIPEMD160() {\n  if (!(this instanceof RIPEMD160)) return new RIPEMD160();\n\n  BlockHash.call(this);\n\n  this.h = [0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0];\n  this.endian = 'little';\n}\nutils.inherits(RIPEMD160, BlockHash);\nexports.ripemd160 = RIPEMD160;\n\nRIPEMD160.blockSize = 512;\nRIPEMD160.outSize = 160;\nRIPEMD160.hmacStrength = 192;\nRIPEMD160.padLength = 64;\n\nRIPEMD160.prototype._update = function update(msg, start) {\n  var A = this.h[0];\n  var B = this.h[1];\n  var C = this.h[2];\n  var D = this.h[3];\n  var E = this.h[4];\n  var Ah = A;\n  var Bh = B;\n  var Ch = C;\n  var Dh = D;\n  var Eh = E;\n  for (var j = 0; j < 80; j++) {\n    var T = sum32(rotl32(sum32_4(A, f(j, B, C, D), msg[r[j] + start], K(j)), s[j]), E);\n    A = E;\n    E = D;\n    D = rotl32(C, 10);\n    C = B;\n    B = T;\n    T = sum32(rotl32(sum32_4(Ah, f(79 - j, Bh, Ch, Dh), msg[rh[j] + start], Kh(j)), sh[j]), Eh);\n    Ah = Eh;\n    Eh = Dh;\n    Dh = rotl32(Ch, 10);\n    Ch = Bh;\n    Bh = T;\n  }\n  T = sum32_3(this.h[1], C, Dh);\n  this.h[1] = sum32_3(this.h[2], D, Eh);\n  this.h[2] = sum32_3(this.h[3], E, Ah);\n  this.h[3] = sum32_3(this.h[4], A, Bh);\n  this.h[4] = sum32_3(this.h[0], B, Ch);\n  this.h[0] = T;\n};\n\nRIPEMD160.prototype._digest = function digest(enc) {\n  if (enc === 'hex') return utils.toHex32(this.h, 'little');else return utils.split32(this.h, 'little');\n};\n\nfunction f(j, x, y, z) {\n  if (j <= 15) return x ^ y ^ z;else if (j <= 31) return x & y | ~x & z;else if (j <= 47) return (x | ~y) ^ z;else if (j <= 63) return x & z | y & ~z;else return x ^ (y | ~z);\n}\n\nfunction K(j) {\n  if (j <= 15) return 0x00000000;else if (j <= 31) return 0x5a827999;else if (j <= 47) return 0x6ed9eba1;else if (j <= 63) return 0x8f1bbcdc;else return 0xa953fd4e;\n}\n\nfunction Kh(j) {\n  if (j <= 15) return 0x50a28be6;else if (j <= 31) return 0x5c4dd124;else if (j <= 47) return 0x6d703ef3;else if (j <= 63) return 0x7a6d76e9;else return 0x00000000;\n}\n\nvar r = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 7, 4, 13, 1, 10, 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8, 3, 10, 14, 4, 9, 15, 8, 1, 2, 7, 0, 6, 13, 11, 5, 12, 1, 9, 11, 10, 0, 8, 12, 4, 13, 3, 7, 15, 14, 5, 6, 2, 4, 0, 5, 9, 7, 12, 2, 10, 14, 1, 3, 8, 11, 6, 15, 13];\n\nvar rh = [5, 14, 7, 0, 9, 2, 11, 4, 13, 6, 15, 8, 1, 10, 3, 12, 6, 11, 3, 7, 0, 13, 5, 10, 14, 15, 8, 12, 4, 9, 1, 2, 15, 5, 1, 3, 7, 14, 6, 9, 11, 8, 12, 2, 10, 0, 4, 13, 8, 6, 4, 1, 3, 11, 15, 0, 5, 12, 2, 13, 9, 7, 10, 14, 12, 15, 10, 4, 1, 5, 8, 7, 6, 2, 13, 14, 0, 3, 9, 11];\n\nvar s = [11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8, 7, 6, 8, 13, 11, 9, 7, 15, 7, 12, 15, 9, 11, 7, 13, 12, 11, 13, 6, 7, 14, 9, 13, 15, 14, 8, 13, 6, 5, 12, 7, 5, 11, 12, 14, 15, 14, 15, 9, 8, 9, 14, 5, 6, 8, 6, 5, 12, 9, 15, 5, 11, 6, 8, 13, 12, 5, 12, 13, 14, 11, 8, 5, 6];\n\nvar sh = [8, 9, 9, 11, 13, 15, 15, 5, 7, 7, 8, 11, 14, 14, 12, 6, 9, 13, 15, 7, 12, 8, 9, 11, 7, 7, 12, 7, 6, 15, 13, 11, 9, 7, 15, 11, 8, 6, 6, 14, 12, 13, 5, 14, 13, 13, 7, 5, 15, 5, 8, 11, 14, 14, 6, 14, 6, 9, 12, 9, 12, 5, 15, 8, 8, 5, 12, 9, 12, 5, 14, 6, 8, 13, 6, 5, 15, 13, 11, 11];\n\n/***/ }),\n/* 54 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar utils = __webpack_require__(4);\nvar assert = __webpack_require__(6);\n\nfunction Hmac(hash, key, enc) {\n  if (!(this instanceof Hmac)) return new Hmac(hash, key, enc);\n  this.Hash = hash;\n  this.blockSize = hash.blockSize / 8;\n  this.outSize = hash.outSize / 8;\n  this.inner = null;\n  this.outer = null;\n\n  this._init(utils.toArray(key, enc));\n}\nmodule.exports = Hmac;\n\nHmac.prototype._init = function init(key) {\n  // Shorten key, if needed\n  if (key.length > this.blockSize) key = new this.Hash().update(key).digest();\n  assert(key.length <= this.blockSize);\n\n  // Add padding to key\n  for (var i = key.length; i < this.blockSize; i++) {\n    key.push(0);\n  }for (i = 0; i < key.length; i++) {\n    key[i] ^= 0x36;\n  }this.inner = new this.Hash().update(key);\n\n  // 0x36 ^ 0x5c = 0x6a\n  for (i = 0; i < key.length; i++) {\n    key[i] ^= 0x6a;\n  }this.outer = new this.Hash().update(key);\n};\n\nHmac.prototype.update = function update(msg, enc) {\n  this.inner.update(msg, enc);\n  return this;\n};\n\nHmac.prototype.digest = function digest(enc) {\n  this.outer.update(this.inner.digest());\n  return this.outer.digest(enc);\n};\n\n/***/ }),\n/* 55 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nmodule.exports = {\n  doubles: {\n    step: 4,\n    points: [['e60fce93b59e9ec53011aabc21c23e97b2a31369b87a5ae9c44ee89e2a6dec0a', 'f7e3507399e595929db99f34f57937101296891e44d23f0be1f32cce69616821'], ['8282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508', '11f8a8098557dfe45e8256e830b60ace62d613ac2f7b17bed31b6eaff6e26caf'], ['175e159f728b865a72f99cc6c6fc846de0b93833fd2222ed73fce5b551e5b739', 'd3506e0d9e3c79eba4ef97a51ff71f5eacb5955add24345c6efa6ffee9fed695'], ['363d90d447b00c9c99ceac05b6262ee053441c7e55552ffe526bad8f83ff4640', '4e273adfc732221953b445397f3363145b9a89008199ecb62003c7f3bee9de9'], ['8b4b5f165df3c2be8c6244b5b745638843e4a781a15bcd1b69f79a55dffdf80c', '4aad0a6f68d308b4b3fbd7813ab0da04f9e336546162ee56b3eff0c65fd4fd36'], ['723cbaa6e5db996d6bf771c00bd548c7b700dbffa6c0e77bcb6115925232fcda', '96e867b5595cc498a921137488824d6e2660a0653779494801dc069d9eb39f5f'], ['eebfa4d493bebf98ba5feec812c2d3b50947961237a919839a533eca0e7dd7fa', '5d9a8ca3970ef0f269ee7edaf178089d9ae4cdc3a711f712ddfd4fdae1de8999'], ['100f44da696e71672791d0a09b7bde459f1215a29b3c03bfefd7835b39a48db0', 'cdd9e13192a00b772ec8f3300c090666b7ff4a18ff5195ac0fbd5cd62bc65a09'], ['e1031be262c7ed1b1dc9227a4a04c017a77f8d4464f3b3852c8acde6e534fd2d', '9d7061928940405e6bb6a4176597535af292dd419e1ced79a44f18f29456a00d'], ['feea6cae46d55b530ac2839f143bd7ec5cf8b266a41d6af52d5e688d9094696d', 'e57c6b6c97dce1bab06e4e12bf3ecd5c981c8957cc41442d3155debf18090088'], ['da67a91d91049cdcb367be4be6ffca3cfeed657d808583de33fa978bc1ec6cb1', '9bacaa35481642bc41f463f7ec9780e5dec7adc508f740a17e9ea8e27a68be1d'], ['53904faa0b334cdda6e000935ef22151ec08d0f7bb11069f57545ccc1a37b7c0', '5bc087d0bc80106d88c9eccac20d3c1c13999981e14434699dcb096b022771c8'], ['8e7bcd0bd35983a7719cca7764ca906779b53a043a9b8bcaeff959f43ad86047', '10b7770b2a3da4b3940310420ca9514579e88e2e47fd68b3ea10047e8460372a'], ['385eed34c1cdff21e6d0818689b81bde71a7f4f18397e6690a841e1599c43862', '283bebc3e8ea23f56701de19e9ebf4576b304eec2086dc8cc0458fe5542e5453'], ['6f9d9b803ecf191637c73a4413dfa180fddf84a5947fbc9c606ed86c3fac3a7', '7c80c68e603059ba69b8e2a30e45c4d47ea4dd2f5c281002d86890603a842160'], ['3322d401243c4e2582a2147c104d6ecbf774d163db0f5e5313b7e0e742d0e6bd', '56e70797e9664ef5bfb019bc4ddaf9b72805f63ea2873af624f3a2e96c28b2a0'], ['85672c7d2de0b7da2bd1770d89665868741b3f9af7643397721d74d28134ab83', '7c481b9b5b43b2eb6374049bfa62c2e5e77f17fcc5298f44c8e3094f790313a6'], ['948bf809b1988a46b06c9f1919413b10f9226c60f668832ffd959af60c82a0a', '53a562856dcb6646dc6b74c5d1c3418c6d4dff08c97cd2bed4cb7f88d8c8e589'], ['6260ce7f461801c34f067ce0f02873a8f1b0e44dfc69752accecd819f38fd8e8', 'bc2da82b6fa5b571a7f09049776a1ef7ecd292238051c198c1a84e95b2b4ae17'], ['e5037de0afc1d8d43d8348414bbf4103043ec8f575bfdc432953cc8d2037fa2d', '4571534baa94d3b5f9f98d09fb990bddbd5f5b03ec481f10e0e5dc841d755bda'], ['e06372b0f4a207adf5ea905e8f1771b4e7e8dbd1c6a6c5b725866a0ae4fce725', '7a908974bce18cfe12a27bb2ad5a488cd7484a7787104870b27034f94eee31dd'], ['213c7a715cd5d45358d0bbf9dc0ce02204b10bdde2a3f58540ad6908d0559754', '4b6dad0b5ae462507013ad06245ba190bb4850f5f36a7eeddff2c27534b458f2'], ['4e7c272a7af4b34e8dbb9352a5419a87e2838c70adc62cddf0cc3a3b08fbd53c', '17749c766c9d0b18e16fd09f6def681b530b9614bff7dd33e0b3941817dcaae6'], ['fea74e3dbe778b1b10f238ad61686aa5c76e3db2be43057632427e2840fb27b6', '6e0568db9b0b13297cf674deccb6af93126b596b973f7b77701d3db7f23cb96f'], ['76e64113f677cf0e10a2570d599968d31544e179b760432952c02a4417bdde39', 'c90ddf8dee4e95cf577066d70681f0d35e2a33d2b56d2032b4b1752d1901ac01'], ['c738c56b03b2abe1e8281baa743f8f9a8f7cc643df26cbee3ab150242bcbb891', '893fb578951ad2537f718f2eacbfbbbb82314eef7880cfe917e735d9699a84c3'], ['d895626548b65b81e264c7637c972877d1d72e5f3a925014372e9f6588f6c14b', 'febfaa38f2bc7eae728ec60818c340eb03428d632bb067e179363ed75d7d991f'], ['b8da94032a957518eb0f6433571e8761ceffc73693e84edd49150a564f676e03', '2804dfa44805a1e4d7c99cc9762808b092cc584d95ff3b511488e4e74efdf6e7'], ['e80fea14441fb33a7d8adab9475d7fab2019effb5156a792f1a11778e3c0df5d', 'eed1de7f638e00771e89768ca3ca94472d155e80af322ea9fcb4291b6ac9ec78'], ['a301697bdfcd704313ba48e51d567543f2a182031efd6915ddc07bbcc4e16070', '7370f91cfb67e4f5081809fa25d40f9b1735dbf7c0a11a130c0d1a041e177ea1'], ['90ad85b389d6b936463f9d0512678de208cc330b11307fffab7ac63e3fb04ed4', 'e507a3620a38261affdcbd9427222b839aefabe1582894d991d4d48cb6ef150'], ['8f68b9d2f63b5f339239c1ad981f162ee88c5678723ea3351b7b444c9ec4c0da', '662a9f2dba063986de1d90c2b6be215dbbea2cfe95510bfdf23cbf79501fff82'], ['e4f3fb0176af85d65ff99ff9198c36091f48e86503681e3e6686fd5053231e11', '1e63633ad0ef4f1c1661a6d0ea02b7286cc7e74ec951d1c9822c38576feb73bc'], ['8c00fa9b18ebf331eb961537a45a4266c7034f2f0d4e1d0716fb6eae20eae29e', 'efa47267fea521a1a9dc343a3736c974c2fadafa81e36c54e7d2a4c66702414b'], ['e7a26ce69dd4829f3e10cec0a9e98ed3143d084f308b92c0997fddfc60cb3e41', '2a758e300fa7984b471b006a1aafbb18d0a6b2c0420e83e20e8a9421cf2cfd51'], ['b6459e0ee3662ec8d23540c223bcbdc571cbcb967d79424f3cf29eb3de6b80ef', '67c876d06f3e06de1dadf16e5661db3c4b3ae6d48e35b2ff30bf0b61a71ba45'], ['d68a80c8280bb840793234aa118f06231d6f1fc67e73c5a5deda0f5b496943e8', 'db8ba9fff4b586d00c4b1f9177b0e28b5b0e7b8f7845295a294c84266b133120'], ['324aed7df65c804252dc0270907a30b09612aeb973449cea4095980fc28d3d5d', '648a365774b61f2ff130c0c35aec1f4f19213b0c7e332843967224af96ab7c84'], ['4df9c14919cde61f6d51dfdbe5fee5dceec4143ba8d1ca888e8bd373fd054c96', '35ec51092d8728050974c23a1d85d4b5d506cdc288490192ebac06cad10d5d'], ['9c3919a84a474870faed8a9c1cc66021523489054d7f0308cbfc99c8ac1f98cd', 'ddb84f0f4a4ddd57584f044bf260e641905326f76c64c8e6be7e5e03d4fc599d'], ['6057170b1dd12fdf8de05f281d8e06bb91e1493a8b91d4cc5a21382120a959e5', '9a1af0b26a6a4807add9a2daf71df262465152bc3ee24c65e899be932385a2a8'], ['a576df8e23a08411421439a4518da31880cef0fba7d4df12b1a6973eecb94266', '40a6bf20e76640b2c92b97afe58cd82c432e10a7f514d9f3ee8be11ae1b28ec8'], ['7778a78c28dec3e30a05fe9629de8c38bb30d1f5cf9a3a208f763889be58ad71', '34626d9ab5a5b22ff7098e12f2ff580087b38411ff24ac563b513fc1fd9f43ac'], ['928955ee637a84463729fd30e7afd2ed5f96274e5ad7e5cb09eda9c06d903ac', 'c25621003d3f42a827b78a13093a95eeac3d26efa8a8d83fc5180e935bcd091f'], ['85d0fef3ec6db109399064f3a0e3b2855645b4a907ad354527aae75163d82751', '1f03648413a38c0be29d496e582cf5663e8751e96877331582c237a24eb1f962'], ['ff2b0dce97eece97c1c9b6041798b85dfdfb6d8882da20308f5404824526087e', '493d13fef524ba188af4c4dc54d07936c7b7ed6fb90e2ceb2c951e01f0c29907'], ['827fbbe4b1e880ea9ed2b2e6301b212b57f1ee148cd6dd28780e5e2cf856e241', 'c60f9c923c727b0b71bef2c67d1d12687ff7a63186903166d605b68baec293ec'], ['eaa649f21f51bdbae7be4ae34ce6e5217a58fdce7f47f9aa7f3b58fa2120e2b3', 'be3279ed5bbbb03ac69a80f89879aa5a01a6b965f13f7e59d47a5305ba5ad93d'], ['e4a42d43c5cf169d9391df6decf42ee541b6d8f0c9a137401e23632dda34d24f', '4d9f92e716d1c73526fc99ccfb8ad34ce886eedfa8d8e4f13a7f7131deba9414'], ['1ec80fef360cbdd954160fadab352b6b92b53576a88fea4947173b9d4300bf19', 'aeefe93756b5340d2f3a4958a7abbf5e0146e77f6295a07b671cdc1cc107cefd'], ['146a778c04670c2f91b00af4680dfa8bce3490717d58ba889ddb5928366642be', 'b318e0ec3354028add669827f9d4b2870aaa971d2f7e5ed1d0b297483d83efd0'], ['fa50c0f61d22e5f07e3acebb1aa07b128d0012209a28b9776d76a8793180eef9', '6b84c6922397eba9b72cd2872281a68a5e683293a57a213b38cd8d7d3f4f2811'], ['da1d61d0ca721a11b1a5bf6b7d88e8421a288ab5d5bba5220e53d32b5f067ec2', '8157f55a7c99306c79c0766161c91e2966a73899d279b48a655fba0f1ad836f1'], ['a8e282ff0c9706907215ff98e8fd416615311de0446f1e062a73b0610d064e13', '7f97355b8db81c09abfb7f3c5b2515888b679a3e50dd6bd6cef7c73111f4cc0c'], ['174a53b9c9a285872d39e56e6913cab15d59b1fa512508c022f382de8319497c', 'ccc9dc37abfc9c1657b4155f2c47f9e6646b3a1d8cb9854383da13ac079afa73'], ['959396981943785c3d3e57edf5018cdbe039e730e4918b3d884fdff09475b7ba', '2e7e552888c331dd8ba0386a4b9cd6849c653f64c8709385e9b8abf87524f2fd'], ['d2a63a50ae401e56d645a1153b109a8fcca0a43d561fba2dbb51340c9d82b151', 'e82d86fb6443fcb7565aee58b2948220a70f750af484ca52d4142174dcf89405'], ['64587e2335471eb890ee7896d7cfdc866bacbdbd3839317b3436f9b45617e073', 'd99fcdd5bf6902e2ae96dd6447c299a185b90a39133aeab358299e5e9faf6589'], ['8481bde0e4e4d885b3a546d3e549de042f0aa6cea250e7fd358d6c86dd45e458', '38ee7b8cba5404dd84a25bf39cecb2ca900a79c42b262e556d64b1b59779057e'], ['13464a57a78102aa62b6979ae817f4637ffcfed3c4b1ce30bcd6303f6caf666b', '69be159004614580ef7e433453ccb0ca48f300a81d0942e13f495a907f6ecc27'], ['bc4a9df5b713fe2e9aef430bcc1dc97a0cd9ccede2f28588cada3a0d2d83f366', 'd3a81ca6e785c06383937adf4b798caa6e8a9fbfa547b16d758d666581f33c1'], ['8c28a97bf8298bc0d23d8c749452a32e694b65e30a9472a3954ab30fe5324caa', '40a30463a3305193378fedf31f7cc0eb7ae784f0451cb9459e71dc73cbef9482'], ['8ea9666139527a8c1dd94ce4f071fd23c8b350c5a4bb33748c4ba111faccae0', '620efabbc8ee2782e24e7c0cfb95c5d735b783be9cf0f8e955af34a30e62b945'], ['dd3625faef5ba06074669716bbd3788d89bdde815959968092f76cc4eb9a9787', '7a188fa3520e30d461da2501045731ca941461982883395937f68d00c644a573'], ['f710d79d9eb962297e4f6232b40e8f7feb2bc63814614d692c12de752408221e', 'ea98e67232d3b3295d3b535532115ccac8612c721851617526ae47a9c77bfc82']]\n  },\n  naf: {\n    wnd: 7,\n    points: [['f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9', '388f7b0f632de8140fe337e62a37f3566500a99934c2231b6cb9fd7584b8e672'], ['2f8bde4d1a07209355b4a7250a5c5128e88b84bddc619ab7cba8d569b240efe4', 'd8ac222636e5e3d6d4dba9dda6c9c426f788271bab0d6840dca87d3aa6ac62d6'], ['5cbdf0646e5db4eaa398f365f2ea7a0e3d419b7e0330e39ce92bddedcac4f9bc', '6aebca40ba255960a3178d6d861a54dba813d0b813fde7b5a5082628087264da'], ['acd484e2f0c7f65309ad178a9f559abde09796974c57e714c35f110dfc27ccbe', 'cc338921b0a7d9fd64380971763b61e9add888a4375f8e0f05cc262ac64f9c37'], ['774ae7f858a9411e5ef4246b70c65aac5649980be5c17891bbec17895da008cb', 'd984a032eb6b5e190243dd56d7b7b365372db1e2dff9d6a8301d74c9c953c61b'], ['f28773c2d975288bc7d1d205c3748651b075fbc6610e58cddeeddf8f19405aa8', 'ab0902e8d880a89758212eb65cdaf473a1a06da521fa91f29b5cb52db03ed81'], ['d7924d4f7d43ea965a465ae3095ff41131e5946f3c85f79e44adbcf8e27e080e', '581e2872a86c72a683842ec228cc6defea40af2bd896d3a5c504dc9ff6a26b58'], ['defdea4cdb677750a420fee807eacf21eb9898ae79b9768766e4faa04a2d4a34', '4211ab0694635168e997b0ead2a93daeced1f4a04a95c0f6cfb199f69e56eb77'], ['2b4ea0a797a443d293ef5cff444f4979f06acfebd7e86d277475656138385b6c', '85e89bc037945d93b343083b5a1c86131a01f60c50269763b570c854e5c09b7a'], ['352bbf4a4cdd12564f93fa332ce333301d9ad40271f8107181340aef25be59d5', '321eb4075348f534d59c18259dda3e1f4a1b3b2e71b1039c67bd3d8bcf81998c'], ['2fa2104d6b38d11b0230010559879124e42ab8dfeff5ff29dc9cdadd4ecacc3f', '2de1068295dd865b64569335bd5dd80181d70ecfc882648423ba76b532b7d67'], ['9248279b09b4d68dab21a9b066edda83263c3d84e09572e269ca0cd7f5453714', '73016f7bf234aade5d1aa71bdea2b1ff3fc0de2a887912ffe54a32ce97cb3402'], ['daed4f2be3a8bf278e70132fb0beb7522f570e144bf615c07e996d443dee8729', 'a69dce4a7d6c98e8d4a1aca87ef8d7003f83c230f3afa726ab40e52290be1c55'], ['c44d12c7065d812e8acf28d7cbb19f9011ecd9e9fdf281b0e6a3b5e87d22e7db', '2119a460ce326cdc76c45926c982fdac0e106e861edf61c5a039063f0e0e6482'], ['6a245bf6dc698504c89a20cfded60853152b695336c28063b61c65cbd269e6b4', 'e022cf42c2bd4a708b3f5126f16a24ad8b33ba48d0423b6efd5e6348100d8a82'], ['1697ffa6fd9de627c077e3d2fe541084ce13300b0bec1146f95ae57f0d0bd6a5', 'b9c398f186806f5d27561506e4557433a2cf15009e498ae7adee9d63d01b2396'], ['605bdb019981718b986d0f07e834cb0d9deb8360ffb7f61df982345ef27a7479', '2972d2de4f8d20681a78d93ec96fe23c26bfae84fb14db43b01e1e9056b8c49'], ['62d14dab4150bf497402fdc45a215e10dcb01c354959b10cfe31c7e9d87ff33d', '80fc06bd8cc5b01098088a1950eed0db01aa132967ab472235f5642483b25eaf'], ['80c60ad0040f27dade5b4b06c408e56b2c50e9f56b9b8b425e555c2f86308b6f', '1c38303f1cc5c30f26e66bad7fe72f70a65eed4cbe7024eb1aa01f56430bd57a'], ['7a9375ad6167ad54aa74c6348cc54d344cc5dc9487d847049d5eabb0fa03c8fb', 'd0e3fa9eca8726909559e0d79269046bdc59ea10c70ce2b02d499ec224dc7f7'], ['d528ecd9b696b54c907a9ed045447a79bb408ec39b68df504bb51f459bc3ffc9', 'eecf41253136e5f99966f21881fd656ebc4345405c520dbc063465b521409933'], ['49370a4b5f43412ea25f514e8ecdad05266115e4a7ecb1387231808f8b45963', '758f3f41afd6ed428b3081b0512fd62a54c3f3afbb5b6764b653052a12949c9a'], ['77f230936ee88cbbd73df930d64702ef881d811e0e1498e2f1c13eb1fc345d74', '958ef42a7886b6400a08266e9ba1b37896c95330d97077cbbe8eb3c7671c60d6'], ['f2dac991cc4ce4b9ea44887e5c7c0bce58c80074ab9d4dbaeb28531b7739f530', 'e0dedc9b3b2f8dad4da1f32dec2531df9eb5fbeb0598e4fd1a117dba703a3c37'], ['463b3d9f662621fb1b4be8fbbe2520125a216cdfc9dae3debcba4850c690d45b', '5ed430d78c296c3543114306dd8622d7c622e27c970a1de31cb377b01af7307e'], ['f16f804244e46e2a09232d4aff3b59976b98fac14328a2d1a32496b49998f247', 'cedabd9b82203f7e13d206fcdf4e33d92a6c53c26e5cce26d6579962c4e31df6'], ['caf754272dc84563b0352b7a14311af55d245315ace27c65369e15f7151d41d1', 'cb474660ef35f5f2a41b643fa5e460575f4fa9b7962232a5c32f908318a04476'], ['2600ca4b282cb986f85d0f1709979d8b44a09c07cb86d7c124497bc86f082120', '4119b88753c15bd6a693b03fcddbb45d5ac6be74ab5f0ef44b0be9475a7e4b40'], ['7635ca72d7e8432c338ec53cd12220bc01c48685e24f7dc8c602a7746998e435', '91b649609489d613d1d5e590f78e6d74ecfc061d57048bad9e76f302c5b9c61'], ['754e3239f325570cdbbf4a87deee8a66b7f2b33479d468fbc1a50743bf56cc18', '673fb86e5bda30fb3cd0ed304ea49a023ee33d0197a695d0c5d98093c536683'], ['e3e6bd1071a1e96aff57859c82d570f0330800661d1c952f9fe2694691d9b9e8', '59c9e0bba394e76f40c0aa58379a3cb6a5a2283993e90c4167002af4920e37f5'], ['186b483d056a033826ae73d88f732985c4ccb1f32ba35f4b4cc47fdcf04aa6eb', '3b952d32c67cf77e2e17446e204180ab21fb8090895138b4a4a797f86e80888b'], ['df9d70a6b9876ce544c98561f4be4f725442e6d2b737d9c91a8321724ce0963f', '55eb2dafd84d6ccd5f862b785dc39d4ab157222720ef9da217b8c45cf2ba2417'], ['5edd5cc23c51e87a497ca815d5dce0f8ab52554f849ed8995de64c5f34ce7143', 'efae9c8dbc14130661e8cec030c89ad0c13c66c0d17a2905cdc706ab7399a868'], ['290798c2b6476830da12fe02287e9e777aa3fba1c355b17a722d362f84614fba', 'e38da76dcd440621988d00bcf79af25d5b29c094db2a23146d003afd41943e7a'], ['af3c423a95d9f5b3054754efa150ac39cd29552fe360257362dfdecef4053b45', 'f98a3fd831eb2b749a93b0e6f35cfb40c8cd5aa667a15581bc2feded498fd9c6'], ['766dbb24d134e745cccaa28c99bf274906bb66b26dcf98df8d2fed50d884249a', '744b1152eacbe5e38dcc887980da38b897584a65fa06cedd2c924f97cbac5996'], ['59dbf46f8c94759ba21277c33784f41645f7b44f6c596a58ce92e666191abe3e', 'c534ad44175fbc300f4ea6ce648309a042ce739a7919798cd85e216c4a307f6e'], ['f13ada95103c4537305e691e74e9a4a8dd647e711a95e73cb62dc6018cfd87b8', 'e13817b44ee14de663bf4bc808341f326949e21a6a75c2570778419bdaf5733d'], ['7754b4fa0e8aced06d4167a2c59cca4cda1869c06ebadfb6488550015a88522c', '30e93e864e669d82224b967c3020b8fa8d1e4e350b6cbcc537a48b57841163a2'], ['948dcadf5990e048aa3874d46abef9d701858f95de8041d2a6828c99e2262519', 'e491a42537f6e597d5d28a3224b1bc25df9154efbd2ef1d2cbba2cae5347d57e'], ['7962414450c76c1689c7b48f8202ec37fb224cf5ac0bfa1570328a8a3d7c77ab', '100b610ec4ffb4760d5c1fc133ef6f6b12507a051f04ac5760afa5b29db83437'], ['3514087834964b54b15b160644d915485a16977225b8847bb0dd085137ec47ca', 'ef0afbb2056205448e1652c48e8127fc6039e77c15c2378b7e7d15a0de293311'], ['d3cc30ad6b483e4bc79ce2c9dd8bc54993e947eb8df787b442943d3f7b527eaf', '8b378a22d827278d89c5e9be8f9508ae3c2ad46290358630afb34db04eede0a4'], ['1624d84780732860ce1c78fcbfefe08b2b29823db913f6493975ba0ff4847610', '68651cf9b6da903e0914448c6cd9d4ca896878f5282be4c8cc06e2a404078575'], ['733ce80da955a8a26902c95633e62a985192474b5af207da6df7b4fd5fc61cd4', 'f5435a2bd2badf7d485a4d8b8db9fcce3e1ef8e0201e4578c54673bc1dc5ea1d'], ['15d9441254945064cf1a1c33bbd3b49f8966c5092171e699ef258dfab81c045c', 'd56eb30b69463e7234f5137b73b84177434800bacebfc685fc37bbe9efe4070d'], ['a1d0fcf2ec9de675b612136e5ce70d271c21417c9d2b8aaaac138599d0717940', 'edd77f50bcb5a3cab2e90737309667f2641462a54070f3d519212d39c197a629'], ['e22fbe15c0af8ccc5780c0735f84dbe9a790badee8245c06c7ca37331cb36980', 'a855babad5cd60c88b430a69f53a1a7a38289154964799be43d06d77d31da06'], ['311091dd9860e8e20ee13473c1155f5f69635e394704eaa74009452246cfa9b3', '66db656f87d1f04fffd1f04788c06830871ec5a64feee685bd80f0b1286d8374'], ['34c1fd04d301be89b31c0442d3e6ac24883928b45a9340781867d4232ec2dbdf', '9414685e97b1b5954bd46f730174136d57f1ceeb487443dc5321857ba73abee'], ['f219ea5d6b54701c1c14de5b557eb42a8d13f3abbcd08affcc2a5e6b049b8d63', '4cb95957e83d40b0f73af4544cccf6b1f4b08d3c07b27fb8d8c2962a400766d1'], ['d7b8740f74a8fbaab1f683db8f45de26543a5490bca627087236912469a0b448', 'fa77968128d9c92ee1010f337ad4717eff15db5ed3c049b3411e0315eaa4593b'], ['32d31c222f8f6f0ef86f7c98d3a3335ead5bcd32abdd94289fe4d3091aa824bf', '5f3032f5892156e39ccd3d7915b9e1da2e6dac9e6f26e961118d14b8462e1661'], ['7461f371914ab32671045a155d9831ea8793d77cd59592c4340f86cbc18347b5', '8ec0ba238b96bec0cbdddcae0aa442542eee1ff50c986ea6b39847b3cc092ff6'], ['ee079adb1df1860074356a25aa38206a6d716b2c3e67453d287698bad7b2b2d6', '8dc2412aafe3be5c4c5f37e0ecc5f9f6a446989af04c4e25ebaac479ec1c8c1e'], ['16ec93e447ec83f0467b18302ee620f7e65de331874c9dc72bfd8616ba9da6b5', '5e4631150e62fb40d0e8c2a7ca5804a39d58186a50e497139626778e25b0674d'], ['eaa5f980c245f6f038978290afa70b6bd8855897f98b6aa485b96065d537bd99', 'f65f5d3e292c2e0819a528391c994624d784869d7e6ea67fb18041024edc07dc'], ['78c9407544ac132692ee1910a02439958ae04877151342ea96c4b6b35a49f51', 'f3e0319169eb9b85d5404795539a5e68fa1fbd583c064d2462b675f194a3ddb4'], ['494f4be219a1a77016dcd838431aea0001cdc8ae7a6fc688726578d9702857a5', '42242a969283a5f339ba7f075e36ba2af925ce30d767ed6e55f4b031880d562c'], ['a598a8030da6d86c6bc7f2f5144ea549d28211ea58faa70ebf4c1e665c1fe9b5', '204b5d6f84822c307e4b4a7140737aec23fc63b65b35f86a10026dbd2d864e6b'], ['c41916365abb2b5d09192f5f2dbeafec208f020f12570a184dbadc3e58595997', '4f14351d0087efa49d245b328984989d5caf9450f34bfc0ed16e96b58fa9913'], ['841d6063a586fa475a724604da03bc5b92a2e0d2e0a36acfe4c73a5514742881', '73867f59c0659e81904f9a1c7543698e62562d6744c169ce7a36de01a8d6154'], ['5e95bb399a6971d376026947f89bde2f282b33810928be4ded112ac4d70e20d5', '39f23f366809085beebfc71181313775a99c9aed7d8ba38b161384c746012865'], ['36e4641a53948fd476c39f8a99fd974e5ec07564b5315d8bf99471bca0ef2f66', 'd2424b1b1abe4eb8164227b085c9aa9456ea13493fd563e06fd51cf5694c78fc'], ['336581ea7bfbbb290c191a2f507a41cf5643842170e914faeab27c2c579f726', 'ead12168595fe1be99252129b6e56b3391f7ab1410cd1e0ef3dcdcabd2fda224'], ['8ab89816dadfd6b6a1f2634fcf00ec8403781025ed6890c4849742706bd43ede', '6fdcef09f2f6d0a044e654aef624136f503d459c3e89845858a47a9129cdd24e'], ['1e33f1a746c9c5778133344d9299fcaa20b0938e8acff2544bb40284b8c5fb94', '60660257dd11b3aa9c8ed618d24edff2306d320f1d03010e33a7d2057f3b3b6'], ['85b7c1dcb3cec1b7ee7f30ded79dd20a0ed1f4cc18cbcfcfa410361fd8f08f31', '3d98a9cdd026dd43f39048f25a8847f4fcafad1895d7a633c6fed3c35e999511'], ['29df9fbd8d9e46509275f4b125d6d45d7fbe9a3b878a7af872a2800661ac5f51', 'b4c4fe99c775a606e2d8862179139ffda61dc861c019e55cd2876eb2a27d84b'], ['a0b1cae06b0a847a3fea6e671aaf8adfdfe58ca2f768105c8082b2e449fce252', 'ae434102edde0958ec4b19d917a6a28e6b72da1834aff0e650f049503a296cf2'], ['4e8ceafb9b3e9a136dc7ff67e840295b499dfb3b2133e4ba113f2e4c0e121e5', 'cf2174118c8b6d7a4b48f6d534ce5c79422c086a63460502b827ce62a326683c'], ['d24a44e047e19b6f5afb81c7ca2f69080a5076689a010919f42725c2b789a33b', '6fb8d5591b466f8fc63db50f1c0f1c69013f996887b8244d2cdec417afea8fa3'], ['ea01606a7a6c9cdd249fdfcfacb99584001edd28abbab77b5104e98e8e3b35d4', '322af4908c7312b0cfbfe369f7a7b3cdb7d4494bc2823700cfd652188a3ea98d'], ['af8addbf2b661c8a6c6328655eb96651252007d8c5ea31be4ad196de8ce2131f', '6749e67c029b85f52a034eafd096836b2520818680e26ac8f3dfbcdb71749700'], ['e3ae1974566ca06cc516d47e0fb165a674a3dabcfca15e722f0e3450f45889', '2aeabe7e4531510116217f07bf4d07300de97e4874f81f533420a72eeb0bd6a4'], ['591ee355313d99721cf6993ffed1e3e301993ff3ed258802075ea8ced397e246', 'b0ea558a113c30bea60fc4775460c7901ff0b053d25ca2bdeee98f1a4be5d196'], ['11396d55fda54c49f19aa97318d8da61fa8584e47b084945077cf03255b52984', '998c74a8cd45ac01289d5833a7beb4744ff536b01b257be4c5767bea93ea57a4'], ['3c5d2a1ba39c5a1790000738c9e0c40b8dcdfd5468754b6405540157e017aa7a', 'b2284279995a34e2f9d4de7396fc18b80f9b8b9fdd270f6661f79ca4c81bd257'], ['cc8704b8a60a0defa3a99a7299f2e9c3fbc395afb04ac078425ef8a1793cc030', 'bdd46039feed17881d1e0862db347f8cf395b74fc4bcdc4e940b74e3ac1f1b13'], ['c533e4f7ea8555aacd9777ac5cad29b97dd4defccc53ee7ea204119b2889b197', '6f0a256bc5efdf429a2fb6242f1a43a2d9b925bb4a4b3a26bb8e0f45eb596096'], ['c14f8f2ccb27d6f109f6d08d03cc96a69ba8c34eec07bbcf566d48e33da6593', 'c359d6923bb398f7fd4473e16fe1c28475b740dd098075e6c0e8649113dc3a38'], ['a6cbc3046bc6a450bac24789fa17115a4c9739ed75f8f21ce441f72e0b90e6ef', '21ae7f4680e889bb130619e2c0f95a360ceb573c70603139862afd617fa9b9f'], ['347d6d9a02c48927ebfb86c1359b1caf130a3c0267d11ce6344b39f99d43cc38', '60ea7f61a353524d1c987f6ecec92f086d565ab687870cb12689ff1e31c74448'], ['da6545d2181db8d983f7dcb375ef5866d47c67b1bf31c8cf855ef7437b72656a', '49b96715ab6878a79e78f07ce5680c5d6673051b4935bd897fea824b77dc208a'], ['c40747cc9d012cb1a13b8148309c6de7ec25d6945d657146b9d5994b8feb1111', '5ca560753be2a12fc6de6caf2cb489565db936156b9514e1bb5e83037e0fa2d4'], ['4e42c8ec82c99798ccf3a610be870e78338c7f713348bd34c8203ef4037f3502', '7571d74ee5e0fb92a7a8b33a07783341a5492144cc54bcc40a94473693606437'], ['3775ab7089bc6af823aba2e1af70b236d251cadb0c86743287522a1b3b0dedea', 'be52d107bcfa09d8bcb9736a828cfa7fac8db17bf7a76a2c42ad961409018cf7'], ['cee31cbf7e34ec379d94fb814d3d775ad954595d1314ba8846959e3e82f74e26', '8fd64a14c06b589c26b947ae2bcf6bfa0149ef0be14ed4d80f448a01c43b1c6d'], ['b4f9eaea09b6917619f6ea6a4eb5464efddb58fd45b1ebefcdc1a01d08b47986', '39e5c9925b5a54b07433a4f18c61726f8bb131c012ca542eb24a8ac07200682a'], ['d4263dfc3d2df923a0179a48966d30ce84e2515afc3dccc1b77907792ebcc60e', '62dfaf07a0f78feb30e30d6295853ce189e127760ad6cf7fae164e122a208d54'], ['48457524820fa65a4f8d35eb6930857c0032acc0a4a2de422233eeda897612c4', '25a748ab367979d98733c38a1fa1c2e7dc6cc07db2d60a9ae7a76aaa49bd0f77'], ['dfeeef1881101f2cb11644f3a2afdfc2045e19919152923f367a1767c11cceda', 'ecfb7056cf1de042f9420bab396793c0c390bde74b4bbdff16a83ae09a9a7517'], ['6d7ef6b17543f8373c573f44e1f389835d89bcbc6062ced36c82df83b8fae859', 'cd450ec335438986dfefa10c57fea9bcc521a0959b2d80bbf74b190dca712d10'], ['e75605d59102a5a2684500d3b991f2e3f3c88b93225547035af25af66e04541f', 'f5c54754a8f71ee540b9b48728473e314f729ac5308b06938360990e2bfad125'], ['eb98660f4c4dfaa06a2be453d5020bc99a0c2e60abe388457dd43fefb1ed620c', '6cb9a8876d9cb8520609af3add26cd20a0a7cd8a9411131ce85f44100099223e'], ['13e87b027d8514d35939f2e6892b19922154596941888336dc3563e3b8dba942', 'fef5a3c68059a6dec5d624114bf1e91aac2b9da568d6abeb2570d55646b8adf1'], ['ee163026e9fd6fe017c38f06a5be6fc125424b371ce2708e7bf4491691e5764a', '1acb250f255dd61c43d94ccc670d0f58f49ae3fa15b96623e5430da0ad6c62b2'], ['b268f5ef9ad51e4d78de3a750c2dc89b1e626d43505867999932e5db33af3d80', '5f310d4b3c99b9ebb19f77d41c1dee018cf0d34fd4191614003e945a1216e423'], ['ff07f3118a9df035e9fad85eb6c7bfe42b02f01ca99ceea3bf7ffdba93c4750d', '438136d603e858a3a5c440c38eccbaddc1d2942114e2eddd4740d098ced1f0d8'], ['8d8b9855c7c052a34146fd20ffb658bea4b9f69e0d825ebec16e8c3ce2b526a1', 'cdb559eedc2d79f926baf44fb84ea4d44bcf50fee51d7ceb30e2e7f463036758'], ['52db0b5384dfbf05bfa9d472d7ae26dfe4b851ceca91b1eba54263180da32b63', 'c3b997d050ee5d423ebaf66a6db9f57b3180c902875679de924b69d84a7b375'], ['e62f9490d3d51da6395efd24e80919cc7d0f29c3f3fa48c6fff543becbd43352', '6d89ad7ba4876b0b22c2ca280c682862f342c8591f1daf5170e07bfd9ccafa7d'], ['7f30ea2476b399b4957509c88f77d0191afa2ff5cb7b14fd6d8e7d65aaab1193', 'ca5ef7d4b231c94c3b15389a5f6311e9daff7bb67b103e9880ef4bff637acaec'], ['5098ff1e1d9f14fb46a210fada6c903fef0fb7b4a1dd1d9ac60a0361800b7a00', '9731141d81fc8f8084d37c6e7542006b3ee1b40d60dfe5362a5b132fd17ddc0'], ['32b78c7de9ee512a72895be6b9cbefa6e2f3c4ccce445c96b9f2c81e2778ad58', 'ee1849f513df71e32efc3896ee28260c73bb80547ae2275ba497237794c8753c'], ['e2cb74fddc8e9fbcd076eef2a7c72b0ce37d50f08269dfc074b581550547a4f7', 'd3aa2ed71c9dd2247a62df062736eb0baddea9e36122d2be8641abcb005cc4a4'], ['8438447566d4d7bedadc299496ab357426009a35f235cb141be0d99cd10ae3a8', 'c4e1020916980a4da5d01ac5e6ad330734ef0d7906631c4f2390426b2edd791f'], ['4162d488b89402039b584c6fc6c308870587d9c46f660b878ab65c82c711d67e', '67163e903236289f776f22c25fb8a3afc1732f2b84b4e95dbda47ae5a0852649'], ['3fad3fa84caf0f34f0f89bfd2dcf54fc175d767aec3e50684f3ba4a4bf5f683d', 'cd1bc7cb6cc407bb2f0ca647c718a730cf71872e7d0d2a53fa20efcdfe61826'], ['674f2600a3007a00568c1a7ce05d0816c1fb84bf1370798f1c69532faeb1a86b', '299d21f9413f33b3edf43b257004580b70db57da0b182259e09eecc69e0d38a5'], ['d32f4da54ade74abb81b815ad1fb3b263d82d6c692714bcff87d29bd5ee9f08f', 'f9429e738b8e53b968e99016c059707782e14f4535359d582fc416910b3eea87'], ['30e4e670435385556e593657135845d36fbb6931f72b08cb1ed954f1e3ce3ff6', '462f9bce619898638499350113bbc9b10a878d35da70740dc695a559eb88db7b'], ['be2062003c51cc3004682904330e4dee7f3dcd10b01e580bf1971b04d4cad297', '62188bc49d61e5428573d48a74e1c655b1c61090905682a0d5558ed72dccb9bc'], ['93144423ace3451ed29e0fb9ac2af211cb6e84a601df5993c419859fff5df04a', '7c10dfb164c3425f5c71a3f9d7992038f1065224f72bb9d1d902a6d13037b47c'], ['b015f8044f5fcbdcf21ca26d6c34fb8197829205c7b7d2a7cb66418c157b112c', 'ab8c1e086d04e813744a655b2df8d5f83b3cdc6faa3088c1d3aea1454e3a1d5f'], ['d5e9e1da649d97d89e4868117a465a3a4f8a18de57a140d36b3f2af341a21b52', '4cb04437f391ed73111a13cc1d4dd0db1693465c2240480d8955e8592f27447a'], ['d3ae41047dd7ca065dbf8ed77b992439983005cd72e16d6f996a5316d36966bb', 'bd1aeb21ad22ebb22a10f0303417c6d964f8cdd7df0aca614b10dc14d125ac46'], ['463e2763d885f958fc66cdd22800f0a487197d0a82e377b49f80af87c897b065', 'bfefacdb0e5d0fd7df3a311a94de062b26b80c61fbc97508b79992671ef7ca7f'], ['7985fdfd127c0567c6f53ec1bb63ec3158e597c40bfe747c83cddfc910641917', '603c12daf3d9862ef2b25fe1de289aed24ed291e0ec6708703a5bd567f32ed03'], ['74a1ad6b5f76e39db2dd249410eac7f99e74c59cb83d2d0ed5ff1543da7703e9', 'cc6157ef18c9c63cd6193d83631bbea0093e0968942e8c33d5737fd790e0db08'], ['30682a50703375f602d416664ba19b7fc9bab42c72747463a71d0896b22f6da3', '553e04f6b018b4fa6c8f39e7f311d3176290d0e0f19ca73f17714d9977a22ff8'], ['9e2158f0d7c0d5f26c3791efefa79597654e7a2b2464f52b1ee6c1347769ef57', '712fcdd1b9053f09003a3481fa7762e9ffd7c8ef35a38509e2fbf2629008373'], ['176e26989a43c9cfeba4029c202538c28172e566e3c4fce7322857f3be327d66', 'ed8cc9d04b29eb877d270b4878dc43c19aefd31f4eee09ee7b47834c1fa4b1c3'], ['75d46efea3771e6e68abb89a13ad747ecf1892393dfc4f1b7004788c50374da8', '9852390a99507679fd0b86fd2b39a868d7efc22151346e1a3ca4726586a6bed8'], ['809a20c67d64900ffb698c4c825f6d5f2310fb0451c869345b7319f645605721', '9e994980d9917e22b76b061927fa04143d096ccc54963e6a5ebfa5f3f8e286c1'], ['1b38903a43f7f114ed4500b4eac7083fdefece1cf29c63528d563446f972c180', '4036edc931a60ae889353f77fd53de4a2708b26b6f5da72ad3394119daf408f9']]\n  }\n};\n\n/***/ }),\n/* 56 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; };\n\nvar BN = __webpack_require__(1);\nvar HmacDRBG = __webpack_require__(57);\nvar elliptic = __webpack_require__(0);\nvar utils = elliptic.utils;\nvar assert = utils.assert;\n\nvar KeyPair = __webpack_require__(58);\nvar Signature = __webpack_require__(59);\n\nfunction EC(options) {\n  if (!(this instanceof EC)) return new EC(options);\n\n  // Shortcut `elliptic.ec(curve-name)`\n  if (typeof options === 'string') {\n    assert(elliptic.curves.hasOwnProperty(options), 'Unknown curve ' + options);\n\n    options = elliptic.curves[options];\n  }\n\n  // Shortcut for `elliptic.ec(elliptic.curves.curveName)`\n  if (options instanceof elliptic.curves.PresetCurve) options = { curve: options };\n\n  this.curve = options.curve.curve;\n  this.n = this.curve.n;\n  this.nh = this.n.ushrn(1);\n  this.g = this.curve.g;\n\n  // Point on curve\n  this.g = options.curve.g;\n  this.g.precompute(options.curve.n.bitLength() + 1);\n\n  // Hash for function for DRBG\n  this.hash = options.hash || options.curve.hash;\n}\nmodule.exports = EC;\n\nEC.prototype.keyPair = function keyPair(options) {\n  return new KeyPair(this, options);\n};\n\nEC.prototype.keyFromPrivate = function keyFromPrivate(priv, enc) {\n  return KeyPair.fromPrivate(this, priv, enc);\n};\n\nEC.prototype.keyFromPublic = function keyFromPublic(pub, enc) {\n  return KeyPair.fromPublic(this, pub, enc);\n};\n\nEC.prototype.genKeyPair = function genKeyPair(options) {\n  if (!options) options = {};\n\n  // Instantiate Hmac_DRBG\n  var drbg = new HmacDRBG({\n    hash: this.hash,\n    pers: options.pers,\n    persEnc: options.persEnc || 'utf8',\n    entropy: options.entropy || elliptic.rand(this.hash.hmacStrength),\n    entropyEnc: options.entropy && options.entropyEnc || 'utf8',\n    nonce: this.n.toArray()\n  });\n\n  var bytes = this.n.byteLength();\n  var ns2 = this.n.sub(new BN(2));\n  do {\n    var priv = new BN(drbg.generate(bytes));\n    if (priv.cmp(ns2) > 0) continue;\n\n    priv.iaddn(1);\n    return this.keyFromPrivate(priv);\n  } while (true);\n};\n\nEC.prototype._truncateToN = function truncateToN(msg, truncOnly) {\n  var delta = msg.byteLength() * 8 - this.n.bitLength();\n  if (delta > 0) msg = msg.ushrn(delta);\n  if (!truncOnly && msg.cmp(this.n) >= 0) return msg.sub(this.n);else return msg;\n};\n\nEC.prototype.sign = function sign(msg, key, enc, options) {\n  if ((typeof enc === 'undefined' ? 'undefined' : _typeof(enc)) === 'object') {\n    options = enc;\n    enc = null;\n  }\n  if (!options) options = {};\n\n  key = this.keyFromPrivate(key, enc);\n  msg = this._truncateToN(new BN(msg, 16));\n\n  // Zero-extend key to provide enough entropy\n  var bytes = this.n.byteLength();\n  var bkey = key.getPrivate().toArray('be', bytes);\n\n  // Zero-extend nonce to have the same byte size as N\n  var nonce = msg.toArray('be', bytes);\n\n  // Instantiate Hmac_DRBG\n  var drbg = new HmacDRBG({\n    hash: this.hash,\n    entropy: bkey,\n    nonce: nonce,\n    pers: options.pers,\n    persEnc: options.persEnc || 'utf8'\n  });\n\n  // Number of bytes to generate\n  var ns1 = this.n.sub(new BN(1));\n\n  for (var iter = 0; true; iter++) {\n    var k = options.k ? options.k(iter) : new BN(drbg.generate(this.n.byteLength()));\n    k = this._truncateToN(k, true);\n    if (k.cmpn(1) <= 0 || k.cmp(ns1) >= 0) continue;\n\n    var kp = this.g.mul(k);\n    if (kp.isInfinity()) continue;\n\n    var kpX = kp.getX();\n    var r = kpX.umod(this.n);\n    if (r.cmpn(0) === 0) continue;\n\n    var s = k.invm(this.n).mul(r.mul(key.getPrivate()).iadd(msg));\n    s = s.umod(this.n);\n    if (s.cmpn(0) === 0) continue;\n\n    var recoveryParam = (kp.getY().isOdd() ? 1 : 0) | (kpX.cmp(r) !== 0 ? 2 : 0);\n\n    // Use complement of `s`, if it is > `n / 2`\n    if (options.canonical && s.cmp(this.nh) > 0) {\n      s = this.n.sub(s);\n      recoveryParam ^= 1;\n    }\n\n    return new Signature({ r: r, s: s, recoveryParam: recoveryParam });\n  }\n};\n\nEC.prototype.verify = function verify(msg, signature, key, enc) {\n  msg = this._truncateToN(new BN(msg, 16));\n  key = this.keyFromPublic(key, enc);\n  signature = new Signature(signature, 'hex');\n\n  // Perform primitive values validation\n  var r = signature.r;\n  var s = signature.s;\n  if (r.cmpn(1) < 0 || r.cmp(this.n) >= 0) return false;\n  if (s.cmpn(1) < 0 || s.cmp(this.n) >= 0) return false;\n\n  // Validate signature\n  var sinv = s.invm(this.n);\n  var u1 = sinv.mul(msg).umod(this.n);\n  var u2 = sinv.mul(r).umod(this.n);\n\n  if (!this.curve._maxwellTrick) {\n    var p = this.g.mulAdd(u1, key.getPublic(), u2);\n    if (p.isInfinity()) return false;\n\n    return p.getX().umod(this.n).cmp(r) === 0;\n  }\n\n  // NOTE: Greg Maxwell's trick, inspired by:\n  // https://git.io/vad3K\n\n  var p = this.g.jmulAdd(u1, key.getPublic(), u2);\n  if (p.isInfinity()) return false;\n\n  // Compare `p.x` of Jacobian point with `r`,\n  // this will do `p.x == r * p.z^2` instead of multiplying `p.x` by the\n  // inverse of `p.z^2`\n  return p.eqXToP(r);\n};\n\nEC.prototype.recoverPubKey = function (msg, signature, j, enc) {\n  assert((3 & j) === j, 'The recovery param is more than two bits');\n  signature = new Signature(signature, enc);\n\n  var n = this.n;\n  var e = new BN(msg);\n  var r = signature.r;\n  var s = signature.s;\n\n  // A set LSB signifies that the y-coordinate is odd\n  var isYOdd = j & 1;\n  var isSecondKey = j >> 1;\n  if (r.cmp(this.curve.p.umod(this.curve.n)) >= 0 && isSecondKey) throw new Error('Unable to find sencond key candinate');\n\n  // 1.1. Let x = r + jn.\n  if (isSecondKey) r = this.curve.pointFromX(r.add(this.curve.n), isYOdd);else r = this.curve.pointFromX(r, isYOdd);\n\n  var rInv = signature.r.invm(n);\n  var s1 = n.sub(e).mul(rInv).umod(n);\n  var s2 = s.mul(rInv).umod(n);\n\n  // 1.6.1 Compute Q = r^-1 (sR -  eG)\n  //               Q = r^-1 (sR + -eG)\n  return this.g.mulAdd(s1, r, s2);\n};\n\nEC.prototype.getKeyRecoveryParam = function (e, signature, Q, enc) {\n  signature = new Signature(signature, enc);\n  if (signature.recoveryParam !== null) return signature.recoveryParam;\n\n  for (var i = 0; i < 4; i++) {\n    var Qprime;\n    try {\n      Qprime = this.recoverPubKey(e, signature, i);\n    } catch (e) {\n      continue;\n    }\n\n    if (Qprime.eq(Q)) return i;\n  }\n  throw new Error('Unable to find valid recovery factor');\n};\n\n/***/ }),\n/* 57 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar hash = __webpack_require__(15);\nvar utils = __webpack_require__(22);\nvar assert = __webpack_require__(6);\n\nfunction HmacDRBG(options) {\n  if (!(this instanceof HmacDRBG)) return new HmacDRBG(options);\n  this.hash = options.hash;\n  this.predResist = !!options.predResist;\n\n  this.outLen = this.hash.outSize;\n  this.minEntropy = options.minEntropy || this.hash.hmacStrength;\n\n  this._reseed = null;\n  this.reseedInterval = null;\n  this.K = null;\n  this.V = null;\n\n  var entropy = utils.toArray(options.entropy, options.entropyEnc || 'hex');\n  var nonce = utils.toArray(options.nonce, options.nonceEnc || 'hex');\n  var pers = utils.toArray(options.pers, options.persEnc || 'hex');\n  assert(entropy.length >= this.minEntropy / 8, 'Not enough entropy. Minimum is: ' + this.minEntropy + ' bits');\n  this._init(entropy, nonce, pers);\n}\nmodule.exports = HmacDRBG;\n\nHmacDRBG.prototype._init = function init(entropy, nonce, pers) {\n  var seed = entropy.concat(nonce).concat(pers);\n\n  this.K = new Array(this.outLen / 8);\n  this.V = new Array(this.outLen / 8);\n  for (var i = 0; i < this.V.length; i++) {\n    this.K[i] = 0x00;\n    this.V[i] = 0x01;\n  }\n\n  this._update(seed);\n  this._reseed = 1;\n  this.reseedInterval = 0x1000000000000; // 2^48\n};\n\nHmacDRBG.prototype._hmac = function hmac() {\n  return new hash.hmac(this.hash, this.K);\n};\n\nHmacDRBG.prototype._update = function update(seed) {\n  var kmac = this._hmac().update(this.V).update([0x00]);\n  if (seed) kmac = kmac.update(seed);\n  this.K = kmac.digest();\n  this.V = this._hmac().update(this.V).digest();\n  if (!seed) return;\n\n  this.K = this._hmac().update(this.V).update([0x01]).update(seed).digest();\n  this.V = this._hmac().update(this.V).digest();\n};\n\nHmacDRBG.prototype.reseed = function reseed(entropy, entropyEnc, add, addEnc) {\n  // Optional entropy enc\n  if (typeof entropyEnc !== 'string') {\n    addEnc = add;\n    add = entropyEnc;\n    entropyEnc = null;\n  }\n\n  entropy = utils.toArray(entropy, entropyEnc);\n  add = utils.toArray(add, addEnc);\n\n  assert(entropy.length >= this.minEntropy / 8, 'Not enough entropy. Minimum is: ' + this.minEntropy + ' bits');\n\n  this._update(entropy.concat(add || []));\n  this._reseed = 1;\n};\n\nHmacDRBG.prototype.generate = function generate(len, enc, add, addEnc) {\n  if (this._reseed > this.reseedInterval) throw new Error('Reseed is required');\n\n  // Optional encoding\n  if (typeof enc !== 'string') {\n    addEnc = add;\n    add = enc;\n    enc = null;\n  }\n\n  // Optional additional data\n  if (add) {\n    add = utils.toArray(add, addEnc || 'hex');\n    this._update(add);\n  }\n\n  var temp = [];\n  while (temp.length < len) {\n    this.V = this._hmac().update(this.V).digest();\n    temp = temp.concat(this.V);\n  }\n\n  var res = temp.slice(0, len);\n  this._update(add);\n  this._reseed++;\n  return utils.encode(res, enc);\n};\n\n/***/ }),\n/* 58 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar BN = __webpack_require__(1);\nvar elliptic = __webpack_require__(0);\nvar utils = elliptic.utils;\nvar assert = utils.assert;\n\nfunction KeyPair(ec, options) {\n  this.ec = ec;\n  this.priv = null;\n  this.pub = null;\n\n  // KeyPair(ec, { priv: ..., pub: ... })\n  if (options.priv) this._importPrivate(options.priv, options.privEnc);\n  if (options.pub) this._importPublic(options.pub, options.pubEnc);\n}\nmodule.exports = KeyPair;\n\nKeyPair.fromPublic = function fromPublic(ec, pub, enc) {\n  if (pub instanceof KeyPair) return pub;\n\n  return new KeyPair(ec, {\n    pub: pub,\n    pubEnc: enc\n  });\n};\n\nKeyPair.fromPrivate = function fromPrivate(ec, priv, enc) {\n  if (priv instanceof KeyPair) return priv;\n\n  return new KeyPair(ec, {\n    priv: priv,\n    privEnc: enc\n  });\n};\n\nKeyPair.prototype.validate = function validate() {\n  var pub = this.getPublic();\n\n  if (pub.isInfinity()) return { result: false, reason: 'Invalid public key' };\n  if (!pub.validate()) return { result: false, reason: 'Public key is not a point' };\n  if (!pub.mul(this.ec.curve.n).isInfinity()) return { result: false, reason: 'Public key * N != O' };\n\n  return { result: true, reason: null };\n};\n\nKeyPair.prototype.getPublic = function getPublic(compact, enc) {\n  // compact is optional argument\n  if (typeof compact === 'string') {\n    enc = compact;\n    compact = null;\n  }\n\n  if (!this.pub) this.pub = this.ec.g.mul(this.priv);\n\n  if (!enc) return this.pub;\n\n  return this.pub.encode(enc, compact);\n};\n\nKeyPair.prototype.getPrivate = function getPrivate(enc) {\n  if (enc === 'hex') return this.priv.toString(16, 2);else return this.priv;\n};\n\nKeyPair.prototype._importPrivate = function _importPrivate(key, enc) {\n  this.priv = new BN(key, enc || 16);\n\n  // Ensure that the priv won't be bigger than n, otherwise we may fail\n  // in fixed multiplication method\n  this.priv = this.priv.umod(this.ec.curve.n);\n};\n\nKeyPair.prototype._importPublic = function _importPublic(key, enc) {\n  if (key.x || key.y) {\n    // Montgomery points only have an `x` coordinate.\n    // Weierstrass/Edwards points on the other hand have both `x` and\n    // `y` coordinates.\n    if (this.ec.curve.type === 'mont') {\n      assert(key.x, 'Need x coordinate');\n    } else if (this.ec.curve.type === 'short' || this.ec.curve.type === 'edwards') {\n      assert(key.x && key.y, 'Need both x and y coordinate');\n    }\n    this.pub = this.ec.curve.point(key.x, key.y);\n    return;\n  }\n  this.pub = this.ec.curve.decodePoint(key, enc);\n};\n\n// ECDH\nKeyPair.prototype.derive = function derive(pub) {\n  return pub.mul(this.priv).getX();\n};\n\n// ECDSA\nKeyPair.prototype.sign = function sign(msg, enc, options) {\n  return this.ec.sign(msg, this, enc, options);\n};\n\nKeyPair.prototype.verify = function verify(msg, signature) {\n  return this.ec.verify(msg, signature, this);\n};\n\nKeyPair.prototype.inspect = function inspect() {\n  return '<Key priv: ' + (this.priv && this.priv.toString(16, 2)) + ' pub: ' + (this.pub && this.pub.inspect()) + ' >';\n};\n\n/***/ }),\n/* 59 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar BN = __webpack_require__(1);\n\nvar elliptic = __webpack_require__(0);\nvar utils = elliptic.utils;\nvar assert = utils.assert;\n\nfunction Signature(options, enc) {\n  if (options instanceof Signature) return options;\n\n  if (this._importDER(options, enc)) return;\n\n  assert(options.r && options.s, 'Signature without r or s');\n  this.r = new BN(options.r, 16);\n  this.s = new BN(options.s, 16);\n  if (options.recoveryParam === undefined) this.recoveryParam = null;else this.recoveryParam = options.recoveryParam;\n}\nmodule.exports = Signature;\n\nfunction Position() {\n  this.place = 0;\n}\n\nfunction getLength(buf, p) {\n  var initial = buf[p.place++];\n  if (!(initial & 0x80)) {\n    return initial;\n  }\n  var octetLen = initial & 0xf;\n  var val = 0;\n  for (var i = 0, off = p.place; i < octetLen; i++, off++) {\n    val <<= 8;\n    val |= buf[off];\n  }\n  p.place = off;\n  return val;\n}\n\nfunction rmPadding(buf) {\n  var i = 0;\n  var len = buf.length - 1;\n  while (!buf[i] && !(buf[i + 1] & 0x80) && i < len) {\n    i++;\n  }\n  if (i === 0) {\n    return buf;\n  }\n  return buf.slice(i);\n}\n\nSignature.prototype._importDER = function _importDER(data, enc) {\n  data = utils.toArray(data, enc);\n  var p = new Position();\n  if (data[p.place++] !== 0x30) {\n    return false;\n  }\n  var len = getLength(data, p);\n  if (len + p.place !== data.length) {\n    return false;\n  }\n  if (data[p.place++] !== 0x02) {\n    return false;\n  }\n  var rlen = getLength(data, p);\n  var r = data.slice(p.place, rlen + p.place);\n  p.place += rlen;\n  if (data[p.place++] !== 0x02) {\n    return false;\n  }\n  var slen = getLength(data, p);\n  if (data.length !== slen + p.place) {\n    return false;\n  }\n  var s = data.slice(p.place, slen + p.place);\n  if (r[0] === 0 && r[1] & 0x80) {\n    r = r.slice(1);\n  }\n  if (s[0] === 0 && s[1] & 0x80) {\n    s = s.slice(1);\n  }\n\n  this.r = new BN(r);\n  this.s = new BN(s);\n  this.recoveryParam = null;\n\n  return true;\n};\n\nfunction constructLength(arr, len) {\n  if (len < 0x80) {\n    arr.push(len);\n    return;\n  }\n  var octets = 1 + (Math.log(len) / Math.LN2 >>> 3);\n  arr.push(octets | 0x80);\n  while (--octets) {\n    arr.push(len >>> (octets << 3) & 0xff);\n  }\n  arr.push(len);\n}\n\nSignature.prototype.toDER = function toDER(enc) {\n  var r = this.r.toArray();\n  var s = this.s.toArray();\n\n  // Pad values\n  if (r[0] & 0x80) r = [0].concat(r);\n  // Pad values\n  if (s[0] & 0x80) s = [0].concat(s);\n\n  r = rmPadding(r);\n  s = rmPadding(s);\n\n  while (!s[0] && !(s[1] & 0x80)) {\n    s = s.slice(1);\n  }\n  var arr = [0x02];\n  constructLength(arr, r.length);\n  arr = arr.concat(r);\n  arr.push(0x02);\n  constructLength(arr, s.length);\n  var backHalf = arr.concat(s);\n  var res = [0x30];\n  constructLength(res, backHalf.length);\n  res = res.concat(backHalf);\n  return utils.encode(res, enc);\n};\n\n/***/ }),\n/* 60 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar hash = __webpack_require__(15);\nvar elliptic = __webpack_require__(0);\nvar utils = elliptic.utils;\nvar assert = utils.assert;\nvar parseBytes = utils.parseBytes;\nvar KeyPair = __webpack_require__(61);\nvar Signature = __webpack_require__(62);\n\nfunction EDDSA(curve) {\n  assert(curve === 'ed25519', 'only tested with ed25519 so far');\n\n  if (!(this instanceof EDDSA)) return new EDDSA(curve);\n\n  var curve = elliptic.curves[curve].curve;\n  this.curve = curve;\n  this.g = curve.g;\n  this.g.precompute(curve.n.bitLength() + 1);\n\n  this.pointClass = curve.point().constructor;\n  this.encodingLength = Math.ceil(curve.n.bitLength() / 8);\n  this.hash = hash.sha512;\n}\n\nmodule.exports = EDDSA;\n\n/**\n* @param {Array|String} message - message bytes\n* @param {Array|String|KeyPair} secret - secret bytes or a keypair\n* @returns {Signature} - signature\n*/\nEDDSA.prototype.sign = function sign(message, secret) {\n  message = parseBytes(message);\n  var key = this.keyFromSecret(secret);\n  var r = this.hashInt(key.messagePrefix(), message);\n  var R = this.g.mul(r);\n  var Rencoded = this.encodePoint(R);\n  var s_ = this.hashInt(Rencoded, key.pubBytes(), message).mul(key.priv());\n  var S = r.add(s_).umod(this.curve.n);\n  return this.makeSignature({ R: R, S: S, Rencoded: Rencoded });\n};\n\n/**\n* @param {Array} message - message bytes\n* @param {Array|String|Signature} sig - sig bytes\n* @param {Array|String|Point|KeyPair} pub - public key\n* @returns {Boolean} - true if public key matches sig of message\n*/\nEDDSA.prototype.verify = function verify(message, sig, pub) {\n  message = parseBytes(message);\n  sig = this.makeSignature(sig);\n  var key = this.keyFromPublic(pub);\n  var h = this.hashInt(sig.Rencoded(), key.pubBytes(), message);\n  var SG = this.g.mul(sig.S());\n  var RplusAh = sig.R().add(key.pub().mul(h));\n  return RplusAh.eq(SG);\n};\n\nEDDSA.prototype.hashInt = function hashInt() {\n  var hash = this.hash();\n  for (var i = 0; i < arguments.length; i++) {\n    hash.update(arguments[i]);\n  }return utils.intFromLE(hash.digest()).umod(this.curve.n);\n};\n\nEDDSA.prototype.keyFromPublic = function keyFromPublic(pub) {\n  return KeyPair.fromPublic(this, pub);\n};\n\nEDDSA.prototype.keyFromSecret = function keyFromSecret(secret) {\n  return KeyPair.fromSecret(this, secret);\n};\n\nEDDSA.prototype.makeSignature = function makeSignature(sig) {\n  if (sig instanceof Signature) return sig;\n  return new Signature(this, sig);\n};\n\n/**\n* * https://tools.ietf.org/html/draft-josefsson-eddsa-ed25519-03#section-5.2\n*\n* EDDSA defines methods for encoding and decoding points and integers. These are\n* helper convenience methods, that pass along to utility functions implied\n* parameters.\n*\n*/\nEDDSA.prototype.encodePoint = function encodePoint(point) {\n  var enc = point.getY().toArray('le', this.encodingLength);\n  enc[this.encodingLength - 1] |= point.getX().isOdd() ? 0x80 : 0;\n  return enc;\n};\n\nEDDSA.prototype.decodePoint = function decodePoint(bytes) {\n  bytes = utils.parseBytes(bytes);\n\n  var lastIx = bytes.length - 1;\n  var normed = bytes.slice(0, lastIx).concat(bytes[lastIx] & ~0x80);\n  var xIsOdd = (bytes[lastIx] & 0x80) !== 0;\n\n  var y = utils.intFromLE(normed);\n  return this.curve.pointFromY(y, xIsOdd);\n};\n\nEDDSA.prototype.encodeInt = function encodeInt(num) {\n  return num.toArray('le', this.encodingLength);\n};\n\nEDDSA.prototype.decodeInt = function decodeInt(bytes) {\n  return utils.intFromLE(bytes);\n};\n\nEDDSA.prototype.isPoint = function isPoint(val) {\n  return val instanceof this.pointClass;\n};\n\n/***/ }),\n/* 61 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar elliptic = __webpack_require__(0);\nvar utils = elliptic.utils;\nvar assert = utils.assert;\nvar parseBytes = utils.parseBytes;\nvar cachedProperty = utils.cachedProperty;\n\n/**\n* @param {EDDSA} eddsa - instance\n* @param {Object} params - public/private key parameters\n*\n* @param {Array<Byte>} [params.secret] - secret seed bytes\n* @param {Point} [params.pub] - public key point (aka `A` in eddsa terms)\n* @param {Array<Byte>} [params.pub] - public key point encoded as bytes\n*\n*/\nfunction KeyPair(eddsa, params) {\n  this.eddsa = eddsa;\n  this._secret = parseBytes(params.secret);\n  if (eddsa.isPoint(params.pub)) this._pub = params.pub;else this._pubBytes = parseBytes(params.pub);\n}\n\nKeyPair.fromPublic = function fromPublic(eddsa, pub) {\n  if (pub instanceof KeyPair) return pub;\n  return new KeyPair(eddsa, { pub: pub });\n};\n\nKeyPair.fromSecret = function fromSecret(eddsa, secret) {\n  if (secret instanceof KeyPair) return secret;\n  return new KeyPair(eddsa, { secret: secret });\n};\n\nKeyPair.prototype.secret = function secret() {\n  return this._secret;\n};\n\ncachedProperty(KeyPair, 'pubBytes', function pubBytes() {\n  return this.eddsa.encodePoint(this.pub());\n});\n\ncachedProperty(KeyPair, 'pub', function pub() {\n  if (this._pubBytes) return this.eddsa.decodePoint(this._pubBytes);\n  return this.eddsa.g.mul(this.priv());\n});\n\ncachedProperty(KeyPair, 'privBytes', function privBytes() {\n  var eddsa = this.eddsa;\n  var hash = this.hash();\n  var lastIx = eddsa.encodingLength - 1;\n\n  var a = hash.slice(0, eddsa.encodingLength);\n  a[0] &= 248;\n  a[lastIx] &= 127;\n  a[lastIx] |= 64;\n\n  return a;\n});\n\ncachedProperty(KeyPair, 'priv', function priv() {\n  return this.eddsa.decodeInt(this.privBytes());\n});\n\ncachedProperty(KeyPair, 'hash', function hash() {\n  return this.eddsa.hash().update(this.secret()).digest();\n});\n\ncachedProperty(KeyPair, 'messagePrefix', function messagePrefix() {\n  return this.hash().slice(this.eddsa.encodingLength);\n});\n\nKeyPair.prototype.sign = function sign(message) {\n  assert(this._secret, 'KeyPair can only verify');\n  return this.eddsa.sign(message, this);\n};\n\nKeyPair.prototype.verify = function verify(message, sig) {\n  return this.eddsa.verify(message, sig, this);\n};\n\nKeyPair.prototype.getSecret = function getSecret(enc) {\n  assert(this._secret, 'KeyPair is public only');\n  return utils.encode(this.secret(), enc);\n};\n\nKeyPair.prototype.getPublic = function getPublic(enc) {\n  return utils.encode(this.pubBytes(), enc);\n};\n\nmodule.exports = KeyPair;\n\n/***/ }),\n/* 62 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; };\n\nvar BN = __webpack_require__(1);\nvar elliptic = __webpack_require__(0);\nvar utils = elliptic.utils;\nvar assert = utils.assert;\nvar cachedProperty = utils.cachedProperty;\nvar parseBytes = utils.parseBytes;\n\n/**\n* @param {EDDSA} eddsa - eddsa instance\n* @param {Array<Bytes>|Object} sig -\n* @param {Array<Bytes>|Point} [sig.R] - R point as Point or bytes\n* @param {Array<Bytes>|bn} [sig.S] - S scalar as bn or bytes\n* @param {Array<Bytes>} [sig.Rencoded] - R point encoded\n* @param {Array<Bytes>} [sig.Sencoded] - S scalar encoded\n*/\nfunction Signature(eddsa, sig) {\n  this.eddsa = eddsa;\n\n  if ((typeof sig === 'undefined' ? 'undefined' : _typeof(sig)) !== 'object') sig = parseBytes(sig);\n\n  if (Array.isArray(sig)) {\n    sig = {\n      R: sig.slice(0, eddsa.encodingLength),\n      S: sig.slice(eddsa.encodingLength)\n    };\n  }\n\n  assert(sig.R && sig.S, 'Signature without R or S');\n\n  if (eddsa.isPoint(sig.R)) this._R = sig.R;\n  if (sig.S instanceof BN) this._S = sig.S;\n\n  this._Rencoded = Array.isArray(sig.R) ? sig.R : sig.Rencoded;\n  this._Sencoded = Array.isArray(sig.S) ? sig.S : sig.Sencoded;\n}\n\ncachedProperty(Signature, 'S', function S() {\n  return this.eddsa.decodeInt(this.Sencoded());\n});\n\ncachedProperty(Signature, 'R', function R() {\n  return this.eddsa.decodePoint(this.Rencoded());\n});\n\ncachedProperty(Signature, 'Rencoded', function Rencoded() {\n  return this.eddsa.encodePoint(this.R());\n});\n\ncachedProperty(Signature, 'Sencoded', function Sencoded() {\n  return this.eddsa.encodeInt(this.S());\n});\n\nSignature.prototype.toBytes = function toBytes() {\n  return this.Rencoded().concat(this.Sencoded());\n};\n\nSignature.prototype.toHex = function toHex() {\n  return utils.encode(this.toBytes(), 'hex').toUpperCase();\n};\n\nmodule.exports = Signature;\n\n/***/ }),\n/* 63 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/* WEBPACK VAR INJECTION */(function(Buffer) {\n\nvar rlp = __webpack_require__(64); // {decode, toBuffer, isHexPrefixed, stripHexPrefix, padToEven, intToBuffer, safeParseInt, bufferToHex}\n\nvar field_sets = {\n  params: [\"nonce\", \"gasPrice\", \"gasLimit\", \"to\", \"value\", \"data\"],\n  signature: [\"v\", \"r\", \"s\"]\n};\n\nvar format_fields = function format_fields(fields, rawData, to_hex, add_prefix) {\n  var txData = {};\n\n  fields.forEach(function (field, index) {\n    if (rawData[index] && rawData[index].length) {\n      txData[field] = to_hex ? rlp.bufferToHex(rawData[index], add_prefix) : rawData[index];\n    }\n  });\n\n  return txData;\n};\n\n// ===\n// API\n// ===\nvar unsign = function unsign(rawTx) {\n  var to_hex = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;\n  var add_prefix_txData = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;\n  var add_prefix_signature = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;\n\n  var rawData = void 0;\n  if (typeof rawTx === 'string') {\n    rawTx = Buffer.from(rlp.stripHexPrefix(rawTx), 'hex');\n  }\n  if (Buffer.isBuffer(rawTx)) {\n    rawData = rlp.decode(rawTx);\n  }\n\n  if (rawData === undefined) throw new Error('TypeError: raw transaction must be either a Buffer or hex-encoded String value');\n  if (!Array.isArray(rawData)) throw new Error('TypeError: raw transaction is not RLP encoded');\n  if (rawData.length < field_sets.params.length + field_sets.signature.length) throw new Error('FormatError: RLP encoded raw transaction contains too few data fields');\n\n  for (var i = 0; i < rawData.length; i++) {\n    rawData[i] = rlp.toBuffer(rawData[i]);\n  }\n\n  var txData = format_fields(field_sets.params, rawData.slice(0, field_sets.params.length), to_hex, add_prefix_txData);\n  var signature = format_fields(field_sets.signature, rawData.slice(field_sets.params.length), to_hex, add_prefix_signature);\n\n  var v_hex = to_hex ? add_prefix_signature ? rlp.stripHexPrefix(signature.v) : signature.v : rlp.bufferToHex(signature.v, false);\n  var v_int = parseInt(v_hex, 16);\n  var chainId = Math.floor((v_int - 35) / 2);\n  if (chainId < 0) chainId = 0;\n  txData['chainId'] = chainId;\n\n  return { txData: txData, signature: signature };\n};\n\nmodule.exports = unsign;\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(2).Buffer))\n\n/***/ }),\n/* 64 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/* WEBPACK VAR INJECTION */(function(Buffer) {\n\n// based on:\n//   https://github.com/ethereumjs/rlp/raw/3122e47f7c2ff2c7efa67acfeabe02a5f3a3670a/index.js\n\nvar assert = __webpack_require__(26);\n\n/**\n * RLP Decoding based on: {@link https://github.com/ethereum/wiki/wiki/%5BEnglish%5D-RLP|RLP}\n * @param {Buffer,String,Integer,Array} data - will be converted to buffer\n * @returns {Array} - returns decode Array of Buffers containg the original message\n **/\nfunction decode(input, stream) {\n  if (!input || input.length === 0) {\n    return new Buffer([]);\n  }\n\n  input = toBuffer(input);\n  var decoded = _decode(input);\n\n  if (stream) {\n    return decoded;\n  }\n\n  assert.equal(decoded.remainder.length, 0, 'invalid remainder');\n  return decoded.data;\n}\n\nfunction toBuffer(v) {\n  if (!Buffer.isBuffer(v)) {\n    if (Array.isArray(v)) {\n      v = Buffer.from(v);\n    } else if (typeof v === 'string') {\n      if (isHexPrefixed(v)) {\n        v = Buffer.from(padToEven(stripHexPrefix(v)), 'hex');\n      } else {\n        v = Buffer.from(v);\n      }\n    } else if (typeof v === 'number') {\n      v = intToBuffer(v);\n    } else if (v === null || v === undefined) {\n      v = Buffer.allocUnsafe(0);\n    } else if (v.toArray) {\n      // converts a BN to a Buffer\n      v = Buffer.from(v.toArray());\n    } else {\n      throw new Error('invalid type');\n    }\n  }\n  return v;\n}\n\nfunction isHexPrefixed(str) {\n  return str.slice(0, 2) === '0x';\n}\n\n// Removes 0x from a given String\nfunction stripHexPrefix(str) {\n  if (typeof str !== 'string') {\n    return str;\n  }\n  return isHexPrefixed(str) ? str.slice(2) : str;\n}\n\nfunction padToEven(a) {\n  if (a.length % 2) a = '0' + a;\n  return a;\n}\n\nfunction intToBuffer(i) {\n  var hex = intToHex(i);\n  return new Buffer(hex, 'hex');\n}\n\nfunction _decode(input) {\n  var length, llength, data, innerRemainder, d;\n  var decoded = [];\n  var firstByte = input[0];\n\n  if (firstByte <= 0x7f) {\n    // a single byte whose value is in the [0x00, 0x7f] range, that byte is its own RLP encoding.\n    return {\n      data: input.slice(0, 1),\n      remainder: input.slice(1)\n    };\n  } else if (firstByte <= 0xb7) {\n    // string is 0-55 bytes long. A single byte with value 0x80 plus the length of the string followed by the string\n    // The range of the first byte is [0x80, 0xb7]\n    length = firstByte - 0x7f;\n\n    // set 0x80 null to 0\n    if (firstByte === 0x80) {\n      data = new Buffer([]);\n    } else {\n      data = input.slice(1, length);\n    }\n\n    if (length === 2 && data[0] < 0x80) {\n      throw new Error('invalid rlp encoding: byte must be less 0x80');\n    }\n\n    return {\n      data: data,\n      remainder: input.slice(length)\n    };\n  } else if (firstByte <= 0xbf) {\n    llength = firstByte - 0xb6;\n    length = safeParseInt(input.slice(1, llength).toString('hex'), 16);\n    data = input.slice(llength, length + llength);\n    if (data.length < length) {\n      throw new Error('invalid RLP');\n    }\n\n    return {\n      data: data,\n      remainder: input.slice(length + llength)\n    };\n  } else if (firstByte <= 0xf7) {\n    // a list between  0-55 bytes long\n    length = firstByte - 0xbf;\n    innerRemainder = input.slice(1, length);\n    while (innerRemainder.length) {\n      d = _decode(innerRemainder);\n      decoded.push(d.data);\n      innerRemainder = d.remainder;\n    }\n\n    return {\n      data: decoded,\n      remainder: input.slice(length)\n    };\n  } else {\n    // a list  over 55 bytes long\n    llength = firstByte - 0xf6;\n    length = safeParseInt(input.slice(1, llength).toString('hex'), 16);\n    var totalLength = llength + length;\n    if (totalLength > input.length) {\n      throw new Error('invalid rlp: total length is larger than the data');\n    }\n\n    innerRemainder = input.slice(llength, totalLength);\n    if (innerRemainder.length === 0) {\n      throw new Error('invalid rlp, List has a invalid length');\n    }\n\n    while (innerRemainder.length) {\n      d = _decode(innerRemainder);\n      decoded.push(d.data);\n      innerRemainder = d.remainder;\n    }\n    return {\n      data: decoded,\n      remainder: input.slice(totalLength)\n    };\n  }\n}\n\nfunction safeParseInt(v, base) {\n  if (v.slice(0, 2) === '00') {\n    throw new Error('invalid RLP: extra zeros');\n  }\n\n  return parseInt(v, base);\n}\n\nfunction bufferToHex(buf) {\n  var add_prefix = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;\n\n  buf = toBuffer(buf);\n  if (!buf || buf.length === 0) return '';else return (add_prefix ? '0x' : '') + buf.toString('hex');\n}\n\nmodule.exports = { decode: decode, toBuffer: toBuffer, isHexPrefixed: isHexPrefixed, stripHexPrefix: stripHexPrefix, padToEven: padToEven, intToBuffer: intToBuffer, safeParseInt: safeParseInt, bufferToHex: bufferToHex };\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(2).Buffer))\n\n/***/ }),\n/* 65 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; };\n\nmodule.exports = function isBuffer(arg) {\n  return arg && (typeof arg === 'undefined' ? 'undefined' : _typeof(arg)) === 'object' && typeof arg.copy === 'function' && typeof arg.fill === 'function' && typeof arg.readUInt8 === 'function';\n};\n\n/***/ }),\n/* 66 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar createKeccak = __webpack_require__(67);\nvar createShake = __webpack_require__(78);\n\nmodule.exports = function (KeccakState) {\n  var Keccak = createKeccak(KeccakState);\n  var Shake = createShake(KeccakState);\n\n  return function (algorithm, options) {\n    var hash = typeof algorithm === 'string' ? algorithm.toLowerCase() : algorithm;\n    switch (hash) {\n      case 'keccak224':\n        return new Keccak(1152, 448, null, 224, options);\n      case 'keccak256':\n        return new Keccak(1088, 512, null, 256, options);\n      case 'keccak384':\n        return new Keccak(832, 768, null, 384, options);\n      case 'keccak512':\n        return new Keccak(576, 1024, null, 512, options);\n\n      case 'sha3-224':\n        return new Keccak(1152, 448, 0x06, 224, options);\n      case 'sha3-256':\n        return new Keccak(1088, 512, 0x06, 256, options);\n      case 'sha3-384':\n        return new Keccak(832, 768, 0x06, 384, options);\n      case 'sha3-512':\n        return new Keccak(576, 1024, 0x06, 512, options);\n\n      case 'shake128':\n        return new Shake(1344, 256, 0x1f, options);\n      case 'shake256':\n        return new Shake(1088, 512, 0x1f, options);\n\n      default:\n        throw new Error('Invald algorithm: ' + algorithm);\n    }\n  };\n};\n\n/***/ }),\n/* 67 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/* WEBPACK VAR INJECTION */(function(Buffer) {\n\nvar Transform = __webpack_require__(27).Transform;\nvar inherits = __webpack_require__(16).inherits;\n\nmodule.exports = function (KeccakState) {\n  function Keccak(rate, capacity, delimitedSuffix, hashBitLength, options) {\n    Transform.call(this, options);\n\n    this._rate = rate;\n    this._capacity = capacity;\n    this._delimitedSuffix = delimitedSuffix;\n    this._hashBitLength = hashBitLength;\n    this._options = options;\n\n    this._state = new KeccakState();\n    this._state.initialize(rate, capacity);\n    this._finalized = false;\n  }\n\n  inherits(Keccak, Transform);\n\n  Keccak.prototype._transform = function (chunk, encoding, callback) {\n    var error = null;\n    try {\n      this.update(chunk, encoding);\n    } catch (err) {\n      error = err;\n    }\n\n    callback(error);\n  };\n\n  Keccak.prototype._flush = function (callback) {\n    var error = null;\n    try {\n      this.push(this.digest());\n    } catch (err) {\n      error = err;\n    }\n\n    callback(error);\n  };\n\n  Keccak.prototype.update = function (data, encoding) {\n    if (!Buffer.isBuffer(data) && typeof data !== 'string') throw new TypeError('Data must be a string or a buffer');\n    if (this._finalized) throw new Error('Digest already called');\n    if (!Buffer.isBuffer(data)) data = Buffer.from(data, encoding);\n\n    this._state.absorb(data);\n\n    return this;\n  };\n\n  Keccak.prototype.digest = function (encoding) {\n    if (this._finalized) throw new Error('Digest already called');\n    this._finalized = true;\n\n    if (this._delimitedSuffix) this._state.absorbLastFewBits(this._delimitedSuffix);\n    var digest = this._state.squeeze(this._hashBitLength / 8);\n    if (encoding !== undefined) digest = digest.toString(encoding);\n\n    this._resetState();\n\n    return digest;\n  };\n\n  // remove result from memory\n  Keccak.prototype._resetState = function () {\n    this._state.initialize(this._rate, this._capacity);\n    return this;\n  };\n\n  // because sometimes we need hash right now and little later\n  Keccak.prototype._clone = function () {\n    var clone = new Keccak(this._rate, this._capacity, this._delimitedSuffix, this._hashBitLength, this._options);\n    this._state.copy(clone._state);\n    clone._finalized = this._finalized;\n\n    return clone;\n  };\n\n  return Keccak;\n};\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(2).Buffer))\n\n/***/ }),\n/* 68 */\n/***/ (function(module, exports) {\n\n/* (ignored) */\n\n/***/ }),\n/* 69 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\n/*<replacement>*/\n\nfunction _classCallCheck(instance, Constructor) {\n  if (!(instance instanceof Constructor)) {\n    throw new TypeError(\"Cannot call a class as a function\");\n  }\n}\n\nvar Buffer = __webpack_require__(14).Buffer;\n/*</replacement>*/\n\nfunction copyBuffer(src, target, offset) {\n  src.copy(target, offset);\n}\n\nmodule.exports = function () {\n  function BufferList() {\n    _classCallCheck(this, BufferList);\n\n    this.head = null;\n    this.tail = null;\n    this.length = 0;\n  }\n\n  BufferList.prototype.push = function push(v) {\n    var entry = { data: v, next: null };\n    if (this.length > 0) this.tail.next = entry;else this.head = entry;\n    this.tail = entry;\n    ++this.length;\n  };\n\n  BufferList.prototype.unshift = function unshift(v) {\n    var entry = { data: v, next: this.head };\n    if (this.length === 0) this.tail = entry;\n    this.head = entry;\n    ++this.length;\n  };\n\n  BufferList.prototype.shift = function shift() {\n    if (this.length === 0) return;\n    var ret = this.head.data;\n    if (this.length === 1) this.head = this.tail = null;else this.head = this.head.next;\n    --this.length;\n    return ret;\n  };\n\n  BufferList.prototype.clear = function clear() {\n    this.head = this.tail = null;\n    this.length = 0;\n  };\n\n  BufferList.prototype.join = function join(s) {\n    if (this.length === 0) return '';\n    var p = this.head;\n    var ret = '' + p.data;\n    while (p = p.next) {\n      ret += s + p.data;\n    }return ret;\n  };\n\n  BufferList.prototype.concat = function concat(n) {\n    if (this.length === 0) return Buffer.alloc(0);\n    if (this.length === 1) return this.head.data;\n    var ret = Buffer.allocUnsafe(n >>> 0);\n    var p = this.head;\n    var i = 0;\n    while (p) {\n      copyBuffer(p.data, ret, i);\n      i += p.data.length;\n      p = p.next;\n    }\n    return ret;\n  };\n\n  return BufferList;\n}();\n\n/***/ }),\n/* 70 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar apply = Function.prototype.apply;\n\n// DOM APIs, for completeness\n\nexports.setTimeout = function () {\n  return new Timeout(apply.call(setTimeout, window, arguments), clearTimeout);\n};\nexports.setInterval = function () {\n  return new Timeout(apply.call(setInterval, window, arguments), clearInterval);\n};\nexports.clearTimeout = exports.clearInterval = function (timeout) {\n  if (timeout) {\n    timeout.close();\n  }\n};\n\nfunction Timeout(id, clearFn) {\n  this._id = id;\n  this._clearFn = clearFn;\n}\nTimeout.prototype.unref = Timeout.prototype.ref = function () {};\nTimeout.prototype.close = function () {\n  this._clearFn.call(window, this._id);\n};\n\n// Does not start the time, just sets up the members needed.\nexports.enroll = function (item, msecs) {\n  clearTimeout(item._idleTimeoutId);\n  item._idleTimeout = msecs;\n};\n\nexports.unenroll = function (item) {\n  clearTimeout(item._idleTimeoutId);\n  item._idleTimeout = -1;\n};\n\nexports._unrefActive = exports.active = function (item) {\n  clearTimeout(item._idleTimeoutId);\n\n  var msecs = item._idleTimeout;\n  if (msecs >= 0) {\n    item._idleTimeoutId = setTimeout(function onTimeout() {\n      if (item._onTimeout) item._onTimeout();\n    }, msecs);\n  }\n};\n\n// setimmediate attaches itself to the global object\n__webpack_require__(71);\nexports.setImmediate = setImmediate;\nexports.clearImmediate = clearImmediate;\n\n/***/ }),\n/* 71 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/* WEBPACK VAR INJECTION */(function(global, process) {\n\n(function (global, undefined) {\n    \"use strict\";\n\n    if (global.setImmediate) {\n        return;\n    }\n\n    var nextHandle = 1; // Spec says greater than zero\n    var tasksByHandle = {};\n    var currentlyRunningATask = false;\n    var doc = global.document;\n    var registerImmediate;\n\n    function setImmediate(callback) {\n        // Callback can either be a function or a string\n        if (typeof callback !== \"function\") {\n            callback = new Function(\"\" + callback);\n        }\n        // Copy function arguments\n        var args = new Array(arguments.length - 1);\n        for (var i = 0; i < args.length; i++) {\n            args[i] = arguments[i + 1];\n        }\n        // Store and register the task\n        var task = { callback: callback, args: args };\n        tasksByHandle[nextHandle] = task;\n        registerImmediate(nextHandle);\n        return nextHandle++;\n    }\n\n    function clearImmediate(handle) {\n        delete tasksByHandle[handle];\n    }\n\n    function run(task) {\n        var callback = task.callback;\n        var args = task.args;\n        switch (args.length) {\n            case 0:\n                callback();\n                break;\n            case 1:\n                callback(args[0]);\n                break;\n            case 2:\n                callback(args[0], args[1]);\n                break;\n            case 3:\n                callback(args[0], args[1], args[2]);\n                break;\n            default:\n                callback.apply(undefined, args);\n                break;\n        }\n    }\n\n    function runIfPresent(handle) {\n        // From the spec: \"Wait until any invocations of this algorithm started before this one have completed.\"\n        // So if we're currently running a task, we'll need to delay this invocation.\n        if (currentlyRunningATask) {\n            // Delay by doing a setTimeout. setImmediate was tried instead, but in Firefox 7 it generated a\n            // \"too much recursion\" error.\n            setTimeout(runIfPresent, 0, handle);\n        } else {\n            var task = tasksByHandle[handle];\n            if (task) {\n                currentlyRunningATask = true;\n                try {\n                    run(task);\n                } finally {\n                    clearImmediate(handle);\n                    currentlyRunningATask = false;\n                }\n            }\n        }\n    }\n\n    function installNextTickImplementation() {\n        registerImmediate = function registerImmediate(handle) {\n            process.nextTick(function () {\n                runIfPresent(handle);\n            });\n        };\n    }\n\n    function canUsePostMessage() {\n        // The test against `importScripts` prevents this implementation from being installed inside a web worker,\n        // where `global.postMessage` means something completely different and can't be used for this purpose.\n        if (global.postMessage && !global.importScripts) {\n            var postMessageIsAsynchronous = true;\n            var oldOnMessage = global.onmessage;\n            global.onmessage = function () {\n                postMessageIsAsynchronous = false;\n            };\n            global.postMessage(\"\", \"*\");\n            global.onmessage = oldOnMessage;\n            return postMessageIsAsynchronous;\n        }\n    }\n\n    function installPostMessageImplementation() {\n        // Installs an event handler on `global` for the `message` event: see\n        // * https://developer.mozilla.org/en/DOM/window.postMessage\n        // * http://www.whatwg.org/specs/web-apps/current-work/multipage/comms.html#crossDocumentMessages\n\n        var messagePrefix = \"setImmediate$\" + Math.random() + \"$\";\n        var onGlobalMessage = function onGlobalMessage(event) {\n            if (event.source === global && typeof event.data === \"string\" && event.data.indexOf(messagePrefix) === 0) {\n                runIfPresent(+event.data.slice(messagePrefix.length));\n            }\n        };\n\n        if (global.addEventListener) {\n            global.addEventListener(\"message\", onGlobalMessage, false);\n        } else {\n            global.attachEvent(\"onmessage\", onGlobalMessage);\n        }\n\n        registerImmediate = function registerImmediate(handle) {\n            global.postMessage(messagePrefix + handle, \"*\");\n        };\n    }\n\n    function installMessageChannelImplementation() {\n        var channel = new MessageChannel();\n        channel.port1.onmessage = function (event) {\n            var handle = event.data;\n            runIfPresent(handle);\n        };\n\n        registerImmediate = function registerImmediate(handle) {\n            channel.port2.postMessage(handle);\n        };\n    }\n\n    function installReadyStateChangeImplementation() {\n        var html = doc.documentElement;\n        registerImmediate = function registerImmediate(handle) {\n            // Create a <script> element; its readystatechange event will be fired asynchronously once it is inserted\n            // into the document. Do so, thus queuing up the task. Remember to clean up once it's been called.\n            var script = doc.createElement(\"script\");\n            script.onreadystatechange = function () {\n                runIfPresent(handle);\n                script.onreadystatechange = null;\n                html.removeChild(script);\n                script = null;\n            };\n            html.appendChild(script);\n        };\n    }\n\n    function installSetTimeoutImplementation() {\n        registerImmediate = function registerImmediate(handle) {\n            setTimeout(runIfPresent, 0, handle);\n        };\n    }\n\n    // If supported, we should attach to the prototype of global, since that is where setTimeout et al. live.\n    var attachTo = Object.getPrototypeOf && Object.getPrototypeOf(global);\n    attachTo = attachTo && attachTo.setTimeout ? attachTo : global;\n\n    // Don't get fooled by e.g. browserify environments.\n    if ({}.toString.call(global.process) === \"[object process]\") {\n        // For Node.js before 0.9\n        installNextTickImplementation();\n    } else if (canUsePostMessage()) {\n        // For non-IE10 modern browsers\n        installPostMessageImplementation();\n    } else if (global.MessageChannel) {\n        // For web workers, where supported\n        installMessageChannelImplementation();\n    } else if (doc && \"onreadystatechange\" in doc.createElement(\"script\")) {\n        // For IE 6–8\n        installReadyStateChangeImplementation();\n    } else {\n        // For older browsers\n        installSetTimeoutImplementation();\n    }\n\n    attachTo.setImmediate = setImmediate;\n    attachTo.clearImmediate = clearImmediate;\n})(typeof self === \"undefined\" ? typeof global === \"undefined\" ? undefined : global : self);\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(5), __webpack_require__(9)))\n\n/***/ }),\n/* 72 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/* WEBPACK VAR INJECTION */(function(global) {\n\n/**\n * Module exports.\n */\n\nmodule.exports = deprecate;\n\n/**\n * Mark that a method should not be used.\n * Returns a modified function which warns once by default.\n *\n * If `localStorage.noDeprecation = true` is set, then it is a no-op.\n *\n * If `localStorage.throwDeprecation = true` is set, then deprecated functions\n * will throw an Error when invoked.\n *\n * If `localStorage.traceDeprecation = true` is set, then deprecated functions\n * will invoke `console.trace()` instead of `console.error()`.\n *\n * @param {Function} fn - the function to deprecate\n * @param {String} msg - the string to print to the console when `fn` is invoked\n * @returns {Function} a new \"deprecated\" version of `fn`\n * @api public\n */\n\nfunction deprecate(fn, msg) {\n  if (config('noDeprecation')) {\n    return fn;\n  }\n\n  var warned = false;\n  function deprecated() {\n    if (!warned) {\n      if (config('throwDeprecation')) {\n        throw new Error(msg);\n      } else if (config('traceDeprecation')) {\n        console.trace(msg);\n      } else {\n        console.warn(msg);\n      }\n      warned = true;\n    }\n    return fn.apply(this, arguments);\n  }\n\n  return deprecated;\n}\n\n/**\n * Checks `localStorage` for boolean values for the given `name`.\n *\n * @param {String} name\n * @returns {Boolean}\n * @api private\n */\n\nfunction config(name) {\n  // accessing global.localStorage can trigger a DOMException in sandboxed iframes\n  try {\n    if (!global.localStorage) return false;\n  } catch (_) {\n    return false;\n  }\n  var val = global.localStorage[name];\n  if (null == val) return false;\n  return String(val).toLowerCase() === 'true';\n}\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(5)))\n\n/***/ }),\n/* 73 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// a passthrough stream.\n// basically just the most minimal sort of Transform stream.\n// Every written chunk gets output as-is.\n\n\n\nmodule.exports = PassThrough;\n\nvar Transform = __webpack_require__(32);\n\n/*<replacement>*/\nvar util = __webpack_require__(10);\nutil.inherits = __webpack_require__(3);\n/*</replacement>*/\n\nutil.inherits(PassThrough, Transform);\n\nfunction PassThrough(options) {\n  if (!(this instanceof PassThrough)) return new PassThrough(options);\n\n  Transform.call(this, options);\n}\n\nPassThrough.prototype._transform = function (chunk, encoding, cb) {\n  cb(null, chunk);\n};\n\n/***/ }),\n/* 74 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nmodule.exports = __webpack_require__(20);\n\n/***/ }),\n/* 75 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nmodule.exports = __webpack_require__(7);\n\n/***/ }),\n/* 76 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nmodule.exports = __webpack_require__(19).Transform;\n\n/***/ }),\n/* 77 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nmodule.exports = __webpack_require__(19).PassThrough;\n\n/***/ }),\n/* 78 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/* WEBPACK VAR INJECTION */(function(Buffer) {\n\nvar Transform = __webpack_require__(27).Transform;\nvar inherits = __webpack_require__(16).inherits;\n\nmodule.exports = function (KeccakState) {\n  function Shake(rate, capacity, delimitedSuffix, options) {\n    Transform.call(this, options);\n\n    this._rate = rate;\n    this._capacity = capacity;\n    this._delimitedSuffix = delimitedSuffix;\n    this._options = options;\n\n    this._state = new KeccakState();\n    this._state.initialize(rate, capacity);\n    this._finalized = false;\n  }\n\n  inherits(Shake, Transform);\n\n  Shake.prototype._transform = function (chunk, encoding, callback) {\n    var error = null;\n    try {\n      this.update(chunk, encoding);\n    } catch (err) {\n      error = err;\n    }\n\n    callback(error);\n  };\n\n  Shake.prototype._flush = function () {};\n\n  Shake.prototype._read = function (size) {\n    this.push(this.squeeze(size));\n  };\n\n  Shake.prototype.update = function (data, encoding) {\n    if (!Buffer.isBuffer(data) && typeof data !== 'string') throw new TypeError('Data must be a string or a buffer');\n    if (this._finalized) throw new Error('Squeeze already called');\n    if (!Buffer.isBuffer(data)) data = Buffer.from(data, encoding);\n\n    this._state.absorb(data);\n\n    return this;\n  };\n\n  Shake.prototype.squeeze = function (dataByteLength, encoding) {\n    if (!this._finalized) {\n      this._finalized = true;\n      this._state.absorbLastFewBits(this._delimitedSuffix);\n    }\n\n    var data = this._state.squeeze(dataByteLength);\n    if (encoding !== undefined) data = data.toString(encoding);\n\n    return data;\n  };\n\n  Shake.prototype._resetState = function () {\n    this._state.initialize(this._rate, this._capacity);\n    return this;\n  };\n\n  Shake.prototype._clone = function () {\n    var clone = new Shake(this._rate, this._capacity, this._delimitedSuffix, this._options);\n    this._state.copy(clone._state);\n    clone._finalized = this._finalized;\n\n    return clone;\n  };\n\n  return Shake;\n};\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(2).Buffer))\n\n/***/ }),\n/* 79 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/* WEBPACK VAR INJECTION */(function(Buffer) {\n\nvar keccakState = __webpack_require__(80);\n\nfunction Keccak() {\n  // much faster than `new Array(50)`\n  this.state = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];\n\n  this.blockSize = null;\n  this.count = 0;\n  this.squeezing = false;\n}\n\nKeccak.prototype.initialize = function (rate, capacity) {\n  for (var i = 0; i < 50; ++i) {\n    this.state[i] = 0;\n  }this.blockSize = rate / 8;\n  this.count = 0;\n  this.squeezing = false;\n};\n\nKeccak.prototype.absorb = function (data) {\n  for (var i = 0; i < data.length; ++i) {\n    this.state[~~(this.count / 4)] ^= data[i] << 8 * (this.count % 4);\n    this.count += 1;\n    if (this.count === this.blockSize) {\n      keccakState.p1600(this.state);\n      this.count = 0;\n    }\n  }\n};\n\nKeccak.prototype.absorbLastFewBits = function (bits) {\n  this.state[~~(this.count / 4)] ^= bits << 8 * (this.count % 4);\n  if ((bits & 0x80) !== 0 && this.count === this.blockSize - 1) keccakState.p1600(this.state);\n  this.state[~~((this.blockSize - 1) / 4)] ^= 0x80 << 8 * ((this.blockSize - 1) % 4);\n  keccakState.p1600(this.state);\n  this.count = 0;\n  this.squeezing = true;\n};\n\nKeccak.prototype.squeeze = function (length) {\n  if (!this.squeezing) this.absorbLastFewBits(0x01);\n\n  var output = Buffer.alloc(length);\n  for (var i = 0; i < length; ++i) {\n    output[i] = this.state[~~(this.count / 4)] >>> 8 * (this.count % 4) & 0xff;\n    this.count += 1;\n    if (this.count === this.blockSize) {\n      keccakState.p1600(this.state);\n      this.count = 0;\n    }\n  }\n\n  return output;\n};\n\nKeccak.prototype.copy = function (dest) {\n  for (var i = 0; i < 50; ++i) {\n    dest.state[i] = this.state[i];\n  }dest.blockSize = this.blockSize;\n  dest.count = this.count;\n  dest.squeezing = this.squeezing;\n};\n\nmodule.exports = Keccak;\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(2).Buffer))\n\n/***/ }),\n/* 80 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar P1600_ROUND_CONSTANTS = [1, 0, 32898, 0, 32906, 2147483648, 2147516416, 2147483648, 32907, 0, 2147483649, 0, 2147516545, 2147483648, 32777, 2147483648, 138, 0, 136, 0, 2147516425, 0, 2147483658, 0, 2147516555, 0, 139, 2147483648, 32905, 2147483648, 32771, 2147483648, 32770, 2147483648, 128, 2147483648, 32778, 0, 2147483658, 2147483648, 2147516545, 2147483648, 32896, 2147483648, 2147483649, 0, 2147516424, 2147483648];\n\nexports.p1600 = function (s) {\n    for (var round = 0; round < 24; ++round) {\n        // theta\n        var lo0 = s[0] ^ s[10] ^ s[20] ^ s[30] ^ s[40];\n        var hi0 = s[1] ^ s[11] ^ s[21] ^ s[31] ^ s[41];\n        var lo1 = s[2] ^ s[12] ^ s[22] ^ s[32] ^ s[42];\n        var hi1 = s[3] ^ s[13] ^ s[23] ^ s[33] ^ s[43];\n        var lo2 = s[4] ^ s[14] ^ s[24] ^ s[34] ^ s[44];\n        var hi2 = s[5] ^ s[15] ^ s[25] ^ s[35] ^ s[45];\n        var lo3 = s[6] ^ s[16] ^ s[26] ^ s[36] ^ s[46];\n        var hi3 = s[7] ^ s[17] ^ s[27] ^ s[37] ^ s[47];\n        var lo4 = s[8] ^ s[18] ^ s[28] ^ s[38] ^ s[48];\n        var hi4 = s[9] ^ s[19] ^ s[29] ^ s[39] ^ s[49];\n\n        var lo = lo4 ^ (lo1 << 1 | hi1 >>> 31);\n        var hi = hi4 ^ (hi1 << 1 | lo1 >>> 31);\n        var t1slo0 = s[0] ^ lo;\n        var t1shi0 = s[1] ^ hi;\n        var t1slo5 = s[10] ^ lo;\n        var t1shi5 = s[11] ^ hi;\n        var t1slo10 = s[20] ^ lo;\n        var t1shi10 = s[21] ^ hi;\n        var t1slo15 = s[30] ^ lo;\n        var t1shi15 = s[31] ^ hi;\n        var t1slo20 = s[40] ^ lo;\n        var t1shi20 = s[41] ^ hi;\n        lo = lo0 ^ (lo2 << 1 | hi2 >>> 31);\n        hi = hi0 ^ (hi2 << 1 | lo2 >>> 31);\n        var t1slo1 = s[2] ^ lo;\n        var t1shi1 = s[3] ^ hi;\n        var t1slo6 = s[12] ^ lo;\n        var t1shi6 = s[13] ^ hi;\n        var t1slo11 = s[22] ^ lo;\n        var t1shi11 = s[23] ^ hi;\n        var t1slo16 = s[32] ^ lo;\n        var t1shi16 = s[33] ^ hi;\n        var t1slo21 = s[42] ^ lo;\n        var t1shi21 = s[43] ^ hi;\n        lo = lo1 ^ (lo3 << 1 | hi3 >>> 31);\n        hi = hi1 ^ (hi3 << 1 | lo3 >>> 31);\n        var t1slo2 = s[4] ^ lo;\n        var t1shi2 = s[5] ^ hi;\n        var t1slo7 = s[14] ^ lo;\n        var t1shi7 = s[15] ^ hi;\n        var t1slo12 = s[24] ^ lo;\n        var t1shi12 = s[25] ^ hi;\n        var t1slo17 = s[34] ^ lo;\n        var t1shi17 = s[35] ^ hi;\n        var t1slo22 = s[44] ^ lo;\n        var t1shi22 = s[45] ^ hi;\n        lo = lo2 ^ (lo4 << 1 | hi4 >>> 31);\n        hi = hi2 ^ (hi4 << 1 | lo4 >>> 31);\n        var t1slo3 = s[6] ^ lo;\n        var t1shi3 = s[7] ^ hi;\n        var t1slo8 = s[16] ^ lo;\n        var t1shi8 = s[17] ^ hi;\n        var t1slo13 = s[26] ^ lo;\n        var t1shi13 = s[27] ^ hi;\n        var t1slo18 = s[36] ^ lo;\n        var t1shi18 = s[37] ^ hi;\n        var t1slo23 = s[46] ^ lo;\n        var t1shi23 = s[47] ^ hi;\n        lo = lo3 ^ (lo0 << 1 | hi0 >>> 31);\n        hi = hi3 ^ (hi0 << 1 | lo0 >>> 31);\n        var t1slo4 = s[8] ^ lo;\n        var t1shi4 = s[9] ^ hi;\n        var t1slo9 = s[18] ^ lo;\n        var t1shi9 = s[19] ^ hi;\n        var t1slo14 = s[28] ^ lo;\n        var t1shi14 = s[29] ^ hi;\n        var t1slo19 = s[38] ^ lo;\n        var t1shi19 = s[39] ^ hi;\n        var t1slo24 = s[48] ^ lo;\n        var t1shi24 = s[49] ^ hi;\n\n        // rho & pi\n        var t2slo0 = t1slo0;\n        var t2shi0 = t1shi0;\n        var t2slo16 = t1shi5 << 4 | t1slo5 >>> 28;\n        var t2shi16 = t1slo5 << 4 | t1shi5 >>> 28;\n        var t2slo7 = t1slo10 << 3 | t1shi10 >>> 29;\n        var t2shi7 = t1shi10 << 3 | t1slo10 >>> 29;\n        var t2slo23 = t1shi15 << 9 | t1slo15 >>> 23;\n        var t2shi23 = t1slo15 << 9 | t1shi15 >>> 23;\n        var t2slo14 = t1slo20 << 18 | t1shi20 >>> 14;\n        var t2shi14 = t1shi20 << 18 | t1slo20 >>> 14;\n        var t2slo10 = t1slo1 << 1 | t1shi1 >>> 31;\n        var t2shi10 = t1shi1 << 1 | t1slo1 >>> 31;\n        var t2slo1 = t1shi6 << 12 | t1slo6 >>> 20;\n        var t2shi1 = t1slo6 << 12 | t1shi6 >>> 20;\n        var t2slo17 = t1slo11 << 10 | t1shi11 >>> 22;\n        var t2shi17 = t1shi11 << 10 | t1slo11 >>> 22;\n        var t2slo8 = t1shi16 << 13 | t1slo16 >>> 19;\n        var t2shi8 = t1slo16 << 13 | t1shi16 >>> 19;\n        var t2slo24 = t1slo21 << 2 | t1shi21 >>> 30;\n        var t2shi24 = t1shi21 << 2 | t1slo21 >>> 30;\n        var t2slo20 = t1shi2 << 30 | t1slo2 >>> 2;\n        var t2shi20 = t1slo2 << 30 | t1shi2 >>> 2;\n        var t2slo11 = t1slo7 << 6 | t1shi7 >>> 26;\n        var t2shi11 = t1shi7 << 6 | t1slo7 >>> 26;\n        var t2slo2 = t1shi12 << 11 | t1slo12 >>> 21;\n        var t2shi2 = t1slo12 << 11 | t1shi12 >>> 21;\n        var t2slo18 = t1slo17 << 15 | t1shi17 >>> 17;\n        var t2shi18 = t1shi17 << 15 | t1slo17 >>> 17;\n        var t2slo9 = t1shi22 << 29 | t1slo22 >>> 3;\n        var t2shi9 = t1slo22 << 29 | t1shi22 >>> 3;\n        var t2slo5 = t1slo3 << 28 | t1shi3 >>> 4;\n        var t2shi5 = t1shi3 << 28 | t1slo3 >>> 4;\n        var t2slo21 = t1shi8 << 23 | t1slo8 >>> 9;\n        var t2shi21 = t1slo8 << 23 | t1shi8 >>> 9;\n        var t2slo12 = t1slo13 << 25 | t1shi13 >>> 7;\n        var t2shi12 = t1shi13 << 25 | t1slo13 >>> 7;\n        var t2slo3 = t1slo18 << 21 | t1shi18 >>> 11;\n        var t2shi3 = t1shi18 << 21 | t1slo18 >>> 11;\n        var t2slo19 = t1shi23 << 24 | t1slo23 >>> 8;\n        var t2shi19 = t1slo23 << 24 | t1shi23 >>> 8;\n        var t2slo15 = t1slo4 << 27 | t1shi4 >>> 5;\n        var t2shi15 = t1shi4 << 27 | t1slo4 >>> 5;\n        var t2slo6 = t1slo9 << 20 | t1shi9 >>> 12;\n        var t2shi6 = t1shi9 << 20 | t1slo9 >>> 12;\n        var t2slo22 = t1shi14 << 7 | t1slo14 >>> 25;\n        var t2shi22 = t1slo14 << 7 | t1shi14 >>> 25;\n        var t2slo13 = t1slo19 << 8 | t1shi19 >>> 24;\n        var t2shi13 = t1shi19 << 8 | t1slo19 >>> 24;\n        var t2slo4 = t1slo24 << 14 | t1shi24 >>> 18;\n        var t2shi4 = t1shi24 << 14 | t1slo24 >>> 18;\n\n        // chi\n        s[0] = t2slo0 ^ ~t2slo1 & t2slo2;\n        s[1] = t2shi0 ^ ~t2shi1 & t2shi2;\n        s[10] = t2slo5 ^ ~t2slo6 & t2slo7;\n        s[11] = t2shi5 ^ ~t2shi6 & t2shi7;\n        s[20] = t2slo10 ^ ~t2slo11 & t2slo12;\n        s[21] = t2shi10 ^ ~t2shi11 & t2shi12;\n        s[30] = t2slo15 ^ ~t2slo16 & t2slo17;\n        s[31] = t2shi15 ^ ~t2shi16 & t2shi17;\n        s[40] = t2slo20 ^ ~t2slo21 & t2slo22;\n        s[41] = t2shi20 ^ ~t2shi21 & t2shi22;\n        s[2] = t2slo1 ^ ~t2slo2 & t2slo3;\n        s[3] = t2shi1 ^ ~t2shi2 & t2shi3;\n        s[12] = t2slo6 ^ ~t2slo7 & t2slo8;\n        s[13] = t2shi6 ^ ~t2shi7 & t2shi8;\n        s[22] = t2slo11 ^ ~t2slo12 & t2slo13;\n        s[23] = t2shi11 ^ ~t2shi12 & t2shi13;\n        s[32] = t2slo16 ^ ~t2slo17 & t2slo18;\n        s[33] = t2shi16 ^ ~t2shi17 & t2shi18;\n        s[42] = t2slo21 ^ ~t2slo22 & t2slo23;\n        s[43] = t2shi21 ^ ~t2shi22 & t2shi23;\n        s[4] = t2slo2 ^ ~t2slo3 & t2slo4;\n        s[5] = t2shi2 ^ ~t2shi3 & t2shi4;\n        s[14] = t2slo7 ^ ~t2slo8 & t2slo9;\n        s[15] = t2shi7 ^ ~t2shi8 & t2shi9;\n        s[24] = t2slo12 ^ ~t2slo13 & t2slo14;\n        s[25] = t2shi12 ^ ~t2shi13 & t2shi14;\n        s[34] = t2slo17 ^ ~t2slo18 & t2slo19;\n        s[35] = t2shi17 ^ ~t2shi18 & t2shi19;\n        s[44] = t2slo22 ^ ~t2slo23 & t2slo24;\n        s[45] = t2shi22 ^ ~t2shi23 & t2shi24;\n        s[6] = t2slo3 ^ ~t2slo4 & t2slo0;\n        s[7] = t2shi3 ^ ~t2shi4 & t2shi0;\n        s[16] = t2slo8 ^ ~t2slo9 & t2slo5;\n        s[17] = t2shi8 ^ ~t2shi9 & t2shi5;\n        s[26] = t2slo13 ^ ~t2slo14 & t2slo10;\n        s[27] = t2shi13 ^ ~t2shi14 & t2shi10;\n        s[36] = t2slo18 ^ ~t2slo19 & t2slo15;\n        s[37] = t2shi18 ^ ~t2shi19 & t2shi15;\n        s[46] = t2slo23 ^ ~t2slo24 & t2slo20;\n        s[47] = t2shi23 ^ ~t2shi24 & t2shi20;\n        s[8] = t2slo4 ^ ~t2slo0 & t2slo1;\n        s[9] = t2shi4 ^ ~t2shi0 & t2shi1;\n        s[18] = t2slo9 ^ ~t2slo5 & t2slo6;\n        s[19] = t2shi9 ^ ~t2shi5 & t2shi6;\n        s[28] = t2slo14 ^ ~t2slo10 & t2slo11;\n        s[29] = t2shi14 ^ ~t2shi10 & t2shi11;\n        s[38] = t2slo19 ^ ~t2slo15 & t2slo16;\n        s[39] = t2shi19 ^ ~t2shi15 & t2shi16;\n        s[48] = t2slo24 ^ ~t2slo20 & t2slo21;\n        s[49] = t2shi24 ^ ~t2shi20 & t2shi21;\n\n        // iota\n        s[0] ^= P1600_ROUND_CONSTANTS[round * 2];\n        s[1] ^= P1600_ROUND_CONSTANTS[round * 2 + 1];\n    }\n};\n\n/***/ })\n/******/ ]);\n\n\n// WEBPACK FOOTER //\n// bundle.js"," \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, {\n \t\t\t\tconfigurable: false,\n \t\t\t\tenumerable: true,\n \t\t\t\tget: getter\n \t\t\t});\n \t\t}\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"\";\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = 34);\n\n\n\n// WEBPACK FOOTER //\n// webpack/bootstrap 341a3223c6a7219097e2","'use strict';\n\nvar elliptic = exports;\n\nelliptic.version = require('../package.json').version;\nelliptic.utils = require('./elliptic/utils');\nelliptic.rand = require('brorand');\nelliptic.curve = require('./elliptic/curve');\nelliptic.curves = require('./elliptic/curves');\n\n// Protocols\nelliptic.ec = require('./elliptic/ec');\nelliptic.eddsa = require('./elliptic/eddsa');\n\n\n\n// WEBPACK FOOTER //\n// ./node_modules/elliptic/lib/elliptic.js","(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    Buffer = require('buffer').Buffer;\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    }\n\n    if (base === 16) {\n      this._parseHex(number, start);\n    } else {\n      this._parseBase(number, base, start);\n    }\n\n    if (number[0] === '-') {\n      this.negative = 1;\n    }\n\n    this.strip();\n\n    if (endian !== 'le') return;\n\n    this._initArray(this.toArray(), base, endian);\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 parseHex (str, start, end) {\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 <<= 4;\n\n      // 'a' - 'f'\n      if (c >= 49 && c <= 54) {\n        r |= c - 49 + 0xa;\n\n      // 'A' - 'F'\n      } else if (c >= 17 && c <= 22) {\n        r |= c - 17 + 0xa;\n\n      // '0' - '9'\n      } else {\n        r |= c & 0xf;\n      }\n    }\n    return r;\n  }\n\n  BN.prototype._parseHex = function _parseHex (number, start) {\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    var j, w;\n    // Scan 24-bit chunks and add them to the number\n    var off = 0;\n    for (i = number.length - 6, j = 0; i >= start; i -= 6) {\n      w = parseHex(number, i, i + 6);\n      this.words[j] |= (w << off) & 0x3ffffff;\n      // NOTE: `0x3fffff` is intentional here, 26bits max shift + 24bit hex limb\n      this.words[j + 1] |= w >>> (26 - off) & 0x3fffff;\n      off += 24;\n      if (off >= 26) {\n        off -= 26;\n        j++;\n      }\n    }\n    if (i + 6 !== start) {\n      w = parseHex(number, start, i + 6);\n      this.words[j] |= (w << off) & 0x3ffffff;\n      this.words[j + 1] |= w >>> (26 - off) & 0x3fffff;\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\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      r.strip();\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\n\n\n// WEBPACK FOOTER //\n// ./node_modules/bn.js/lib/bn.js","/*!\n * The buffer module from node.js, for the browser.\n *\n * @author   Feross Aboukhadijeh <feross@feross.org> <http://feross.org>\n * @license  MIT\n */\n/* eslint-disable no-proto */\n\n'use strict'\n\nvar base64 = require('base64-js')\nvar ieee754 = require('ieee754')\nvar isArray = require('isarray')\n\nexports.Buffer = Buffer\nexports.SlowBuffer = SlowBuffer\nexports.INSPECT_MAX_BYTES = 50\n\n/**\n * If `Buffer.TYPED_ARRAY_SUPPORT`:\n *   === true    Use Uint8Array implementation (fastest)\n *   === false   Use Object implementation (most compatible, even IE6)\n *\n * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,\n * Opera 11.6+, iOS 4.2+.\n *\n * Due to various browser bugs, sometimes the Object implementation will be used even\n * when the browser supports typed arrays.\n *\n * Note:\n *\n *   - Firefox 4-29 lacks support for adding new properties to `Uint8Array` instances,\n *     See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438.\n *\n *   - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function.\n *\n *   - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of\n *     incorrect length in some situations.\n\n * We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they\n * get the Object implementation, which is slower but behaves correctly.\n */\nBuffer.TYPED_ARRAY_SUPPORT = global.TYPED_ARRAY_SUPPORT !== undefined\n  ? global.TYPED_ARRAY_SUPPORT\n  : typedArraySupport()\n\n/*\n * Export kMaxLength after typed array support is determined.\n */\nexports.kMaxLength = kMaxLength()\n\nfunction typedArraySupport () {\n  try {\n    var arr = new Uint8Array(1)\n    arr.__proto__ = {__proto__: Uint8Array.prototype, foo: function () { return 42 }}\n    return arr.foo() === 42 && // typed array instances can be augmented\n        typeof arr.subarray === 'function' && // chrome 9-10 lack `subarray`\n        arr.subarray(1, 1).byteLength === 0 // ie10 has broken `subarray`\n  } catch (e) {\n    return false\n  }\n}\n\nfunction kMaxLength () {\n  return Buffer.TYPED_ARRAY_SUPPORT\n    ? 0x7fffffff\n    : 0x3fffffff\n}\n\nfunction createBuffer (that, length) {\n  if (kMaxLength() < length) {\n    throw new RangeError('Invalid typed array length')\n  }\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    // Return an augmented `Uint8Array` instance, for best performance\n    that = new Uint8Array(length)\n    that.__proto__ = Buffer.prototype\n  } else {\n    // Fallback: Return an object instance of the Buffer class\n    if (that === null) {\n      that = new Buffer(length)\n    }\n    that.length = length\n  }\n\n  return that\n}\n\n/**\n * The Buffer constructor returns instances of `Uint8Array` that have their\n * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of\n * `Uint8Array`, so the returned instances will have all the node `Buffer` methods\n * and the `Uint8Array` methods. Square bracket notation works as expected -- it\n * returns a single octet.\n *\n * The `Uint8Array` prototype remains unmodified.\n */\n\nfunction Buffer (arg, encodingOrOffset, length) {\n  if (!Buffer.TYPED_ARRAY_SUPPORT && !(this instanceof Buffer)) {\n    return new Buffer(arg, encodingOrOffset, length)\n  }\n\n  // Common case.\n  if (typeof arg === 'number') {\n    if (typeof encodingOrOffset === 'string') {\n      throw new Error(\n        'If encoding is specified then the first argument must be a string'\n      )\n    }\n    return allocUnsafe(this, arg)\n  }\n  return from(this, arg, encodingOrOffset, length)\n}\n\nBuffer.poolSize = 8192 // not used by this implementation\n\n// TODO: Legacy, not needed anymore. Remove in next major version.\nBuffer._augment = function (arr) {\n  arr.__proto__ = Buffer.prototype\n  return arr\n}\n\nfunction from (that, value, encodingOrOffset, length) {\n  if (typeof value === 'number') {\n    throw new TypeError('\"value\" argument must not be a number')\n  }\n\n  if (typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer) {\n    return fromArrayBuffer(that, value, encodingOrOffset, length)\n  }\n\n  if (typeof value === 'string') {\n    return fromString(that, value, encodingOrOffset)\n  }\n\n  return fromObject(that, value)\n}\n\n/**\n * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError\n * if value is a number.\n * Buffer.from(str[, encoding])\n * Buffer.from(array)\n * Buffer.from(buffer)\n * Buffer.from(arrayBuffer[, byteOffset[, length]])\n **/\nBuffer.from = function (value, encodingOrOffset, length) {\n  return from(null, value, encodingOrOffset, length)\n}\n\nif (Buffer.TYPED_ARRAY_SUPPORT) {\n  Buffer.prototype.__proto__ = Uint8Array.prototype\n  Buffer.__proto__ = Uint8Array\n  if (typeof Symbol !== 'undefined' && Symbol.species &&\n      Buffer[Symbol.species] === Buffer) {\n    // Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97\n    Object.defineProperty(Buffer, Symbol.species, {\n      value: null,\n      configurable: true\n    })\n  }\n}\n\nfunction assertSize (size) {\n  if (typeof size !== 'number') {\n    throw new TypeError('\"size\" argument must be a number')\n  } else if (size < 0) {\n    throw new RangeError('\"size\" argument must not be negative')\n  }\n}\n\nfunction alloc (that, size, fill, encoding) {\n  assertSize(size)\n  if (size <= 0) {\n    return createBuffer(that, size)\n  }\n  if (fill !== undefined) {\n    // Only pay attention to encoding if it's a string. This\n    // prevents accidentally sending in a number that would\n    // be interpretted as a start offset.\n    return typeof encoding === 'string'\n      ? createBuffer(that, size).fill(fill, encoding)\n      : createBuffer(that, size).fill(fill)\n  }\n  return createBuffer(that, size)\n}\n\n/**\n * Creates a new filled Buffer instance.\n * alloc(size[, fill[, encoding]])\n **/\nBuffer.alloc = function (size, fill, encoding) {\n  return alloc(null, size, fill, encoding)\n}\n\nfunction allocUnsafe (that, size) {\n  assertSize(size)\n  that = createBuffer(that, size < 0 ? 0 : checked(size) | 0)\n  if (!Buffer.TYPED_ARRAY_SUPPORT) {\n    for (var i = 0; i < size; ++i) {\n      that[i] = 0\n    }\n  }\n  return that\n}\n\n/**\n * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.\n * */\nBuffer.allocUnsafe = function (size) {\n  return allocUnsafe(null, size)\n}\n/**\n * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.\n */\nBuffer.allocUnsafeSlow = function (size) {\n  return allocUnsafe(null, size)\n}\n\nfunction fromString (that, string, encoding) {\n  if (typeof encoding !== 'string' || encoding === '') {\n    encoding = 'utf8'\n  }\n\n  if (!Buffer.isEncoding(encoding)) {\n    throw new TypeError('\"encoding\" must be a valid string encoding')\n  }\n\n  var length = byteLength(string, encoding) | 0\n  that = createBuffer(that, length)\n\n  var actual = that.write(string, encoding)\n\n  if (actual !== length) {\n    // Writing a hex string, for example, that contains invalid characters will\n    // cause everything after the first invalid character to be ignored. (e.g.\n    // 'abxxcd' will be treated as 'ab')\n    that = that.slice(0, actual)\n  }\n\n  return that\n}\n\nfunction fromArrayLike (that, array) {\n  var length = array.length < 0 ? 0 : checked(array.length) | 0\n  that = createBuffer(that, length)\n  for (var i = 0; i < length; i += 1) {\n    that[i] = array[i] & 255\n  }\n  return that\n}\n\nfunction fromArrayBuffer (that, array, byteOffset, length) {\n  array.byteLength // this throws if `array` is not a valid ArrayBuffer\n\n  if (byteOffset < 0 || array.byteLength < byteOffset) {\n    throw new RangeError('\\'offset\\' is out of bounds')\n  }\n\n  if (array.byteLength < byteOffset + (length || 0)) {\n    throw new RangeError('\\'length\\' is out of bounds')\n  }\n\n  if (byteOffset === undefined && length === undefined) {\n    array = new Uint8Array(array)\n  } else if (length === undefined) {\n    array = new Uint8Array(array, byteOffset)\n  } else {\n    array = new Uint8Array(array, byteOffset, length)\n  }\n\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    // Return an augmented `Uint8Array` instance, for best performance\n    that = array\n    that.__proto__ = Buffer.prototype\n  } else {\n    // Fallback: Return an object instance of the Buffer class\n    that = fromArrayLike(that, array)\n  }\n  return that\n}\n\nfunction fromObject (that, obj) {\n  if (Buffer.isBuffer(obj)) {\n    var len = checked(obj.length) | 0\n    that = createBuffer(that, len)\n\n    if (that.length === 0) {\n      return that\n    }\n\n    obj.copy(that, 0, 0, len)\n    return that\n  }\n\n  if (obj) {\n    if ((typeof ArrayBuffer !== 'undefined' &&\n        obj.buffer instanceof ArrayBuffer) || 'length' in obj) {\n      if (typeof obj.length !== 'number' || isnan(obj.length)) {\n        return createBuffer(that, 0)\n      }\n      return fromArrayLike(that, obj)\n    }\n\n    if (obj.type === 'Buffer' && isArray(obj.data)) {\n      return fromArrayLike(that, obj.data)\n    }\n  }\n\n  throw new TypeError('First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.')\n}\n\nfunction checked (length) {\n  // Note: cannot use `length < kMaxLength()` here because that fails when\n  // length is NaN (which is otherwise coerced to zero.)\n  if (length >= kMaxLength()) {\n    throw new RangeError('Attempt to allocate Buffer larger than maximum ' +\n                         'size: 0x' + kMaxLength().toString(16) + ' bytes')\n  }\n  return length | 0\n}\n\nfunction SlowBuffer (length) {\n  if (+length != length) { // eslint-disable-line eqeqeq\n    length = 0\n  }\n  return Buffer.alloc(+length)\n}\n\nBuffer.isBuffer = function isBuffer (b) {\n  return !!(b != null && b._isBuffer)\n}\n\nBuffer.compare = function compare (a, b) {\n  if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {\n    throw new TypeError('Arguments must be Buffers')\n  }\n\n  if (a === b) return 0\n\n  var x = a.length\n  var y = b.length\n\n  for (var i = 0, len = Math.min(x, y); i < len; ++i) {\n    if (a[i] !== b[i]) {\n      x = a[i]\n      y = b[i]\n      break\n    }\n  }\n\n  if (x < y) return -1\n  if (y < x) return 1\n  return 0\n}\n\nBuffer.isEncoding = function isEncoding (encoding) {\n  switch (String(encoding).toLowerCase()) {\n    case 'hex':\n    case 'utf8':\n    case 'utf-8':\n    case 'ascii':\n    case 'latin1':\n    case 'binary':\n    case 'base64':\n    case 'ucs2':\n    case 'ucs-2':\n    case 'utf16le':\n    case 'utf-16le':\n      return true\n    default:\n      return false\n  }\n}\n\nBuffer.concat = function concat (list, length) {\n  if (!isArray(list)) {\n    throw new TypeError('\"list\" argument must be an Array of Buffers')\n  }\n\n  if (list.length === 0) {\n    return Buffer.alloc(0)\n  }\n\n  var i\n  if (length === undefined) {\n    length = 0\n    for (i = 0; i < list.length; ++i) {\n      length += list[i].length\n    }\n  }\n\n  var buffer = Buffer.allocUnsafe(length)\n  var pos = 0\n  for (i = 0; i < list.length; ++i) {\n    var buf = list[i]\n    if (!Buffer.isBuffer(buf)) {\n      throw new TypeError('\"list\" argument must be an Array of Buffers')\n    }\n    buf.copy(buffer, pos)\n    pos += buf.length\n  }\n  return buffer\n}\n\nfunction byteLength (string, encoding) {\n  if (Buffer.isBuffer(string)) {\n    return string.length\n  }\n  if (typeof ArrayBuffer !== 'undefined' && typeof ArrayBuffer.isView === 'function' &&\n      (ArrayBuffer.isView(string) || string instanceof ArrayBuffer)) {\n    return string.byteLength\n  }\n  if (typeof string !== 'string') {\n    string = '' + string\n  }\n\n  var len = string.length\n  if (len === 0) return 0\n\n  // Use a for loop to avoid recursion\n  var loweredCase = false\n  for (;;) {\n    switch (encoding) {\n      case 'ascii':\n      case 'latin1':\n      case 'binary':\n        return len\n      case 'utf8':\n      case 'utf-8':\n      case undefined:\n        return utf8ToBytes(string).length\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return len * 2\n      case 'hex':\n        return len >>> 1\n      case 'base64':\n        return base64ToBytes(string).length\n      default:\n        if (loweredCase) return utf8ToBytes(string).length // assume utf8\n        encoding = ('' + encoding).toLowerCase()\n        loweredCase = true\n    }\n  }\n}\nBuffer.byteLength = byteLength\n\nfunction slowToString (encoding, start, end) {\n  var loweredCase = false\n\n  // No need to verify that \"this.length <= MAX_UINT32\" since it's a read-only\n  // property of a typed array.\n\n  // This behaves neither like String nor Uint8Array in that we set start/end\n  // to their upper/lower bounds if the value passed is out of range.\n  // undefined is handled specially as per ECMA-262 6th Edition,\n  // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.\n  if (start === undefined || start < 0) {\n    start = 0\n  }\n  // Return early if start > this.length. Done here to prevent potential uint32\n  // coercion fail below.\n  if (start > this.length) {\n    return ''\n  }\n\n  if (end === undefined || end > this.length) {\n    end = this.length\n  }\n\n  if (end <= 0) {\n    return ''\n  }\n\n  // Force coersion to uint32. This will also coerce falsey/NaN values to 0.\n  end >>>= 0\n  start >>>= 0\n\n  if (end <= start) {\n    return ''\n  }\n\n  if (!encoding) encoding = 'utf8'\n\n  while (true) {\n    switch (encoding) {\n      case 'hex':\n        return hexSlice(this, start, end)\n\n      case 'utf8':\n      case 'utf-8':\n        return utf8Slice(this, start, end)\n\n      case 'ascii':\n        return asciiSlice(this, start, end)\n\n      case 'latin1':\n      case 'binary':\n        return latin1Slice(this, start, end)\n\n      case 'base64':\n        return base64Slice(this, start, end)\n\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return utf16leSlice(this, start, end)\n\n      default:\n        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n        encoding = (encoding + '').toLowerCase()\n        loweredCase = true\n    }\n  }\n}\n\n// The property is used by `Buffer.isBuffer` and `is-buffer` (in Safari 5-7) to detect\n// Buffer instances.\nBuffer.prototype._isBuffer = true\n\nfunction swap (b, n, m) {\n  var i = b[n]\n  b[n] = b[m]\n  b[m] = i\n}\n\nBuffer.prototype.swap16 = function swap16 () {\n  var len = this.length\n  if (len % 2 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 16-bits')\n  }\n  for (var i = 0; i < len; i += 2) {\n    swap(this, i, i + 1)\n  }\n  return this\n}\n\nBuffer.prototype.swap32 = function swap32 () {\n  var len = this.length\n  if (len % 4 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 32-bits')\n  }\n  for (var i = 0; i < len; i += 4) {\n    swap(this, i, i + 3)\n    swap(this, i + 1, i + 2)\n  }\n  return this\n}\n\nBuffer.prototype.swap64 = function swap64 () {\n  var len = this.length\n  if (len % 8 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 64-bits')\n  }\n  for (var i = 0; i < len; i += 8) {\n    swap(this, i, i + 7)\n    swap(this, i + 1, i + 6)\n    swap(this, i + 2, i + 5)\n    swap(this, i + 3, i + 4)\n  }\n  return this\n}\n\nBuffer.prototype.toString = function toString () {\n  var length = this.length | 0\n  if (length === 0) return ''\n  if (arguments.length === 0) return utf8Slice(this, 0, length)\n  return slowToString.apply(this, arguments)\n}\n\nBuffer.prototype.equals = function equals (b) {\n  if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')\n  if (this === b) return true\n  return Buffer.compare(this, b) === 0\n}\n\nBuffer.prototype.inspect = function inspect () {\n  var str = ''\n  var max = exports.INSPECT_MAX_BYTES\n  if (this.length > 0) {\n    str = this.toString('hex', 0, max).match(/.{2}/g).join(' ')\n    if (this.length > max) str += ' ... '\n  }\n  return '<Buffer ' + str + '>'\n}\n\nBuffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) {\n  if (!Buffer.isBuffer(target)) {\n    throw new TypeError('Argument must be a Buffer')\n  }\n\n  if (start === undefined) {\n    start = 0\n  }\n  if (end === undefined) {\n    end = target ? target.length : 0\n  }\n  if (thisStart === undefined) {\n    thisStart = 0\n  }\n  if (thisEnd === undefined) {\n    thisEnd = this.length\n  }\n\n  if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {\n    throw new RangeError('out of range index')\n  }\n\n  if (thisStart >= thisEnd && start >= end) {\n    return 0\n  }\n  if (thisStart >= thisEnd) {\n    return -1\n  }\n  if (start >= end) {\n    return 1\n  }\n\n  start >>>= 0\n  end >>>= 0\n  thisStart >>>= 0\n  thisEnd >>>= 0\n\n  if (this === target) return 0\n\n  var x = thisEnd - thisStart\n  var y = end - start\n  var len = Math.min(x, y)\n\n  var thisCopy = this.slice(thisStart, thisEnd)\n  var targetCopy = target.slice(start, end)\n\n  for (var i = 0; i < len; ++i) {\n    if (thisCopy[i] !== targetCopy[i]) {\n      x = thisCopy[i]\n      y = targetCopy[i]\n      break\n    }\n  }\n\n  if (x < y) return -1\n  if (y < x) return 1\n  return 0\n}\n\n// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,\n// OR the last index of `val` in `buffer` at offset <= `byteOffset`.\n//\n// Arguments:\n// - buffer - a Buffer to search\n// - val - a string, Buffer, or number\n// - byteOffset - an index into `buffer`; will be clamped to an int32\n// - encoding - an optional encoding, relevant is val is a string\n// - dir - true for indexOf, false for lastIndexOf\nfunction bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) {\n  // Empty buffer means no match\n  if (buffer.length === 0) return -1\n\n  // Normalize byteOffset\n  if (typeof byteOffset === 'string') {\n    encoding = byteOffset\n    byteOffset = 0\n  } else if (byteOffset > 0x7fffffff) {\n    byteOffset = 0x7fffffff\n  } else if (byteOffset < -0x80000000) {\n    byteOffset = -0x80000000\n  }\n  byteOffset = +byteOffset  // Coerce to Number.\n  if (isNaN(byteOffset)) {\n    // byteOffset: it it's undefined, null, NaN, \"foo\", etc, search whole buffer\n    byteOffset = dir ? 0 : (buffer.length - 1)\n  }\n\n  // Normalize byteOffset: negative offsets start from the end of the buffer\n  if (byteOffset < 0) byteOffset = buffer.length + byteOffset\n  if (byteOffset >= buffer.length) {\n    if (dir) return -1\n    else byteOffset = buffer.length - 1\n  } else if (byteOffset < 0) {\n    if (dir) byteOffset = 0\n    else return -1\n  }\n\n  // Normalize val\n  if (typeof val === 'string') {\n    val = Buffer.from(val, encoding)\n  }\n\n  // Finally, search either indexOf (if dir is true) or lastIndexOf\n  if (Buffer.isBuffer(val)) {\n    // Special case: looking for empty string/buffer always fails\n    if (val.length === 0) {\n      return -1\n    }\n    return arrayIndexOf(buffer, val, byteOffset, encoding, dir)\n  } else if (typeof val === 'number') {\n    val = val & 0xFF // Search for a byte value [0-255]\n    if (Buffer.TYPED_ARRAY_SUPPORT &&\n        typeof Uint8Array.prototype.indexOf === 'function') {\n      if (dir) {\n        return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset)\n      } else {\n        return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset)\n      }\n    }\n    return arrayIndexOf(buffer, [ val ], byteOffset, encoding, dir)\n  }\n\n  throw new TypeError('val must be string, number or Buffer')\n}\n\nfunction arrayIndexOf (arr, val, byteOffset, encoding, dir) {\n  var indexSize = 1\n  var arrLength = arr.length\n  var valLength = val.length\n\n  if (encoding !== undefined) {\n    encoding = String(encoding).toLowerCase()\n    if (encoding === 'ucs2' || encoding === 'ucs-2' ||\n        encoding === 'utf16le' || encoding === 'utf-16le') {\n      if (arr.length < 2 || val.length < 2) {\n        return -1\n      }\n      indexSize = 2\n      arrLength /= 2\n      valLength /= 2\n      byteOffset /= 2\n    }\n  }\n\n  function read (buf, i) {\n    if (indexSize === 1) {\n      return buf[i]\n    } else {\n      return buf.readUInt16BE(i * indexSize)\n    }\n  }\n\n  var i\n  if (dir) {\n    var foundIndex = -1\n    for (i = byteOffset; i < arrLength; i++) {\n      if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {\n        if (foundIndex === -1) foundIndex = i\n        if (i - foundIndex + 1 === valLength) return foundIndex * indexSize\n      } else {\n        if (foundIndex !== -1) i -= i - foundIndex\n        foundIndex = -1\n      }\n    }\n  } else {\n    if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength\n    for (i = byteOffset; i >= 0; i--) {\n      var found = true\n      for (var j = 0; j < valLength; j++) {\n        if (read(arr, i + j) !== read(val, j)) {\n          found = false\n          break\n        }\n      }\n      if (found) return i\n    }\n  }\n\n  return -1\n}\n\nBuffer.prototype.includes = function includes (val, byteOffset, encoding) {\n  return this.indexOf(val, byteOffset, encoding) !== -1\n}\n\nBuffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) {\n  return bidirectionalIndexOf(this, val, byteOffset, encoding, true)\n}\n\nBuffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) {\n  return bidirectionalIndexOf(this, val, byteOffset, encoding, false)\n}\n\nfunction hexWrite (buf, string, offset, length) {\n  offset = Number(offset) || 0\n  var remaining = buf.length - offset\n  if (!length) {\n    length = remaining\n  } else {\n    length = Number(length)\n    if (length > remaining) {\n      length = remaining\n    }\n  }\n\n  // must be an even number of digits\n  var strLen = string.length\n  if (strLen % 2 !== 0) throw new TypeError('Invalid hex string')\n\n  if (length > strLen / 2) {\n    length = strLen / 2\n  }\n  for (var i = 0; i < length; ++i) {\n    var parsed = parseInt(string.substr(i * 2, 2), 16)\n    if (isNaN(parsed)) return i\n    buf[offset + i] = parsed\n  }\n  return i\n}\n\nfunction utf8Write (buf, string, offset, length) {\n  return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)\n}\n\nfunction asciiWrite (buf, string, offset, length) {\n  return blitBuffer(asciiToBytes(string), buf, offset, length)\n}\n\nfunction latin1Write (buf, string, offset, length) {\n  return asciiWrite(buf, string, offset, length)\n}\n\nfunction base64Write (buf, string, offset, length) {\n  return blitBuffer(base64ToBytes(string), buf, offset, length)\n}\n\nfunction ucs2Write (buf, string, offset, length) {\n  return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)\n}\n\nBuffer.prototype.write = function write (string, offset, length, encoding) {\n  // Buffer#write(string)\n  if (offset === undefined) {\n    encoding = 'utf8'\n    length = this.length\n    offset = 0\n  // Buffer#write(string, encoding)\n  } else if (length === undefined && typeof offset === 'string') {\n    encoding = offset\n    length = this.length\n    offset = 0\n  // Buffer#write(string, offset[, length][, encoding])\n  } else if (isFinite(offset)) {\n    offset = offset | 0\n    if (isFinite(length)) {\n      length = length | 0\n      if (encoding === undefined) encoding = 'utf8'\n    } else {\n      encoding = length\n      length = undefined\n    }\n  // legacy write(string, encoding, offset, length) - remove in v0.13\n  } else {\n    throw new Error(\n      'Buffer.write(string, encoding, offset[, length]) is no longer supported'\n    )\n  }\n\n  var remaining = this.length - offset\n  if (length === undefined || length > remaining) length = remaining\n\n  if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {\n    throw new RangeError('Attempt to write outside buffer bounds')\n  }\n\n  if (!encoding) encoding = 'utf8'\n\n  var loweredCase = false\n  for (;;) {\n    switch (encoding) {\n      case 'hex':\n        return hexWrite(this, string, offset, length)\n\n      case 'utf8':\n      case 'utf-8':\n        return utf8Write(this, string, offset, length)\n\n      case 'ascii':\n        return asciiWrite(this, string, offset, length)\n\n      case 'latin1':\n      case 'binary':\n        return latin1Write(this, string, offset, length)\n\n      case 'base64':\n        // Warning: maxLength not taken into account in base64Write\n        return base64Write(this, string, offset, length)\n\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return ucs2Write(this, string, offset, length)\n\n      default:\n        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n        encoding = ('' + encoding).toLowerCase()\n        loweredCase = true\n    }\n  }\n}\n\nBuffer.prototype.toJSON = function toJSON () {\n  return {\n    type: 'Buffer',\n    data: Array.prototype.slice.call(this._arr || this, 0)\n  }\n}\n\nfunction base64Slice (buf, start, end) {\n  if (start === 0 && end === buf.length) {\n    return base64.fromByteArray(buf)\n  } else {\n    return base64.fromByteArray(buf.slice(start, end))\n  }\n}\n\nfunction utf8Slice (buf, start, end) {\n  end = Math.min(buf.length, end)\n  var res = []\n\n  var i = start\n  while (i < end) {\n    var firstByte = buf[i]\n    var codePoint = null\n    var bytesPerSequence = (firstByte > 0xEF) ? 4\n      : (firstByte > 0xDF) ? 3\n      : (firstByte > 0xBF) ? 2\n      : 1\n\n    if (i + bytesPerSequence <= end) {\n      var secondByte, thirdByte, fourthByte, tempCodePoint\n\n      switch (bytesPerSequence) {\n        case 1:\n          if (firstByte < 0x80) {\n            codePoint = firstByte\n          }\n          break\n        case 2:\n          secondByte = buf[i + 1]\n          if ((secondByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F)\n            if (tempCodePoint > 0x7F) {\n              codePoint = tempCodePoint\n            }\n          }\n          break\n        case 3:\n          secondByte = buf[i + 1]\n          thirdByte = buf[i + 2]\n          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F)\n            if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {\n              codePoint = tempCodePoint\n            }\n          }\n          break\n        case 4:\n          secondByte = buf[i + 1]\n          thirdByte = buf[i + 2]\n          fourthByte = buf[i + 3]\n          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F)\n            if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {\n              codePoint = tempCodePoint\n            }\n          }\n      }\n    }\n\n    if (codePoint === null) {\n      // we did not generate a valid codePoint so insert a\n      // replacement char (U+FFFD) and advance only 1 byte\n      codePoint = 0xFFFD\n      bytesPerSequence = 1\n    } else if (codePoint > 0xFFFF) {\n      // encode to utf16 (surrogate pair dance)\n      codePoint -= 0x10000\n      res.push(codePoint >>> 10 & 0x3FF | 0xD800)\n      codePoint = 0xDC00 | codePoint & 0x3FF\n    }\n\n    res.push(codePoint)\n    i += bytesPerSequence\n  }\n\n  return decodeCodePointsArray(res)\n}\n\n// Based on http://stackoverflow.com/a/22747272/680742, the browser with\n// the lowest limit is Chrome, with 0x10000 args.\n// We go 1 magnitude less, for safety\nvar MAX_ARGUMENTS_LENGTH = 0x1000\n\nfunction decodeCodePointsArray (codePoints) {\n  var len = codePoints.length\n  if (len <= MAX_ARGUMENTS_LENGTH) {\n    return String.fromCharCode.apply(String, codePoints) // avoid extra slice()\n  }\n\n  // Decode in chunks to avoid \"call stack size exceeded\".\n  var res = ''\n  var i = 0\n  while (i < len) {\n    res += String.fromCharCode.apply(\n      String,\n      codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)\n    )\n  }\n  return res\n}\n\nfunction asciiSlice (buf, start, end) {\n  var ret = ''\n  end = Math.min(buf.length, end)\n\n  for (var i = start; i < end; ++i) {\n    ret += String.fromCharCode(buf[i] & 0x7F)\n  }\n  return ret\n}\n\nfunction latin1Slice (buf, start, end) {\n  var ret = ''\n  end = Math.min(buf.length, end)\n\n  for (var i = start; i < end; ++i) {\n    ret += String.fromCharCode(buf[i])\n  }\n  return ret\n}\n\nfunction hexSlice (buf, start, end) {\n  var len = buf.length\n\n  if (!start || start < 0) start = 0\n  if (!end || end < 0 || end > len) end = len\n\n  var out = ''\n  for (var i = start; i < end; ++i) {\n    out += toHex(buf[i])\n  }\n  return out\n}\n\nfunction utf16leSlice (buf, start, end) {\n  var bytes = buf.slice(start, end)\n  var res = ''\n  for (var i = 0; i < bytes.length; i += 2) {\n    res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256)\n  }\n  return res\n}\n\nBuffer.prototype.slice = function slice (start, end) {\n  var len = this.length\n  start = ~~start\n  end = end === undefined ? len : ~~end\n\n  if (start < 0) {\n    start += len\n    if (start < 0) start = 0\n  } else if (start > len) {\n    start = len\n  }\n\n  if (end < 0) {\n    end += len\n    if (end < 0) end = 0\n  } else if (end > len) {\n    end = len\n  }\n\n  if (end < start) end = start\n\n  var newBuf\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    newBuf = this.subarray(start, end)\n    newBuf.__proto__ = Buffer.prototype\n  } else {\n    var sliceLen = end - start\n    newBuf = new Buffer(sliceLen, undefined)\n    for (var i = 0; i < sliceLen; ++i) {\n      newBuf[i] = this[i + start]\n    }\n  }\n\n  return newBuf\n}\n\n/*\n * Need to make sure that buffer isn't trying to write out of bounds.\n */\nfunction checkOffset (offset, ext, length) {\n  if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint')\n  if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')\n}\n\nBuffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var val = this[offset]\n  var mul = 1\n  var i = 0\n  while (++i < byteLength && (mul *= 0x100)) {\n    val += this[offset + i] * mul\n  }\n\n  return val\n}\n\nBuffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) {\n    checkOffset(offset, byteLength, this.length)\n  }\n\n  var val = this[offset + --byteLength]\n  var mul = 1\n  while (byteLength > 0 && (mul *= 0x100)) {\n    val += this[offset + --byteLength] * mul\n  }\n\n  return val\n}\n\nBuffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 1, this.length)\n  return this[offset]\n}\n\nBuffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  return this[offset] | (this[offset + 1] << 8)\n}\n\nBuffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  return (this[offset] << 8) | this[offset + 1]\n}\n\nBuffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return ((this[offset]) |\n      (this[offset + 1] << 8) |\n      (this[offset + 2] << 16)) +\n      (this[offset + 3] * 0x1000000)\n}\n\nBuffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset] * 0x1000000) +\n    ((this[offset + 1] << 16) |\n    (this[offset + 2] << 8) |\n    this[offset + 3])\n}\n\nBuffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var val = this[offset]\n  var mul = 1\n  var i = 0\n  while (++i < byteLength && (mul *= 0x100)) {\n    val += this[offset + i] * mul\n  }\n  mul *= 0x80\n\n  if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\n  return val\n}\n\nBuffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var i = byteLength\n  var mul = 1\n  var val = this[offset + --i]\n  while (i > 0 && (mul *= 0x100)) {\n    val += this[offset + --i] * mul\n  }\n  mul *= 0x80\n\n  if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\n  return val\n}\n\nBuffer.prototype.readInt8 = function readInt8 (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 1, this.length)\n  if (!(this[offset] & 0x80)) return (this[offset])\n  return ((0xff - this[offset] + 1) * -1)\n}\n\nBuffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  var val = this[offset] | (this[offset + 1] << 8)\n  return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  var val = this[offset + 1] | (this[offset] << 8)\n  return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset]) |\n    (this[offset + 1] << 8) |\n    (this[offset + 2] << 16) |\n    (this[offset + 3] << 24)\n}\n\nBuffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset] << 24) |\n    (this[offset + 1] << 16) |\n    (this[offset + 2] << 8) |\n    (this[offset + 3])\n}\n\nBuffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n  return ieee754.read(this, offset, true, 23, 4)\n}\n\nBuffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n  return ieee754.read(this, offset, false, 23, 4)\n}\n\nBuffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 8, this.length)\n  return ieee754.read(this, offset, true, 52, 8)\n}\n\nBuffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 8, this.length)\n  return ieee754.read(this, offset, false, 52, 8)\n}\n\nfunction checkInt (buf, value, offset, ext, max, min) {\n  if (!Buffer.isBuffer(buf)) throw new TypeError('\"buffer\" argument must be a Buffer instance')\n  if (value > max || value < min) throw new RangeError('\"value\" argument is out of bounds')\n  if (offset + ext > buf.length) throw new RangeError('Index out of range')\n}\n\nBuffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) {\n    var maxBytes = Math.pow(2, 8 * byteLength) - 1\n    checkInt(this, value, offset, byteLength, maxBytes, 0)\n  }\n\n  var mul = 1\n  var i = 0\n  this[offset] = value & 0xFF\n  while (++i < byteLength && (mul *= 0x100)) {\n    this[offset + i] = (value / mul) & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) {\n    var maxBytes = Math.pow(2, 8 * byteLength) - 1\n    checkInt(this, value, offset, byteLength, maxBytes, 0)\n  }\n\n  var i = byteLength - 1\n  var mul = 1\n  this[offset + i] = value & 0xFF\n  while (--i >= 0 && (mul *= 0x100)) {\n    this[offset + i] = (value / mul) & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0)\n  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)\n  this[offset] = (value & 0xff)\n  return offset + 1\n}\n\nfunction objectWriteUInt16 (buf, value, offset, littleEndian) {\n  if (value < 0) value = 0xffff + value + 1\n  for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; ++i) {\n    buf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>>\n      (littleEndian ? i : 1 - i) * 8\n  }\n}\n\nBuffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value & 0xff)\n    this[offset + 1] = (value >>> 8)\n  } else {\n    objectWriteUInt16(this, value, offset, true)\n  }\n  return offset + 2\n}\n\nBuffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 8)\n    this[offset + 1] = (value & 0xff)\n  } else {\n    objectWriteUInt16(this, value, offset, false)\n  }\n  return offset + 2\n}\n\nfunction objectWriteUInt32 (buf, value, offset, littleEndian) {\n  if (value < 0) value = 0xffffffff + value + 1\n  for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; ++i) {\n    buf[offset + i] = (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff\n  }\n}\n\nBuffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset + 3] = (value >>> 24)\n    this[offset + 2] = (value >>> 16)\n    this[offset + 1] = (value >>> 8)\n    this[offset] = (value & 0xff)\n  } else {\n    objectWriteUInt32(this, value, offset, true)\n  }\n  return offset + 4\n}\n\nBuffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 24)\n    this[offset + 1] = (value >>> 16)\n    this[offset + 2] = (value >>> 8)\n    this[offset + 3] = (value & 0xff)\n  } else {\n    objectWriteUInt32(this, value, offset, false)\n  }\n  return offset + 4\n}\n\nBuffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) {\n    var limit = Math.pow(2, 8 * byteLength - 1)\n\n    checkInt(this, value, offset, byteLength, limit - 1, -limit)\n  }\n\n  var i = 0\n  var mul = 1\n  var sub = 0\n  this[offset] = value & 0xFF\n  while (++i < byteLength && (mul *= 0x100)) {\n    if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {\n      sub = 1\n    }\n    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) {\n    var limit = Math.pow(2, 8 * byteLength - 1)\n\n    checkInt(this, value, offset, byteLength, limit - 1, -limit)\n  }\n\n  var i = byteLength - 1\n  var mul = 1\n  var sub = 0\n  this[offset + i] = value & 0xFF\n  while (--i >= 0 && (mul *= 0x100)) {\n    if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {\n      sub = 1\n    }\n    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80)\n  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)\n  if (value < 0) value = 0xff + value + 1\n  this[offset] = (value & 0xff)\n  return offset + 1\n}\n\nBuffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value & 0xff)\n    this[offset + 1] = (value >>> 8)\n  } else {\n    objectWriteUInt16(this, value, offset, true)\n  }\n  return offset + 2\n}\n\nBuffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 8)\n    this[offset + 1] = (value & 0xff)\n  } else {\n    objectWriteUInt16(this, value, offset, false)\n  }\n  return offset + 2\n}\n\nBuffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value & 0xff)\n    this[offset + 1] = (value >>> 8)\n    this[offset + 2] = (value >>> 16)\n    this[offset + 3] = (value >>> 24)\n  } else {\n    objectWriteUInt32(this, value, offset, true)\n  }\n  return offset + 4\n}\n\nBuffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n  if (value < 0) value = 0xffffffff + value + 1\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 24)\n    this[offset + 1] = (value >>> 16)\n    this[offset + 2] = (value >>> 8)\n    this[offset + 3] = (value & 0xff)\n  } else {\n    objectWriteUInt32(this, value, offset, false)\n  }\n  return offset + 4\n}\n\nfunction checkIEEE754 (buf, value, offset, ext, max, min) {\n  if (offset + ext > buf.length) throw new RangeError('Index out of range')\n  if (offset < 0) throw new RangeError('Index out of range')\n}\n\nfunction writeFloat (buf, value, offset, littleEndian, noAssert) {\n  if (!noAssert) {\n    checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38)\n  }\n  ieee754.write(buf, value, offset, littleEndian, 23, 4)\n  return offset + 4\n}\n\nBuffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) {\n  return writeFloat(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) {\n  return writeFloat(this, value, offset, false, noAssert)\n}\n\nfunction writeDouble (buf, value, offset, littleEndian, noAssert) {\n  if (!noAssert) {\n    checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308)\n  }\n  ieee754.write(buf, value, offset, littleEndian, 52, 8)\n  return offset + 8\n}\n\nBuffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) {\n  return writeDouble(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) {\n  return writeDouble(this, value, offset, false, noAssert)\n}\n\n// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)\nBuffer.prototype.copy = function copy (target, targetStart, start, end) {\n  if (!start) start = 0\n  if (!end && end !== 0) end = this.length\n  if (targetStart >= target.length) targetStart = target.length\n  if (!targetStart) targetStart = 0\n  if (end > 0 && end < start) end = start\n\n  // Copy 0 bytes; we're done\n  if (end === start) return 0\n  if (target.length === 0 || this.length === 0) return 0\n\n  // Fatal error conditions\n  if (targetStart < 0) {\n    throw new RangeError('targetStart out of bounds')\n  }\n  if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds')\n  if (end < 0) throw new RangeError('sourceEnd out of bounds')\n\n  // Are we oob?\n  if (end > this.length) end = this.length\n  if (target.length - targetStart < end - start) {\n    end = target.length - targetStart + start\n  }\n\n  var len = end - start\n  var i\n\n  if (this === target && start < targetStart && targetStart < end) {\n    // descending copy from end\n    for (i = len - 1; i >= 0; --i) {\n      target[i + targetStart] = this[i + start]\n    }\n  } else if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) {\n    // ascending copy from start\n    for (i = 0; i < len; ++i) {\n      target[i + targetStart] = this[i + start]\n    }\n  } else {\n    Uint8Array.prototype.set.call(\n      target,\n      this.subarray(start, start + len),\n      targetStart\n    )\n  }\n\n  return len\n}\n\n// Usage:\n//    buffer.fill(number[, offset[, end]])\n//    buffer.fill(buffer[, offset[, end]])\n//    buffer.fill(string[, offset[, end]][, encoding])\nBuffer.prototype.fill = function fill (val, start, end, encoding) {\n  // Handle string cases:\n  if (typeof val === 'string') {\n    if (typeof start === 'string') {\n      encoding = start\n      start = 0\n      end = this.length\n    } else if (typeof end === 'string') {\n      encoding = end\n      end = this.length\n    }\n    if (val.length === 1) {\n      var code = val.charCodeAt(0)\n      if (code < 256) {\n        val = code\n      }\n    }\n    if (encoding !== undefined && typeof encoding !== 'string') {\n      throw new TypeError('encoding must be a string')\n    }\n    if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {\n      throw new TypeError('Unknown encoding: ' + encoding)\n    }\n  } else if (typeof val === 'number') {\n    val = val & 255\n  }\n\n  // Invalid ranges are not set to a default, so can range check early.\n  if (start < 0 || this.length < start || this.length < end) {\n    throw new RangeError('Out of range index')\n  }\n\n  if (end <= start) {\n    return this\n  }\n\n  start = start >>> 0\n  end = end === undefined ? this.length : end >>> 0\n\n  if (!val) val = 0\n\n  var i\n  if (typeof val === 'number') {\n    for (i = start; i < end; ++i) {\n      this[i] = val\n    }\n  } else {\n    var bytes = Buffer.isBuffer(val)\n      ? val\n      : utf8ToBytes(new Buffer(val, encoding).toString())\n    var len = bytes.length\n    for (i = 0; i < end - start; ++i) {\n      this[i + start] = bytes[i % len]\n    }\n  }\n\n  return this\n}\n\n// HELPER FUNCTIONS\n// ================\n\nvar INVALID_BASE64_RE = /[^+\\/0-9A-Za-z-_]/g\n\nfunction base64clean (str) {\n  // Node strips out invalid characters like \\n and \\t from the string, base64-js does not\n  str = stringtrim(str).replace(INVALID_BASE64_RE, '')\n  // Node converts strings with length < 2 to ''\n  if (str.length < 2) return ''\n  // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not\n  while (str.length % 4 !== 0) {\n    str = str + '='\n  }\n  return str\n}\n\nfunction stringtrim (str) {\n  if (str.trim) return str.trim()\n  return str.replace(/^\\s+|\\s+$/g, '')\n}\n\nfunction toHex (n) {\n  if (n < 16) return '0' + n.toString(16)\n  return n.toString(16)\n}\n\nfunction utf8ToBytes (string, units) {\n  units = units || Infinity\n  var codePoint\n  var length = string.length\n  var leadSurrogate = null\n  var bytes = []\n\n  for (var i = 0; i < length; ++i) {\n    codePoint = string.charCodeAt(i)\n\n    // is surrogate component\n    if (codePoint > 0xD7FF && codePoint < 0xE000) {\n      // last char was a lead\n      if (!leadSurrogate) {\n        // no lead yet\n        if (codePoint > 0xDBFF) {\n          // unexpected trail\n          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n          continue\n        } else if (i + 1 === length) {\n          // unpaired lead\n          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n          continue\n        }\n\n        // valid lead\n        leadSurrogate = codePoint\n\n        continue\n      }\n\n      // 2 leads in a row\n      if (codePoint < 0xDC00) {\n        if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n        leadSurrogate = codePoint\n        continue\n      }\n\n      // valid surrogate pair\n      codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000\n    } else if (leadSurrogate) {\n      // valid bmp char, but last char was a lead\n      if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n    }\n\n    leadSurrogate = null\n\n    // encode utf8\n    if (codePoint < 0x80) {\n      if ((units -= 1) < 0) break\n      bytes.push(codePoint)\n    } else if (codePoint < 0x800) {\n      if ((units -= 2) < 0) break\n      bytes.push(\n        codePoint >> 0x6 | 0xC0,\n        codePoint & 0x3F | 0x80\n      )\n    } else if (codePoint < 0x10000) {\n      if ((units -= 3) < 0) break\n      bytes.push(\n        codePoint >> 0xC | 0xE0,\n        codePoint >> 0x6 & 0x3F | 0x80,\n        codePoint & 0x3F | 0x80\n      )\n    } else if (codePoint < 0x110000) {\n      if ((units -= 4) < 0) break\n      bytes.push(\n        codePoint >> 0x12 | 0xF0,\n        codePoint >> 0xC & 0x3F | 0x80,\n        codePoint >> 0x6 & 0x3F | 0x80,\n        codePoint & 0x3F | 0x80\n      )\n    } else {\n      throw new Error('Invalid code point')\n    }\n  }\n\n  return bytes\n}\n\nfunction asciiToBytes (str) {\n  var byteArray = []\n  for (var i = 0; i < str.length; ++i) {\n    // Node's code seems to be doing this and not & 0x7F..\n    byteArray.push(str.charCodeAt(i) & 0xFF)\n  }\n  return byteArray\n}\n\nfunction utf16leToBytes (str, units) {\n  var c, hi, lo\n  var byteArray = []\n  for (var i = 0; i < str.length; ++i) {\n    if ((units -= 2) < 0) break\n\n    c = str.charCodeAt(i)\n    hi = c >> 8\n    lo = c % 256\n    byteArray.push(lo)\n    byteArray.push(hi)\n  }\n\n  return byteArray\n}\n\nfunction base64ToBytes (str) {\n  return base64.toByteArray(base64clean(str))\n}\n\nfunction blitBuffer (src, dst, offset, length) {\n  for (var i = 0; i < length; ++i) {\n    if ((i + offset >= dst.length) || (i >= src.length)) break\n    dst[i + offset] = src[i]\n  }\n  return i\n}\n\nfunction isnan (val) {\n  return val !== val // eslint-disable-line no-self-compare\n}\n\n\n\n// WEBPACK FOOTER //\n// ./node_modules/buffer/index.js","if (typeof Object.create === 'function') {\n  // implementation from standard node.js 'util' module\n  module.exports = function inherits(ctor, superCtor) {\n    ctor.super_ = superCtor\n    ctor.prototype = Object.create(superCtor.prototype, {\n      constructor: {\n        value: ctor,\n        enumerable: false,\n        writable: true,\n        configurable: true\n      }\n    });\n  };\n} else {\n  // old school shim for old browsers\n  module.exports = 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\n\n\n// WEBPACK FOOTER //\n// ./node_modules/inherits/inherits_browser.js","'use strict';\n\nvar assert = require('minimalistic-assert');\nvar inherits = require('inherits');\n\nexports.inherits = inherits;\n\nfunction toArray(msg, enc) {\n  if (Array.isArray(msg))\n    return msg.slice();\n  if (!msg)\n    return [];\n  var res = [];\n  if (typeof msg === 'string') {\n    if (!enc) {\n      for (var i = 0; i < msg.length; i++) {\n        var c = msg.charCodeAt(i);\n        var hi = c >> 8;\n        var lo = c & 0xff;\n        if (hi)\n          res.push(hi, lo);\n        else\n          res.push(lo);\n      }\n    } else if (enc === 'hex') {\n      msg = msg.replace(/[^a-z0-9]+/ig, '');\n      if (msg.length % 2 !== 0)\n        msg = '0' + msg;\n      for (i = 0; i < msg.length; i += 2)\n        res.push(parseInt(msg[i] + msg[i + 1], 16));\n    }\n  } else {\n    for (i = 0; i < msg.length; i++)\n      res[i] = msg[i] | 0;\n  }\n  return res;\n}\nexports.toArray = toArray;\n\nfunction toHex(msg) {\n  var res = '';\n  for (var i = 0; i < msg.length; i++)\n    res += zero2(msg[i].toString(16));\n  return res;\n}\nexports.toHex = toHex;\n\nfunction htonl(w) {\n  var res = (w >>> 24) |\n            ((w >>> 8) & 0xff00) |\n            ((w << 8) & 0xff0000) |\n            ((w & 0xff) << 24);\n  return res >>> 0;\n}\nexports.htonl = htonl;\n\nfunction toHex32(msg, endian) {\n  var res = '';\n  for (var i = 0; i < msg.length; i++) {\n    var w = msg[i];\n    if (endian === 'little')\n      w = htonl(w);\n    res += zero8(w.toString(16));\n  }\n  return res;\n}\nexports.toHex32 = toHex32;\n\nfunction zero2(word) {\n  if (word.length === 1)\n    return '0' + word;\n  else\n    return word;\n}\nexports.zero2 = zero2;\n\nfunction zero8(word) {\n  if (word.length === 7)\n    return '0' + word;\n  else if (word.length === 6)\n    return '00' + word;\n  else if (word.length === 5)\n    return '000' + word;\n  else if (word.length === 4)\n    return '0000' + word;\n  else if (word.length === 3)\n    return '00000' + word;\n  else if (word.length === 2)\n    return '000000' + word;\n  else if (word.length === 1)\n    return '0000000' + word;\n  else\n    return word;\n}\nexports.zero8 = zero8;\n\nfunction join32(msg, start, end, endian) {\n  var len = end - start;\n  assert(len % 4 === 0);\n  var res = new Array(len / 4);\n  for (var i = 0, k = start; i < res.length; i++, k += 4) {\n    var w;\n    if (endian === 'big')\n      w = (msg[k] << 24) | (msg[k + 1] << 16) | (msg[k + 2] << 8) | msg[k + 3];\n    else\n      w = (msg[k + 3] << 24) | (msg[k + 2] << 16) | (msg[k + 1] << 8) | msg[k];\n    res[i] = w >>> 0;\n  }\n  return res;\n}\nexports.join32 = join32;\n\nfunction split32(msg, endian) {\n  var res = new Array(msg.length * 4);\n  for (var i = 0, k = 0; i < msg.length; i++, k += 4) {\n    var m = msg[i];\n    if (endian === 'big') {\n      res[k] = m >>> 24;\n      res[k + 1] = (m >>> 16) & 0xff;\n      res[k + 2] = (m >>> 8) & 0xff;\n      res[k + 3] = m & 0xff;\n    } else {\n      res[k + 3] = m >>> 24;\n      res[k + 2] = (m >>> 16) & 0xff;\n      res[k + 1] = (m >>> 8) & 0xff;\n      res[k] = m & 0xff;\n    }\n  }\n  return res;\n}\nexports.split32 = split32;\n\nfunction rotr32(w, b) {\n  return (w >>> b) | (w << (32 - b));\n}\nexports.rotr32 = rotr32;\n\nfunction rotl32(w, b) {\n  return (w << b) | (w >>> (32 - b));\n}\nexports.rotl32 = rotl32;\n\nfunction sum32(a, b) {\n  return (a + b) >>> 0;\n}\nexports.sum32 = sum32;\n\nfunction sum32_3(a, b, c) {\n  return (a + b + c) >>> 0;\n}\nexports.sum32_3 = sum32_3;\n\nfunction sum32_4(a, b, c, d) {\n  return (a + b + c + d) >>> 0;\n}\nexports.sum32_4 = sum32_4;\n\nfunction sum32_5(a, b, c, d, e) {\n  return (a + b + c + d + e) >>> 0;\n}\nexports.sum32_5 = sum32_5;\n\nfunction sum64(buf, pos, ah, al) {\n  var bh = buf[pos];\n  var bl = buf[pos + 1];\n\n  var lo = (al + bl) >>> 0;\n  var hi = (lo < al ? 1 : 0) + ah + bh;\n  buf[pos] = hi >>> 0;\n  buf[pos + 1] = lo;\n}\nexports.sum64 = sum64;\n\nfunction sum64_hi(ah, al, bh, bl) {\n  var lo = (al + bl) >>> 0;\n  var hi = (lo < al ? 1 : 0) + ah + bh;\n  return hi >>> 0;\n}\nexports.sum64_hi = sum64_hi;\n\nfunction sum64_lo(ah, al, bh, bl) {\n  var lo = al + bl;\n  return lo >>> 0;\n}\nexports.sum64_lo = sum64_lo;\n\nfunction sum64_4_hi(ah, al, bh, bl, ch, cl, dh, dl) {\n  var carry = 0;\n  var lo = al;\n  lo = (lo + bl) >>> 0;\n  carry += lo < al ? 1 : 0;\n  lo = (lo + cl) >>> 0;\n  carry += lo < cl ? 1 : 0;\n  lo = (lo + dl) >>> 0;\n  carry += lo < dl ? 1 : 0;\n\n  var hi = ah + bh + ch + dh + carry;\n  return hi >>> 0;\n}\nexports.sum64_4_hi = sum64_4_hi;\n\nfunction sum64_4_lo(ah, al, bh, bl, ch, cl, dh, dl) {\n  var lo = al + bl + cl + dl;\n  return lo >>> 0;\n}\nexports.sum64_4_lo = sum64_4_lo;\n\nfunction sum64_5_hi(ah, al, bh, bl, ch, cl, dh, dl, eh, el) {\n  var carry = 0;\n  var lo = al;\n  lo = (lo + bl) >>> 0;\n  carry += lo < al ? 1 : 0;\n  lo = (lo + cl) >>> 0;\n  carry += lo < cl ? 1 : 0;\n  lo = (lo + dl) >>> 0;\n  carry += lo < dl ? 1 : 0;\n  lo = (lo + el) >>> 0;\n  carry += lo < el ? 1 : 0;\n\n  var hi = ah + bh + ch + dh + eh + carry;\n  return hi >>> 0;\n}\nexports.sum64_5_hi = sum64_5_hi;\n\nfunction sum64_5_lo(ah, al, bh, bl, ch, cl, dh, dl, eh, el) {\n  var lo = al + bl + cl + dl + el;\n\n  return lo >>> 0;\n}\nexports.sum64_5_lo = sum64_5_lo;\n\nfunction rotr64_hi(ah, al, num) {\n  var r = (al << (32 - num)) | (ah >>> num);\n  return r >>> 0;\n}\nexports.rotr64_hi = rotr64_hi;\n\nfunction rotr64_lo(ah, al, num) {\n  var r = (ah << (32 - num)) | (al >>> num);\n  return r >>> 0;\n}\nexports.rotr64_lo = rotr64_lo;\n\nfunction shr64_hi(ah, al, num) {\n  return ah >>> num;\n}\nexports.shr64_hi = shr64_hi;\n\nfunction shr64_lo(ah, al, num) {\n  var r = (ah << (32 - num)) | (al >>> num);\n  return r >>> 0;\n}\nexports.shr64_lo = shr64_lo;\n\n\n\n// WEBPACK FOOTER //\n// ./node_modules/hash.js/lib/hash/utils.js","var g;\r\n\r\n// This works in non-strict mode\r\ng = (function() {\r\n\treturn this;\r\n})();\r\n\r\ntry {\r\n\t// This works if eval is allowed (see CSP)\r\n\tg = g || Function(\"return this\")() || (1,eval)(\"this\");\r\n} catch(e) {\r\n\t// This works if the window reference is available\r\n\tif(typeof window === \"object\")\r\n\t\tg = window;\r\n}\r\n\r\n// g can still be undefined, but nothing to do about it...\r\n// We return undefined, instead of nothing here, so it's\r\n// easier to handle this case. if(!global) { ...}\r\n\r\nmodule.exports = g;\r\n\n\n\n// WEBPACK FOOTER //\n// (webpack)/buildin/global.js","module.exports = assert;\n\nfunction assert(val, msg) {\n  if (!val)\n    throw new Error(msg || 'Assertion failed');\n}\n\nassert.equal = function assertEqual(l, r, msg) {\n  if (l != r)\n    throw new Error(msg || ('Assertion failed: ' + l + ' != ' + r));\n};\n\n\n\n// WEBPACK FOOTER //\n// ./node_modules/minimalistic-assert/index.js","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// a duplex stream is just a stream that is both readable and writable.\n// Since JS doesn't have multiple prototypal inheritance, this class\n// prototypally inherits from Readable, and then parasitically from\n// Writable.\n\n'use strict';\n\n/*<replacement>*/\n\nvar processNextTick = require('process-nextick-args');\n/*</replacement>*/\n\n/*<replacement>*/\nvar objectKeys = Object.keys || function (obj) {\n  var keys = [];\n  for (var key in obj) {\n    keys.push(key);\n  }return keys;\n};\n/*</replacement>*/\n\nmodule.exports = Duplex;\n\n/*<replacement>*/\nvar util = require('core-util-is');\nutil.inherits = require('inherits');\n/*</replacement>*/\n\nvar Readable = require('./_stream_readable');\nvar Writable = require('./_stream_writable');\n\nutil.inherits(Duplex, Readable);\n\nvar keys = objectKeys(Writable.prototype);\nfor (var v = 0; v < keys.length; v++) {\n  var method = keys[v];\n  if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable.prototype[method];\n}\n\nfunction Duplex(options) {\n  if (!(this instanceof Duplex)) return new Duplex(options);\n\n  Readable.call(this, options);\n  Writable.call(this, options);\n\n  if (options && options.readable === false) this.readable = false;\n\n  if (options && options.writable === false) this.writable = false;\n\n  this.allowHalfOpen = true;\n  if (options && options.allowHalfOpen === false) this.allowHalfOpen = false;\n\n  this.once('end', onend);\n}\n\n// the no-half-open enforcer\nfunction onend() {\n  // if we allow half-open state, or if the writable side ended,\n  // then we're ok.\n  if (this.allowHalfOpen || this._writableState.ended) return;\n\n  // no more data can be written.\n  // But allow more writes to happen in this tick.\n  processNextTick(onEndNT, this);\n}\n\nfunction onEndNT(self) {\n  self.end();\n}\n\nObject.defineProperty(Duplex.prototype, 'destroyed', {\n  get: function () {\n    if (this._readableState === undefined || this._writableState === undefined) {\n      return false;\n    }\n    return this._readableState.destroyed && this._writableState.destroyed;\n  },\n  set: function (value) {\n    // we ignore the value if the stream\n    // has not been initialized yet\n    if (this._readableState === undefined || this._writableState === undefined) {\n      return;\n    }\n\n    // backward compatibility, the user is explicitly\n    // managing destroyed\n    this._readableState.destroyed = value;\n    this._writableState.destroyed = value;\n  }\n});\n\nDuplex.prototype._destroy = function (err, cb) {\n  this.push(null);\n  this.end();\n\n  processNextTick(cb, err);\n};\n\nfunction forEach(xs, f) {\n  for (var i = 0, l = xs.length; i < l; i++) {\n    f(xs[i], i);\n  }\n}\n\n\n// WEBPACK FOOTER //\n// ./node_modules/readable-stream/lib/_stream_duplex.js","'use strict';\n\nvar utils = require('./utils');\nvar assert = require('minimalistic-assert');\n\nfunction BlockHash() {\n  this.pending = null;\n  this.pendingTotal = 0;\n  this.blockSize = this.constructor.blockSize;\n  this.outSize = this.constructor.outSize;\n  this.hmacStrength = this.constructor.hmacStrength;\n  this.padLength = this.constructor.padLength / 8;\n  this.endian = 'big';\n\n  this._delta8 = this.blockSize / 8;\n  this._delta32 = this.blockSize / 32;\n}\nexports.BlockHash = BlockHash;\n\nBlockHash.prototype.update = function update(msg, enc) {\n  // Convert message to array, pad it, and join into 32bit blocks\n  msg = utils.toArray(msg, enc);\n  if (!this.pending)\n    this.pending = msg;\n  else\n    this.pending = this.pending.concat(msg);\n  this.pendingTotal += msg.length;\n\n  // Enough data, try updating\n  if (this.pending.length >= this._delta8) {\n    msg = this.pending;\n\n    // Process pending data in blocks\n    var r = msg.length % this._delta8;\n    this.pending = msg.slice(msg.length - r, msg.length);\n    if (this.pending.length === 0)\n      this.pending = null;\n\n    msg = utils.join32(msg, 0, msg.length - r, this.endian);\n    for (var i = 0; i < msg.length; i += this._delta32)\n      this._update(msg, i, i + this._delta32);\n  }\n\n  return this;\n};\n\nBlockHash.prototype.digest = function digest(enc) {\n  this.update(this._pad());\n  assert(this.pending === null);\n\n  return this._digest(enc);\n};\n\nBlockHash.prototype._pad = function pad() {\n  var len = this.pendingTotal;\n  var bytes = this._delta8;\n  var k = bytes - ((len + this.padLength) % bytes);\n  var res = new Array(k + this.padLength);\n  res[0] = 0x80;\n  for (var i = 1; i < k; i++)\n    res[i] = 0;\n\n  // Append length\n  len <<= 3;\n  if (this.endian === 'big') {\n    for (var t = 8; t < this.padLength; t++)\n      res[i++] = 0;\n\n    res[i++] = 0;\n    res[i++] = 0;\n    res[i++] = 0;\n    res[i++] = 0;\n    res[i++] = (len >>> 24) & 0xff;\n    res[i++] = (len >>> 16) & 0xff;\n    res[i++] = (len >>> 8) & 0xff;\n    res[i++] = len & 0xff;\n  } else {\n    res[i++] = len & 0xff;\n    res[i++] = (len >>> 8) & 0xff;\n    res[i++] = (len >>> 16) & 0xff;\n    res[i++] = (len >>> 24) & 0xff;\n    res[i++] = 0;\n    res[i++] = 0;\n    res[i++] = 0;\n    res[i++] = 0;\n\n    for (t = 8; t < this.padLength; t++)\n      res[i++] = 0;\n  }\n\n  return res;\n};\n\n\n\n// WEBPACK FOOTER //\n// ./node_modules/hash.js/lib/hash/common.js","// shim for using process in browser\nvar process = module.exports = {};\n\n// cached from whatever global is present so that test runners that stub it\n// don't break things.  But we need to wrap it in a try catch in case it is\n// wrapped in strict mode code which doesn't define any globals.  It's inside a\n// function because try/catches deoptimize in certain engines.\n\nvar cachedSetTimeout;\nvar cachedClearTimeout;\n\nfunction defaultSetTimout() {\n    throw new Error('setTimeout has not been defined');\n}\nfunction defaultClearTimeout () {\n    throw new Error('clearTimeout has not been defined');\n}\n(function () {\n    try {\n        if (typeof setTimeout === 'function') {\n            cachedSetTimeout = setTimeout;\n        } else {\n            cachedSetTimeout = defaultSetTimout;\n        }\n    } catch (e) {\n        cachedSetTimeout = defaultSetTimout;\n    }\n    try {\n        if (typeof clearTimeout === 'function') {\n            cachedClearTimeout = clearTimeout;\n        } else {\n            cachedClearTimeout = defaultClearTimeout;\n        }\n    } catch (e) {\n        cachedClearTimeout = defaultClearTimeout;\n    }\n} ())\nfunction runTimeout(fun) {\n    if (cachedSetTimeout === setTimeout) {\n        //normal enviroments in sane situations\n        return setTimeout(fun, 0);\n    }\n    // if setTimeout wasn't available but was latter defined\n    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n        cachedSetTimeout = setTimeout;\n        return setTimeout(fun, 0);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedSetTimeout(fun, 0);\n    } catch(e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n            return cachedSetTimeout.call(null, fun, 0);\n        } catch(e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error\n            return cachedSetTimeout.call(this, fun, 0);\n        }\n    }\n\n\n}\nfunction runClearTimeout(marker) {\n    if (cachedClearTimeout === clearTimeout) {\n        //normal enviroments in sane situations\n        return clearTimeout(marker);\n    }\n    // if clearTimeout wasn't available but was latter defined\n    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n        cachedClearTimeout = clearTimeout;\n        return clearTimeout(marker);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedClearTimeout(marker);\n    } catch (e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally\n            return cachedClearTimeout.call(null, marker);\n        } catch (e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.\n            // Some versions of I.E. have different rules for clearTimeout vs setTimeout\n            return cachedClearTimeout.call(this, marker);\n        }\n    }\n\n\n\n}\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\n\nfunction cleanUpNextTick() {\n    if (!draining || !currentQueue) {\n        return;\n    }\n    draining = false;\n    if (currentQueue.length) {\n        queue = currentQueue.concat(queue);\n    } else {\n        queueIndex = -1;\n    }\n    if (queue.length) {\n        drainQueue();\n    }\n}\n\nfunction drainQueue() {\n    if (draining) {\n        return;\n    }\n    var timeout = runTimeout(cleanUpNextTick);\n    draining = true;\n\n    var len = queue.length;\n    while(len) {\n        currentQueue = queue;\n        queue = [];\n        while (++queueIndex < len) {\n            if (currentQueue) {\n                currentQueue[queueIndex].run();\n            }\n        }\n        queueIndex = -1;\n        len = queue.length;\n    }\n    currentQueue = null;\n    draining = false;\n    runClearTimeout(timeout);\n}\n\nprocess.nextTick = function (fun) {\n    var args = new Array(arguments.length - 1);\n    if (arguments.length > 1) {\n        for (var i = 1; i < arguments.length; i++) {\n            args[i - 1] = arguments[i];\n        }\n    }\n    queue.push(new Item(fun, args));\n    if (queue.length === 1 && !draining) {\n        runTimeout(drainQueue);\n    }\n};\n\n// v8 likes predictible objects\nfunction Item(fun, array) {\n    this.fun = fun;\n    this.array = array;\n}\nItem.prototype.run = function () {\n    this.fun.apply(null, this.array);\n};\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\nprocess.version = ''; // empty string to avoid regexp issues\nprocess.versions = {};\n\nfunction noop() {}\n\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\nprocess.prependListener = noop;\nprocess.prependOnceListener = noop;\n\nprocess.listeners = function (name) { return [] }\n\nprocess.binding = function (name) {\n    throw new Error('process.binding is not supported');\n};\n\nprocess.cwd = function () { return '/' };\nprocess.chdir = function (dir) {\n    throw new Error('process.chdir is not supported');\n};\nprocess.umask = function() { return 0; };\n\n\n\n// WEBPACK FOOTER //\n// ./node_modules/process/browser.js","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// NOTE: These type checking functions intentionally don't use `instanceof`\n// because it is fragile and can be easily faked with `Object.create()`.\n\nfunction isArray(arg) {\n  if (Array.isArray) {\n    return Array.isArray(arg);\n  }\n  return objectToString(arg) === '[object Array]';\n}\nexports.isArray = isArray;\n\nfunction isBoolean(arg) {\n  return typeof arg === 'boolean';\n}\nexports.isBoolean = isBoolean;\n\nfunction isNull(arg) {\n  return arg === null;\n}\nexports.isNull = isNull;\n\nfunction isNullOrUndefined(arg) {\n  return arg == null;\n}\nexports.isNullOrUndefined = isNullOrUndefined;\n\nfunction isNumber(arg) {\n  return typeof arg === 'number';\n}\nexports.isNumber = isNumber;\n\nfunction isString(arg) {\n  return typeof arg === 'string';\n}\nexports.isString = isString;\n\nfunction isSymbol(arg) {\n  return typeof arg === 'symbol';\n}\nexports.isSymbol = isSymbol;\n\nfunction isUndefined(arg) {\n  return arg === void 0;\n}\nexports.isUndefined = isUndefined;\n\nfunction isRegExp(re) {\n  return objectToString(re) === '[object RegExp]';\n}\nexports.isRegExp = isRegExp;\n\nfunction isObject(arg) {\n  return typeof arg === 'object' && arg !== null;\n}\nexports.isObject = isObject;\n\nfunction isDate(d) {\n  return objectToString(d) === '[object Date]';\n}\nexports.isDate = isDate;\n\nfunction isError(e) {\n  return (objectToString(e) === '[object Error]' || e instanceof Error);\n}\nexports.isError = isError;\n\nfunction isFunction(arg) {\n  return typeof arg === 'function';\n}\nexports.isFunction = isFunction;\n\nfunction isPrimitive(arg) {\n  return arg === null ||\n         typeof arg === 'boolean' ||\n         typeof arg === 'number' ||\n         typeof arg === 'string' ||\n         typeof arg === 'symbol' ||  // ES6 symbol\n         typeof arg === 'undefined';\n}\nexports.isPrimitive = isPrimitive;\n\nexports.isBuffer = Buffer.isBuffer;\n\nfunction objectToString(o) {\n  return Object.prototype.toString.call(o);\n}\n\n\n\n// WEBPACK FOOTER //\n// ./node_modules/core-util-is/lib/util.js","'use strict';\n\nvar curve = exports;\n\ncurve.base = require('./base');\ncurve.short = require('./short');\ncurve.mont = require('./mont');\ncurve.edwards = require('./edwards');\n\n\n\n// WEBPACK FOOTER //\n// ./node_modules/elliptic/lib/elliptic/curve/index.js","// based on:\r\n//   https://github.com/ethereumjs/rlp/raw/3122e47f7c2ff2c7efa67acfeabe02a5f3a3670a/index.js\r\n\r\n/**\r\n * RLP Encoding based on: https://github.com/ethereum/wiki/wiki/%5BEnglish%5D-RLP\r\n * This function takes in a data, convert it to buffer if not, and a length for recursion\r\n *\r\n * @param {Buffer,String,Integer,Array} data - will be converted to buffer\r\n * @returns {Buffer} - returns buffer of encoded data\r\n **/\r\nfunction encode (input) {\r\n  if (input instanceof Array) {\r\n    var output = []\r\n    for (var i = 0; i < input.length; i++) {\r\n      output.push(encode(input[i]))\r\n    }\r\n    var buf = Buffer.concat(output)\r\n    return Buffer.concat([encodeLength(buf.length, 192), buf])\r\n  } else {\r\n    input = toBuffer(input)\r\n    if (input.length === 1 && input[0] < 128) {\r\n      return input\r\n    } else {\r\n      return Buffer.concat([encodeLength(input.length, 128), input])\r\n    }\r\n  }\r\n}\r\n\r\nfunction safeParseInt (v, base) {\r\n  if (v.slice(0, 2) === '00') {\r\n    throw (new Error('invalid RLP: extra zeros'))\r\n  }\r\n\r\n  return parseInt(v, base)\r\n}\r\n\r\nfunction encodeLength (len, offset) {\r\n  if (len < 56) {\r\n    return new Buffer([len + offset])\r\n  } else {\r\n    var hexLength = intToHex(len)\r\n    var lLength = hexLength.length / 2\r\n    var firstByte = intToHex(offset + 55 + lLength)\r\n    return new Buffer(firstByte + hexLength, 'hex')\r\n  }\r\n}\r\n\r\nfunction isHexPrefixed (str) {\r\n  return str.slice(0, 2) === '0x'\r\n}\r\n\r\n// Removes 0x from a given String\r\nfunction stripHexPrefix (str) {\r\n  if (typeof str !== 'string') {\r\n    return str\r\n  }\r\n  return isHexPrefixed(str) ? str.slice(2) : str\r\n}\r\n\r\n// Removes leading zeros from: Buffer, Array, or String\r\nfunction stripZeros (a) {\r\n  a = stripHexPrefix(a)\r\n  var first = a[0]\r\n  while (a.length > 0 && first.toString() === '0') {\r\n    a = a.slice(1)\r\n    first = a[0]\r\n  }\r\n  return a\r\n}\r\n\r\nfunction intToHex (i) {\r\n  var hex = i.toString(16)\r\n  if (hex.length % 2) {\r\n    hex = '0' + hex\r\n  }\r\n\r\n  return hex\r\n}\r\n\r\nfunction padToEven (a) {\r\n  if (a.length % 2) a = '0' + a\r\n  return a\r\n}\r\n\r\nfunction intToBuffer (i) {\r\n  var hex = intToHex(i)\r\n  return new Buffer(hex, 'hex')\r\n}\r\n\r\nfunction toBuffer (v) {\r\n  if (!Buffer.isBuffer(v)) {\r\n    if (Array.isArray(v)) {\r\n      v = Buffer.from(v)\r\n    } else if (typeof v === 'string') {\r\n      if (isHexPrefixed(v)) {\r\n        v = Buffer.from(padToEven(stripHexPrefix(v)), 'hex')\r\n      } else {\r\n        v = Buffer.from(v)\r\n      }\r\n    } else if (typeof v === 'number') {\r\n      v = intToBuffer(v)\r\n    } else if (v === null || v === undefined) {\r\n      v = Buffer.allocUnsafe(0)\r\n    } else if (v.toArray) {\r\n      // converts a BN to a Buffer\r\n      v = Buffer.from(v.toArray())\r\n    } else {\r\n      throw new Error('invalid type')\r\n    }\r\n  }\r\n  return v\r\n}\r\n\r\nfunction bufferToHex (buf, add_prefix=true) {\r\n  buf = toBuffer(buf)\r\n  if ((! buf) || (buf.length === 0))\r\n    return ''\r\n  else\r\n    return (add_prefix ? '0x' : '') + buf.toString('hex')\r\n}\r\n\r\nfunction bufferToInt (buf) {\r\n  return parseInt(bufferToHex(buf), 16)\r\n}\r\n\r\nmodule.exports = {encode, isHexPrefixed, stripHexPrefix, stripZeros, intToHex, padToEven, intToBuffer, toBuffer, bufferToHex, bufferToInt}\r\n\n\n\n// WEBPACK FOOTER //\n// ./../lib/rlp.js","'use strict';\n\nif (!process.version ||\n    process.version.indexOf('v0.') === 0 ||\n    process.version.indexOf('v1.') === 0 && process.version.indexOf('v1.8.') !== 0) {\n  module.exports = nextTick;\n} else {\n  module.exports = process.nextTick;\n}\n\nfunction nextTick(fn, arg1, arg2, arg3) {\n  if (typeof fn !== 'function') {\n    throw new TypeError('\"callback\" argument must be a function');\n  }\n  var len = arguments.length;\n  var args, i;\n  switch (len) {\n  case 0:\n  case 1:\n    return process.nextTick(fn);\n  case 2:\n    return process.nextTick(function afterTickOne() {\n      fn.call(null, arg1);\n    });\n  case 3:\n    return process.nextTick(function afterTickTwo() {\n      fn.call(null, arg1, arg2);\n    });\n  case 4:\n    return process.nextTick(function afterTickThree() {\n      fn.call(null, arg1, arg2, arg3);\n    });\n  default:\n    args = new Array(len - 1);\n    i = 0;\n    while (i < args.length) {\n      args[i++] = arguments[i];\n    }\n    return process.nextTick(function afterTick() {\n      fn.apply(null, args);\n    });\n  }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./node_modules/process-nextick-args/index.js","/* eslint-disable node/no-deprecated-api */\nvar buffer = require('buffer')\nvar Buffer = buffer.Buffer\n\n// alternative to using Object.keys for old browsers\nfunction copyProps (src, dst) {\n  for (var key in src) {\n    dst[key] = src[key]\n  }\n}\nif (Buffer.from && Buffer.alloc && Buffer.allocUnsafe && Buffer.allocUnsafeSlow) {\n  module.exports = buffer\n} else {\n  // Copy properties from require('buffer')\n  copyProps(buffer, exports)\n  exports.Buffer = SafeBuffer\n}\n\nfunction SafeBuffer (arg, encodingOrOffset, length) {\n  return Buffer(arg, encodingOrOffset, length)\n}\n\n// Copy static methods from Buffer\ncopyProps(Buffer, SafeBuffer)\n\nSafeBuffer.from = function (arg, encodingOrOffset, length) {\n  if (typeof arg === 'number') {\n    throw new TypeError('Argument must not be a number')\n  }\n  return Buffer(arg, encodingOrOffset, length)\n}\n\nSafeBuffer.alloc = function (size, fill, encoding) {\n  if (typeof size !== 'number') {\n    throw new TypeError('Argument must be a number')\n  }\n  var buf = Buffer(size)\n  if (fill !== undefined) {\n    if (typeof encoding === 'string') {\n      buf.fill(fill, encoding)\n    } else {\n      buf.fill(fill)\n    }\n  } else {\n    buf.fill(0)\n  }\n  return buf\n}\n\nSafeBuffer.allocUnsafe = function (size) {\n  if (typeof size !== 'number') {\n    throw new TypeError('Argument must be a number')\n  }\n  return Buffer(size)\n}\n\nSafeBuffer.allocUnsafeSlow = function (size) {\n  if (typeof size !== 'number') {\n    throw new TypeError('Argument must be a number')\n  }\n  return buffer.SlowBuffer(size)\n}\n\n\n\n// WEBPACK FOOTER //\n// ./node_modules/safe-buffer/index.js","var hash = exports;\n\nhash.utils = require('./hash/utils');\nhash.common = require('./hash/common');\nhash.sha = require('./hash/sha');\nhash.ripemd = require('./hash/ripemd');\nhash.hmac = require('./hash/hmac');\n\n// Proxy hash functions to the main object\nhash.sha1 = hash.sha.sha1;\nhash.sha256 = hash.sha.sha256;\nhash.sha224 = hash.sha.sha224;\nhash.sha384 = hash.sha.sha384;\nhash.sha512 = hash.sha.sha512;\nhash.ripemd160 = hash.ripemd.ripemd160;\n\n\n\n// WEBPACK FOOTER //\n// ./node_modules/hash.js/lib/hash.js","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nvar formatRegExp = /%[sdj%]/g;\nexports.format = function(f) {\n  if (!isString(f)) {\n    var objects = [];\n    for (var i = 0; i < arguments.length; i++) {\n      objects.push(inspect(arguments[i]));\n    }\n    return objects.join(' ');\n  }\n\n  var i = 1;\n  var args = arguments;\n  var len = args.length;\n  var str = String(f).replace(formatRegExp, function(x) {\n    if (x === '%%') return '%';\n    if (i >= len) return x;\n    switch (x) {\n      case '%s': return String(args[i++]);\n      case '%d': return Number(args[i++]);\n      case '%j':\n        try {\n          return JSON.stringify(args[i++]);\n        } catch (_) {\n          return '[Circular]';\n        }\n      default:\n        return x;\n    }\n  });\n  for (var x = args[i]; i < len; x = args[++i]) {\n    if (isNull(x) || !isObject(x)) {\n      str += ' ' + x;\n    } else {\n      str += ' ' + inspect(x);\n    }\n  }\n  return str;\n};\n\n\n// Mark that a method should not be used.\n// Returns a modified function which warns once by default.\n// If --no-deprecation is set, then it is a no-op.\nexports.deprecate = function(fn, msg) {\n  // Allow for deprecating things in the process of starting up.\n  if (isUndefined(global.process)) {\n    return function() {\n      return exports.deprecate(fn, msg).apply(this, arguments);\n    };\n  }\n\n  if (process.noDeprecation === true) {\n    return fn;\n  }\n\n  var warned = false;\n  function deprecated() {\n    if (!warned) {\n      if (process.throwDeprecation) {\n        throw new Error(msg);\n      } else if (process.traceDeprecation) {\n        console.trace(msg);\n      } else {\n        console.error(msg);\n      }\n      warned = true;\n    }\n    return fn.apply(this, arguments);\n  }\n\n  return deprecated;\n};\n\n\nvar debugs = {};\nvar debugEnviron;\nexports.debuglog = function(set) {\n  if (isUndefined(debugEnviron))\n    debugEnviron = process.env.NODE_DEBUG || '';\n  set = set.toUpperCase();\n  if (!debugs[set]) {\n    if (new RegExp('\\\\b' + set + '\\\\b', 'i').test(debugEnviron)) {\n      var pid = process.pid;\n      debugs[set] = function() {\n        var msg = exports.format.apply(exports, arguments);\n        console.error('%s %d: %s', set, pid, msg);\n      };\n    } else {\n      debugs[set] = function() {};\n    }\n  }\n  return debugs[set];\n};\n\n\n/**\n * Echos the value of a value. Trys to print the value out\n * in the best way possible given the different types.\n *\n * @param {Object} obj The object to print out.\n * @param {Object} opts Optional options object that alters the output.\n */\n/* legacy: obj, showHidden, depth, colors*/\nfunction inspect(obj, opts) {\n  // default options\n  var ctx = {\n    seen: [],\n    stylize: stylizeNoColor\n  };\n  // legacy...\n  if (arguments.length >= 3) ctx.depth = arguments[2];\n  if (arguments.length >= 4) ctx.colors = arguments[3];\n  if (isBoolean(opts)) {\n    // legacy...\n    ctx.showHidden = opts;\n  } else if (opts) {\n    // got an \"options\" object\n    exports._extend(ctx, opts);\n  }\n  // set default options\n  if (isUndefined(ctx.showHidden)) ctx.showHidden = false;\n  if (isUndefined(ctx.depth)) ctx.depth = 2;\n  if (isUndefined(ctx.colors)) ctx.colors = false;\n  if (isUndefined(ctx.customInspect)) ctx.customInspect = true;\n  if (ctx.colors) ctx.stylize = stylizeWithColor;\n  return formatValue(ctx, obj, ctx.depth);\n}\nexports.inspect = inspect;\n\n\n// http://en.wikipedia.org/wiki/ANSI_escape_code#graphics\ninspect.colors = {\n  'bold' : [1, 22],\n  'italic' : [3, 23],\n  'underline' : [4, 24],\n  'inverse' : [7, 27],\n  'white' : [37, 39],\n  'grey' : [90, 39],\n  'black' : [30, 39],\n  'blue' : [34, 39],\n  'cyan' : [36, 39],\n  'green' : [32, 39],\n  'magenta' : [35, 39],\n  'red' : [31, 39],\n  'yellow' : [33, 39]\n};\n\n// Don't use 'blue' not visible on cmd.exe\ninspect.styles = {\n  'special': 'cyan',\n  'number': 'yellow',\n  'boolean': 'yellow',\n  'undefined': 'grey',\n  'null': 'bold',\n  'string': 'green',\n  'date': 'magenta',\n  // \"name\": intentionally not styling\n  'regexp': 'red'\n};\n\n\nfunction stylizeWithColor(str, styleType) {\n  var style = inspect.styles[styleType];\n\n  if (style) {\n    return '\\u001b[' + inspect.colors[style][0] + 'm' + str +\n           '\\u001b[' + inspect.colors[style][1] + 'm';\n  } else {\n    return str;\n  }\n}\n\n\nfunction stylizeNoColor(str, styleType) {\n  return str;\n}\n\n\nfunction arrayToHash(array) {\n  var hash = {};\n\n  array.forEach(function(val, idx) {\n    hash[val] = true;\n  });\n\n  return hash;\n}\n\n\nfunction formatValue(ctx, value, recurseTimes) {\n  // Provide a hook for user-specified inspect functions.\n  // Check that value is an object with an inspect function on it\n  if (ctx.customInspect &&\n      value &&\n      isFunction(value.inspect) &&\n      // Filter out the util module, it's inspect function is special\n      value.inspect !== exports.inspect &&\n      // Also filter out any prototype objects using the circular check.\n      !(value.constructor && value.constructor.prototype === value)) {\n    var ret = value.inspect(recurseTimes, ctx);\n    if (!isString(ret)) {\n      ret = formatValue(ctx, ret, recurseTimes);\n    }\n    return ret;\n  }\n\n  // Primitive types cannot have properties\n  var primitive = formatPrimitive(ctx, value);\n  if (primitive) {\n    return primitive;\n  }\n\n  // Look up the keys of the object.\n  var keys = Object.keys(value);\n  var visibleKeys = arrayToHash(keys);\n\n  if (ctx.showHidden) {\n    keys = Object.getOwnPropertyNames(value);\n  }\n\n  // IE doesn't make error fields non-enumerable\n  // http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx\n  if (isError(value)\n      && (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) {\n    return formatError(value);\n  }\n\n  // Some type of object without properties can be shortcutted.\n  if (keys.length === 0) {\n    if (isFunction(value)) {\n      var name = value.name ? ': ' + value.name : '';\n      return ctx.stylize('[Function' + name + ']', 'special');\n    }\n    if (isRegExp(value)) {\n      return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');\n    }\n    if (isDate(value)) {\n      return ctx.stylize(Date.prototype.toString.call(value), 'date');\n    }\n    if (isError(value)) {\n      return formatError(value);\n    }\n  }\n\n  var base = '', array = false, braces = ['{', '}'];\n\n  // Make Array say that they are Array\n  if (isArray(value)) {\n    array = true;\n    braces = ['[', ']'];\n  }\n\n  // Make functions say that they are functions\n  if (isFunction(value)) {\n    var n = value.name ? ': ' + value.name : '';\n    base = ' [Function' + n + ']';\n  }\n\n  // Make RegExps say that they are RegExps\n  if (isRegExp(value)) {\n    base = ' ' + RegExp.prototype.toString.call(value);\n  }\n\n  // Make dates with properties first say the date\n  if (isDate(value)) {\n    base = ' ' + Date.prototype.toUTCString.call(value);\n  }\n\n  // Make error with message first say the error\n  if (isError(value)) {\n    base = ' ' + formatError(value);\n  }\n\n  if (keys.length === 0 && (!array || value.length == 0)) {\n    return braces[0] + base + braces[1];\n  }\n\n  if (recurseTimes < 0) {\n    if (isRegExp(value)) {\n      return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');\n    } else {\n      return ctx.stylize('[Object]', 'special');\n    }\n  }\n\n  ctx.seen.push(value);\n\n  var output;\n  if (array) {\n    output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);\n  } else {\n    output = keys.map(function(key) {\n      return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);\n    });\n  }\n\n  ctx.seen.pop();\n\n  return reduceToSingleString(output, base, braces);\n}\n\n\nfunction formatPrimitive(ctx, value) {\n  if (isUndefined(value))\n    return ctx.stylize('undefined', 'undefined');\n  if (isString(value)) {\n    var simple = '\\'' + JSON.stringify(value).replace(/^\"|\"$/g, '')\n                                             .replace(/'/g, \"\\\\'\")\n                                             .replace(/\\\\\"/g, '\"') + '\\'';\n    return ctx.stylize(simple, 'string');\n  }\n  if (isNumber(value))\n    return ctx.stylize('' + value, 'number');\n  if (isBoolean(value))\n    return ctx.stylize('' + value, 'boolean');\n  // For some reason typeof null is \"object\", so special case here.\n  if (isNull(value))\n    return ctx.stylize('null', 'null');\n}\n\n\nfunction formatError(value) {\n  return '[' + Error.prototype.toString.call(value) + ']';\n}\n\n\nfunction formatArray(ctx, value, recurseTimes, visibleKeys, keys) {\n  var output = [];\n  for (var i = 0, l = value.length; i < l; ++i) {\n    if (hasOwnProperty(value, String(i))) {\n      output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,\n          String(i), true));\n    } else {\n      output.push('');\n    }\n  }\n  keys.forEach(function(key) {\n    if (!key.match(/^\\d+$/)) {\n      output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,\n          key, true));\n    }\n  });\n  return output;\n}\n\n\nfunction formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {\n  var name, str, desc;\n  desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] };\n  if (desc.get) {\n    if (desc.set) {\n      str = ctx.stylize('[Getter/Setter]', 'special');\n    } else {\n      str = ctx.stylize('[Getter]', 'special');\n    }\n  } else {\n    if (desc.set) {\n      str = ctx.stylize('[Setter]', 'special');\n    }\n  }\n  if (!hasOwnProperty(visibleKeys, key)) {\n    name = '[' + key + ']';\n  }\n  if (!str) {\n    if (ctx.seen.indexOf(desc.value) < 0) {\n      if (isNull(recurseTimes)) {\n        str = formatValue(ctx, desc.value, null);\n      } else {\n        str = formatValue(ctx, desc.value, recurseTimes - 1);\n      }\n      if (str.indexOf('\\n') > -1) {\n        if (array) {\n          str = str.split('\\n').map(function(line) {\n            return '  ' + line;\n          }).join('\\n').substr(2);\n        } else {\n          str = '\\n' + str.split('\\n').map(function(line) {\n            return '   ' + line;\n          }).join('\\n');\n        }\n      }\n    } else {\n      str = ctx.stylize('[Circular]', 'special');\n    }\n  }\n  if (isUndefined(name)) {\n    if (array && key.match(/^\\d+$/)) {\n      return str;\n    }\n    name = JSON.stringify('' + key);\n    if (name.match(/^\"([a-zA-Z_][a-zA-Z_0-9]*)\"$/)) {\n      name = name.substr(1, name.length - 2);\n      name = ctx.stylize(name, 'name');\n    } else {\n      name = name.replace(/'/g, \"\\\\'\")\n                 .replace(/\\\\\"/g, '\"')\n                 .replace(/(^\"|\"$)/g, \"'\");\n      name = ctx.stylize(name, 'string');\n    }\n  }\n\n  return name + ': ' + str;\n}\n\n\nfunction reduceToSingleString(output, base, braces) {\n  var numLinesEst = 0;\n  var length = output.reduce(function(prev, cur) {\n    numLinesEst++;\n    if (cur.indexOf('\\n') >= 0) numLinesEst++;\n    return prev + cur.replace(/\\u001b\\[\\d\\d?m/g, '').length + 1;\n  }, 0);\n\n  if (length > 60) {\n    return braces[0] +\n           (base === '' ? '' : base + '\\n ') +\n           ' ' +\n           output.join(',\\n  ') +\n           ' ' +\n           braces[1];\n  }\n\n  return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];\n}\n\n\n// NOTE: These type checking functions intentionally don't use `instanceof`\n// because it is fragile and can be easily faked with `Object.create()`.\nfunction isArray(ar) {\n  return Array.isArray(ar);\n}\nexports.isArray = isArray;\n\nfunction isBoolean(arg) {\n  return typeof arg === 'boolean';\n}\nexports.isBoolean = isBoolean;\n\nfunction isNull(arg) {\n  return arg === null;\n}\nexports.isNull = isNull;\n\nfunction isNullOrUndefined(arg) {\n  return arg == null;\n}\nexports.isNullOrUndefined = isNullOrUndefined;\n\nfunction isNumber(arg) {\n  return typeof arg === 'number';\n}\nexports.isNumber = isNumber;\n\nfunction isString(arg) {\n  return typeof arg === 'string';\n}\nexports.isString = isString;\n\nfunction isSymbol(arg) {\n  return typeof arg === 'symbol';\n}\nexports.isSymbol = isSymbol;\n\nfunction isUndefined(arg) {\n  return arg === void 0;\n}\nexports.isUndefined = isUndefined;\n\nfunction isRegExp(re) {\n  return isObject(re) && objectToString(re) === '[object RegExp]';\n}\nexports.isRegExp = isRegExp;\n\nfunction isObject(arg) {\n  return typeof arg === 'object' && arg !== null;\n}\nexports.isObject = isObject;\n\nfunction isDate(d) {\n  return isObject(d) && objectToString(d) === '[object Date]';\n}\nexports.isDate = isDate;\n\nfunction isError(e) {\n  return isObject(e) &&\n      (objectToString(e) === '[object Error]' || e instanceof Error);\n}\nexports.isError = isError;\n\nfunction isFunction(arg) {\n  return typeof arg === 'function';\n}\nexports.isFunction = isFunction;\n\nfunction isPrimitive(arg) {\n  return arg === null ||\n         typeof arg === 'boolean' ||\n         typeof arg === 'number' ||\n         typeof arg === 'string' ||\n         typeof arg === 'symbol' ||  // ES6 symbol\n         typeof arg === 'undefined';\n}\nexports.isPrimitive = isPrimitive;\n\nexports.isBuffer = require('./support/isBuffer');\n\nfunction objectToString(o) {\n  return Object.prototype.toString.call(o);\n}\n\n\nfunction pad(n) {\n  return n < 10 ? '0' + n.toString(10) : n.toString(10);\n}\n\n\nvar months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep',\n              'Oct', 'Nov', 'Dec'];\n\n// 26 Feb 16:19:34\nfunction timestamp() {\n  var d = new Date();\n  var time = [pad(d.getHours()),\n              pad(d.getMinutes()),\n              pad(d.getSeconds())].join(':');\n  return [d.getDate(), months[d.getMonth()], time].join(' ');\n}\n\n\n// log is just a thin wrapper to console.log that prepends a timestamp\nexports.log = function() {\n  console.log('%s - %s', timestamp(), exports.format.apply(exports, arguments));\n};\n\n\n/**\n * Inherit the prototype methods from one constructor into another.\n *\n * The Function.prototype.inherits from lang.js rewritten as a standalone\n * function (not on Function.prototype). NOTE: If this file is to be loaded\n * during bootstrapping this function needs to be rewritten using some native\n * functions as prototype setup using normal JavaScript does not work as\n * expected during bootstrapping (see mirror.js in r114903).\n *\n * @param {function} ctor Constructor function which needs to inherit the\n *     prototype.\n * @param {function} superCtor Constructor function to inherit prototype from.\n */\nexports.inherits = require('inherits');\n\nexports._extend = function(origin, add) {\n  // Don't do anything if add isn't an object\n  if (!add || !isObject(add)) return origin;\n\n  var keys = Object.keys(add);\n  var i = keys.length;\n  while (i--) {\n    origin[keys[i]] = add[keys[i]];\n  }\n  return origin;\n};\n\nfunction hasOwnProperty(obj, prop) {\n  return Object.prototype.hasOwnProperty.call(obj, prop);\n}\n\n\n\n// WEBPACK FOOTER //\n// ./node_modules/util/util.js","'use strict'\r\n\r\n// based on:\r\n//   https://github.com/cryptocoinjs/keccak/raw/v1.3.0/js.js\r\n//   https://github.com/cryptocoinjs/keccak/tree/v1.3.0/lib\r\n\r\nconst createKeccakHash = require('./api')(require('./keccak'))\r\n\r\nconst toBuffer = require('../rlp').toBuffer\r\n\r\n// ====================\r\n// ethereumjs-util.sha3\r\n// ====================\r\nconst sha3 = function (a, bits) {\r\n  a = toBuffer(a)\r\n  if (!bits) bits = 256\r\n\r\n  return createKeccakHash('keccak' + bits).update(a).digest('hex')\r\n}\r\n\r\nmodule.exports = {createKeccakHash, sha3}\r\n\n\n\n// WEBPACK FOOTER //\n// ./../lib/keccak/index.js","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nfunction EventEmitter() {\n  this._events = this._events || {};\n  this._maxListeners = this._maxListeners || undefined;\n}\nmodule.exports = EventEmitter;\n\n// Backwards-compat with node 0.10.x\nEventEmitter.EventEmitter = EventEmitter;\n\nEventEmitter.prototype._events = undefined;\nEventEmitter.prototype._maxListeners = undefined;\n\n// By default EventEmitters will print a warning if more than 10 listeners are\n// added to it. This is a useful default which helps finding memory leaks.\nEventEmitter.defaultMaxListeners = 10;\n\n// Obviously not all Emitters should be limited to 10. This function allows\n// that to be increased. Set to zero for unlimited.\nEventEmitter.prototype.setMaxListeners = function(n) {\n  if (!isNumber(n) || n < 0 || isNaN(n))\n    throw TypeError('n must be a positive number');\n  this._maxListeners = n;\n  return this;\n};\n\nEventEmitter.prototype.emit = function(type) {\n  var er, handler, len, args, i, listeners;\n\n  if (!this._events)\n    this._events = {};\n\n  // If there is no 'error' event listener then throw.\n  if (type === 'error') {\n    if (!this._events.error ||\n        (isObject(this._events.error) && !this._events.error.length)) {\n      er = arguments[1];\n      if (er instanceof Error) {\n        throw er; // Unhandled 'error' event\n      } else {\n        // At least give some kind of context to the user\n        var err = new Error('Uncaught, unspecified \"error\" event. (' + er + ')');\n        err.context = er;\n        throw err;\n      }\n    }\n  }\n\n  handler = this._events[type];\n\n  if (isUndefined(handler))\n    return false;\n\n  if (isFunction(handler)) {\n    switch (arguments.length) {\n      // fast cases\n      case 1:\n        handler.call(this);\n        break;\n      case 2:\n        handler.call(this, arguments[1]);\n        break;\n      case 3:\n        handler.call(this, arguments[1], arguments[2]);\n        break;\n      // slower\n      default:\n        args = Array.prototype.slice.call(arguments, 1);\n        handler.apply(this, args);\n    }\n  } else if (isObject(handler)) {\n    args = Array.prototype.slice.call(arguments, 1);\n    listeners = handler.slice();\n    len = listeners.length;\n    for (i = 0; i < len; i++)\n      listeners[i].apply(this, args);\n  }\n\n  return true;\n};\n\nEventEmitter.prototype.addListener = function(type, listener) {\n  var m;\n\n  if (!isFunction(listener))\n    throw TypeError('listener must be a function');\n\n  if (!this._events)\n    this._events = {};\n\n  // To avoid recursion in the case that type === \"newListener\"! Before\n  // adding it to the listeners, first emit \"newListener\".\n  if (this._events.newListener)\n    this.emit('newListener', type,\n              isFunction(listener.listener) ?\n              listener.listener : listener);\n\n  if (!this._events[type])\n    // Optimize the case of one listener. Don't need the extra array object.\n    this._events[type] = listener;\n  else if (isObject(this._events[type]))\n    // If we've already got an array, just append.\n    this._events[type].push(listener);\n  else\n    // Adding the second element, need to change to array.\n    this._events[type] = [this._events[type], listener];\n\n  // Check for listener leak\n  if (isObject(this._events[type]) && !this._events[type].warned) {\n    if (!isUndefined(this._maxListeners)) {\n      m = this._maxListeners;\n    } else {\n      m = EventEmitter.defaultMaxListeners;\n    }\n\n    if (m && m > 0 && this._events[type].length > m) {\n      this._events[type].warned = true;\n      console.error('(node) warning: possible EventEmitter memory ' +\n                    'leak detected. %d listeners added. ' +\n                    'Use emitter.setMaxListeners() to increase limit.',\n                    this._events[type].length);\n      if (typeof console.trace === 'function') {\n        // not supported in IE 10\n        console.trace();\n      }\n    }\n  }\n\n  return this;\n};\n\nEventEmitter.prototype.on = EventEmitter.prototype.addListener;\n\nEventEmitter.prototype.once = function(type, listener) {\n  if (!isFunction(listener))\n    throw TypeError('listener must be a function');\n\n  var fired = false;\n\n  function g() {\n    this.removeListener(type, g);\n\n    if (!fired) {\n      fired = true;\n      listener.apply(this, arguments);\n    }\n  }\n\n  g.listener = listener;\n  this.on(type, g);\n\n  return this;\n};\n\n// emits a 'removeListener' event iff the listener was removed\nEventEmitter.prototype.removeListener = function(type, listener) {\n  var list, position, length, i;\n\n  if (!isFunction(listener))\n    throw TypeError('listener must be a function');\n\n  if (!this._events || !this._events[type])\n    return this;\n\n  list = this._events[type];\n  length = list.length;\n  position = -1;\n\n  if (list === listener ||\n      (isFunction(list.listener) && list.listener === listener)) {\n    delete this._events[type];\n    if (this._events.removeListener)\n      this.emit('removeListener', type, listener);\n\n  } else if (isObject(list)) {\n    for (i = length; i-- > 0;) {\n      if (list[i] === listener ||\n          (list[i].listener && list[i].listener === listener)) {\n        position = i;\n        break;\n      }\n    }\n\n    if (position < 0)\n      return this;\n\n    if (list.length === 1) {\n      list.length = 0;\n      delete this._events[type];\n    } else {\n      list.splice(position, 1);\n    }\n\n    if (this._events.removeListener)\n      this.emit('removeListener', type, listener);\n  }\n\n  return this;\n};\n\nEventEmitter.prototype.removeAllListeners = function(type) {\n  var key, listeners;\n\n  if (!this._events)\n    return this;\n\n  // not listening for removeListener, no need to emit\n  if (!this._events.removeListener) {\n    if (arguments.length === 0)\n      this._events = {};\n    else if (this._events[type])\n      delete this._events[type];\n    return this;\n  }\n\n  // emit removeListener for all listeners on all events\n  if (arguments.length === 0) {\n    for (key in this._events) {\n      if (key === 'removeListener') continue;\n      this.removeAllListeners(key);\n    }\n    this.removeAllListeners('removeListener');\n    this._events = {};\n    return this;\n  }\n\n  listeners = this._events[type];\n\n  if (isFunction(listeners)) {\n    this.removeListener(type, listeners);\n  } else if (listeners) {\n    // LIFO order\n    while (listeners.length)\n      this.removeListener(type, listeners[listeners.length - 1]);\n  }\n  delete this._events[type];\n\n  return this;\n};\n\nEventEmitter.prototype.listeners = function(type) {\n  var ret;\n  if (!this._events || !this._events[type])\n    ret = [];\n  else if (isFunction(this._events[type]))\n    ret = [this._events[type]];\n  else\n    ret = this._events[type].slice();\n  return ret;\n};\n\nEventEmitter.prototype.listenerCount = function(type) {\n  if (this._events) {\n    var evlistener = this._events[type];\n\n    if (isFunction(evlistener))\n      return 1;\n    else if (evlistener)\n      return evlistener.length;\n  }\n  return 0;\n};\n\nEventEmitter.listenerCount = function(emitter, type) {\n  return emitter.listenerCount(type);\n};\n\nfunction isFunction(arg) {\n  return typeof arg === 'function';\n}\n\nfunction isNumber(arg) {\n  return typeof arg === 'number';\n}\n\nfunction isObject(arg) {\n  return typeof arg === 'object' && arg !== null;\n}\n\nfunction isUndefined(arg) {\n  return arg === void 0;\n}\n\n\n\n// WEBPACK FOOTER //\n// ./node_modules/events/events.js","exports = module.exports = require('./lib/_stream_readable.js');\nexports.Stream = exports;\nexports.Readable = exports;\nexports.Writable = require('./lib/_stream_writable.js');\nexports.Duplex = require('./lib/_stream_duplex.js');\nexports.Transform = require('./lib/_stream_transform.js');\nexports.PassThrough = require('./lib/_stream_passthrough.js');\n\n\n\n// WEBPACK FOOTER //\n// ./node_modules/readable-stream/readable-browser.js","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// A bit simpler than readable streams.\n// Implement an async ._write(chunk, encoding, cb), and it'll handle all\n// the drain event emission and buffering.\n\n'use strict';\n\n/*<replacement>*/\n\nvar processNextTick = require('process-nextick-args');\n/*</replacement>*/\n\nmodule.exports = Writable;\n\n/* <replacement> */\nfunction WriteReq(chunk, encoding, cb) {\n  this.chunk = chunk;\n  this.encoding = encoding;\n  this.callback = cb;\n  this.next = null;\n}\n\n// It seems a linked list but it is not\n// there will be only 2 of these for each stream\nfunction CorkedRequest(state) {\n  var _this = this;\n\n  this.next = null;\n  this.entry = null;\n  this.finish = function () {\n    onCorkedFinish(_this, state);\n  };\n}\n/* </replacement> */\n\n/*<replacement>*/\nvar asyncWrite = !process.browser && ['v0.10', 'v0.9.'].indexOf(process.version.slice(0, 5)) > -1 ? setImmediate : processNextTick;\n/*</replacement>*/\n\n/*<replacement>*/\nvar Duplex;\n/*</replacement>*/\n\nWritable.WritableState = WritableState;\n\n/*<replacement>*/\nvar util = require('core-util-is');\nutil.inherits = require('inherits');\n/*</replacement>*/\n\n/*<replacement>*/\nvar internalUtil = {\n  deprecate: require('util-deprecate')\n};\n/*</replacement>*/\n\n/*<replacement>*/\nvar Stream = require('./internal/streams/stream');\n/*</replacement>*/\n\n/*<replacement>*/\nvar Buffer = require('safe-buffer').Buffer;\nvar OurUint8Array = global.Uint8Array || function () {};\nfunction _uint8ArrayToBuffer(chunk) {\n  return Buffer.from(chunk);\n}\nfunction _isUint8Array(obj) {\n  return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;\n}\n/*</replacement>*/\n\nvar destroyImpl = require('./internal/streams/destroy');\n\nutil.inherits(Writable, Stream);\n\nfunction nop() {}\n\nfunction WritableState(options, stream) {\n  Duplex = Duplex || require('./_stream_duplex');\n\n  options = options || {};\n\n  // object stream flag to indicate whether or not this stream\n  // contains buffers or objects.\n  this.objectMode = !!options.objectMode;\n\n  if (stream instanceof Duplex) this.objectMode = this.objectMode || !!options.writableObjectMode;\n\n  // the point at which write() starts returning false\n  // Note: 0 is a valid value, means that we always return false if\n  // the entire buffer is not flushed immediately on write()\n  var hwm = options.highWaterMark;\n  var defaultHwm = this.objectMode ? 16 : 16 * 1024;\n  this.highWaterMark = hwm || hwm === 0 ? hwm : defaultHwm;\n\n  // cast to ints.\n  this.highWaterMark = Math.floor(this.highWaterMark);\n\n  // if _final has been called\n  this.finalCalled = false;\n\n  // drain event flag.\n  this.needDrain = false;\n  // at the start of calling end()\n  this.ending = false;\n  // when end() has been called, and returned\n  this.ended = false;\n  // when 'finish' is emitted\n  this.finished = false;\n\n  // has it been destroyed\n  this.destroyed = false;\n\n  // should we decode strings into buffers before passing to _write?\n  // this is here so that some node-core streams can optimize string\n  // handling at a lower level.\n  var noDecode = options.decodeStrings === false;\n  this.decodeStrings = !noDecode;\n\n  // Crypto is kind of old and crusty.  Historically, its default string\n  // encoding is 'binary' so we have to make this configurable.\n  // Everything else in the universe uses 'utf8', though.\n  this.defaultEncoding = options.defaultEncoding || 'utf8';\n\n  // not an actual buffer we keep track of, but a measurement\n  // of how much we're waiting to get pushed to some underlying\n  // socket or file.\n  this.length = 0;\n\n  // a flag to see when we're in the middle of a write.\n  this.writing = false;\n\n  // when true all writes will be buffered until .uncork() call\n  this.corked = 0;\n\n  // a flag to be able to tell if the onwrite cb is called immediately,\n  // or on a later tick.  We set this to true at first, because any\n  // actions that shouldn't happen until \"later\" should generally also\n  // not happen before the first write call.\n  this.sync = true;\n\n  // a flag to know if we're processing previously buffered items, which\n  // may call the _write() callback in the same tick, so that we don't\n  // end up in an overlapped onwrite situation.\n  this.bufferProcessing = false;\n\n  // the callback that's passed to _write(chunk,cb)\n  this.onwrite = function (er) {\n    onwrite(stream, er);\n  };\n\n  // the callback that the user supplies to write(chunk,encoding,cb)\n  this.writecb = null;\n\n  // the amount that is being written when _write is called.\n  this.writelen = 0;\n\n  this.bufferedRequest = null;\n  this.lastBufferedRequest = null;\n\n  // number of pending user-supplied write callbacks\n  // this must be 0 before 'finish' can be emitted\n  this.pendingcb = 0;\n\n  // emit prefinish if the only thing we're waiting for is _write cbs\n  // This is relevant for synchronous Transform streams\n  this.prefinished = false;\n\n  // True if the error was already emitted and should not be thrown again\n  this.errorEmitted = false;\n\n  // count buffered requests\n  this.bufferedRequestCount = 0;\n\n  // allocate the first CorkedRequest, there is always\n  // one allocated and free to use, and we maintain at most two\n  this.corkedRequestsFree = new CorkedRequest(this);\n}\n\nWritableState.prototype.getBuffer = function getBuffer() {\n  var current = this.bufferedRequest;\n  var out = [];\n  while (current) {\n    out.push(current);\n    current = current.next;\n  }\n  return out;\n};\n\n(function () {\n  try {\n    Object.defineProperty(WritableState.prototype, 'buffer', {\n      get: internalUtil.deprecate(function () {\n        return this.getBuffer();\n      }, '_writableState.buffer is deprecated. Use _writableState.getBuffer ' + 'instead.', 'DEP0003')\n    });\n  } catch (_) {}\n})();\n\n// Test _writableState for inheritance to account for Duplex streams,\n// whose prototype chain only points to Readable.\nvar realHasInstance;\nif (typeof Symbol === 'function' && Symbol.hasInstance && typeof Function.prototype[Symbol.hasInstance] === 'function') {\n  realHasInstance = Function.prototype[Symbol.hasInstance];\n  Object.defineProperty(Writable, Symbol.hasInstance, {\n    value: function (object) {\n      if (realHasInstance.call(this, object)) return true;\n\n      return object && object._writableState instanceof WritableState;\n    }\n  });\n} else {\n  realHasInstance = function (object) {\n    return object instanceof this;\n  };\n}\n\nfunction Writable(options) {\n  Duplex = Duplex || require('./_stream_duplex');\n\n  // Writable ctor is applied to Duplexes, too.\n  // `realHasInstance` is necessary because using plain `instanceof`\n  // would return false, as no `_writableState` property is attached.\n\n  // Trying to use the custom `instanceof` for Writable here will also break the\n  // Node.js LazyTransform implementation, which has a non-trivial getter for\n  // `_writableState` that would lead to infinite recursion.\n  if (!realHasInstance.call(Writable, this) && !(this instanceof Duplex)) {\n    return new Writable(options);\n  }\n\n  this._writableState = new WritableState(options, this);\n\n  // legacy.\n  this.writable = true;\n\n  if (options) {\n    if (typeof options.write === 'function') this._write = options.write;\n\n    if (typeof options.writev === 'function') this._writev = options.writev;\n\n    if (typeof options.destroy === 'function') this._destroy = options.destroy;\n\n    if (typeof options.final === 'function') this._final = options.final;\n  }\n\n  Stream.call(this);\n}\n\n// Otherwise people can pipe Writable streams, which is just wrong.\nWritable.prototype.pipe = function () {\n  this.emit('error', new Error('Cannot pipe, not readable'));\n};\n\nfunction writeAfterEnd(stream, cb) {\n  var er = new Error('write after end');\n  // TODO: defer error events consistently everywhere, not just the cb\n  stream.emit('error', er);\n  processNextTick(cb, er);\n}\n\n// Checks that a user-supplied chunk is valid, especially for the particular\n// mode the stream is in. Currently this means that `null` is never accepted\n// and undefined/non-string values are only allowed in object mode.\nfunction validChunk(stream, state, chunk, cb) {\n  var valid = true;\n  var er = false;\n\n  if (chunk === null) {\n    er = new TypeError('May not write null values to stream');\n  } else if (typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) {\n    er = new TypeError('Invalid non-string/buffer chunk');\n  }\n  if (er) {\n    stream.emit('error', er);\n    processNextTick(cb, er);\n    valid = false;\n  }\n  return valid;\n}\n\nWritable.prototype.write = function (chunk, encoding, cb) {\n  var state = this._writableState;\n  var ret = false;\n  var isBuf = _isUint8Array(chunk) && !state.objectMode;\n\n  if (isBuf && !Buffer.isBuffer(chunk)) {\n    chunk = _uint8ArrayToBuffer(chunk);\n  }\n\n  if (typeof encoding === 'function') {\n    cb = encoding;\n    encoding = null;\n  }\n\n  if (isBuf) encoding = 'buffer';else if (!encoding) encoding = state.defaultEncoding;\n\n  if (typeof cb !== 'function') cb = nop;\n\n  if (state.ended) writeAfterEnd(this, cb);else if (isBuf || validChunk(this, state, chunk, cb)) {\n    state.pendingcb++;\n    ret = writeOrBuffer(this, state, isBuf, chunk, encoding, cb);\n  }\n\n  return ret;\n};\n\nWritable.prototype.cork = function () {\n  var state = this._writableState;\n\n  state.corked++;\n};\n\nWritable.prototype.uncork = function () {\n  var state = this._writableState;\n\n  if (state.corked) {\n    state.corked--;\n\n    if (!state.writing && !state.corked && !state.finished && !state.bufferProcessing && state.bufferedRequest) clearBuffer(this, state);\n  }\n};\n\nWritable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) {\n  // node::ParseEncoding() requires lower case.\n  if (typeof encoding === 'string') encoding = encoding.toLowerCase();\n  if (!(['hex', 'utf8', 'utf-8', 'ascii', 'binary', 'base64', 'ucs2', 'ucs-2', 'utf16le', 'utf-16le', 'raw'].indexOf((encoding + '').toLowerCase()) > -1)) throw new TypeError('Unknown encoding: ' + encoding);\n  this._writableState.defaultEncoding = encoding;\n  return this;\n};\n\nfunction decodeChunk(state, chunk, encoding) {\n  if (!state.objectMode && state.decodeStrings !== false && typeof chunk === 'string') {\n    chunk = Buffer.from(chunk, encoding);\n  }\n  return chunk;\n}\n\n// if we're already writing something, then just put this\n// in the queue, and wait our turn.  Otherwise, call _write\n// If we return false, then we need a drain event, so set that flag.\nfunction writeOrBuffer(stream, state, isBuf, chunk, encoding, cb) {\n  if (!isBuf) {\n    var newChunk = decodeChunk(state, chunk, encoding);\n    if (chunk !== newChunk) {\n      isBuf = true;\n      encoding = 'buffer';\n      chunk = newChunk;\n    }\n  }\n  var len = state.objectMode ? 1 : chunk.length;\n\n  state.length += len;\n\n  var ret = state.length < state.highWaterMark;\n  // we must ensure that previous needDrain will not be reset to false.\n  if (!ret) state.needDrain = true;\n\n  if (state.writing || state.corked) {\n    var last = state.lastBufferedRequest;\n    state.lastBufferedRequest = {\n      chunk: chunk,\n      encoding: encoding,\n      isBuf: isBuf,\n      callback: cb,\n      next: null\n    };\n    if (last) {\n      last.next = state.lastBufferedRequest;\n    } else {\n      state.bufferedRequest = state.lastBufferedRequest;\n    }\n    state.bufferedRequestCount += 1;\n  } else {\n    doWrite(stream, state, false, len, chunk, encoding, cb);\n  }\n\n  return ret;\n}\n\nfunction doWrite(stream, state, writev, len, chunk, encoding, cb) {\n  state.writelen = len;\n  state.writecb = cb;\n  state.writing = true;\n  state.sync = true;\n  if (writev) stream._writev(chunk, state.onwrite);else stream._write(chunk, encoding, state.onwrite);\n  state.sync = false;\n}\n\nfunction onwriteError(stream, state, sync, er, cb) {\n  --state.pendingcb;\n\n  if (sync) {\n    // defer the callback if we are being called synchronously\n    // to avoid piling up things on the stack\n    processNextTick(cb, er);\n    // this can emit finish, and it will always happen\n    // after error\n    processNextTick(finishMaybe, stream, state);\n    stream._writableState.errorEmitted = true;\n    stream.emit('error', er);\n  } else {\n    // the caller expect this to happen before if\n    // it is async\n    cb(er);\n    stream._writableState.errorEmitted = true;\n    stream.emit('error', er);\n    // this can emit finish, but finish must\n    // always follow error\n    finishMaybe(stream, state);\n  }\n}\n\nfunction onwriteStateUpdate(state) {\n  state.writing = false;\n  state.writecb = null;\n  state.length -= state.writelen;\n  state.writelen = 0;\n}\n\nfunction onwrite(stream, er) {\n  var state = stream._writableState;\n  var sync = state.sync;\n  var cb = state.writecb;\n\n  onwriteStateUpdate(state);\n\n  if (er) onwriteError(stream, state, sync, er, cb);else {\n    // Check if we're actually ready to finish, but don't emit yet\n    var finished = needFinish(state);\n\n    if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) {\n      clearBuffer(stream, state);\n    }\n\n    if (sync) {\n      /*<replacement>*/\n      asyncWrite(afterWrite, stream, state, finished, cb);\n      /*</replacement>*/\n    } else {\n      afterWrite(stream, state, finished, cb);\n    }\n  }\n}\n\nfunction afterWrite(stream, state, finished, cb) {\n  if (!finished) onwriteDrain(stream, state);\n  state.pendingcb--;\n  cb();\n  finishMaybe(stream, state);\n}\n\n// Must force callback to be called on nextTick, so that we don't\n// emit 'drain' before the write() consumer gets the 'false' return\n// value, and has a chance to attach a 'drain' listener.\nfunction onwriteDrain(stream, state) {\n  if (state.length === 0 && state.needDrain) {\n    state.needDrain = false;\n    stream.emit('drain');\n  }\n}\n\n// if there's something in the buffer waiting, then process it\nfunction clearBuffer(stream, state) {\n  state.bufferProcessing = true;\n  var entry = state.bufferedRequest;\n\n  if (stream._writev && entry && entry.next) {\n    // Fast case, write everything using _writev()\n    var l = state.bufferedRequestCount;\n    var buffer = new Array(l);\n    var holder = state.corkedRequestsFree;\n    holder.entry = entry;\n\n    var count = 0;\n    var allBuffers = true;\n    while (entry) {\n      buffer[count] = entry;\n      if (!entry.isBuf) allBuffers = false;\n      entry = entry.next;\n      count += 1;\n    }\n    buffer.allBuffers = allBuffers;\n\n    doWrite(stream, state, true, state.length, buffer, '', holder.finish);\n\n    // doWrite is almost always async, defer these to save a bit of time\n    // as the hot path ends with doWrite\n    state.pendingcb++;\n    state.lastBufferedRequest = null;\n    if (holder.next) {\n      state.corkedRequestsFree = holder.next;\n      holder.next = null;\n    } else {\n      state.corkedRequestsFree = new CorkedRequest(state);\n    }\n  } else {\n    // Slow case, write chunks one-by-one\n    while (entry) {\n      var chunk = entry.chunk;\n      var encoding = entry.encoding;\n      var cb = entry.callback;\n      var len = state.objectMode ? 1 : chunk.length;\n\n      doWrite(stream, state, false, len, chunk, encoding, cb);\n      entry = entry.next;\n      // if we didn't call the onwrite immediately, then\n      // it means that we need to wait until it does.\n      // also, that means that the chunk and cb are currently\n      // being processed, so move the buffer counter past them.\n      if (state.writing) {\n        break;\n      }\n    }\n\n    if (entry === null) state.lastBufferedRequest = null;\n  }\n\n  state.bufferedRequestCount = 0;\n  state.bufferedRequest = entry;\n  state.bufferProcessing = false;\n}\n\nWritable.prototype._write = function (chunk, encoding, cb) {\n  cb(new Error('_write() is not implemented'));\n};\n\nWritable.prototype._writev = null;\n\nWritable.prototype.end = function (chunk, encoding, cb) {\n  var state = this._writableState;\n\n  if (typeof chunk === 'function') {\n    cb = chunk;\n    chunk = null;\n    encoding = null;\n  } else if (typeof encoding === 'function') {\n    cb = encoding;\n    encoding = null;\n  }\n\n  if (chunk !== null && chunk !== undefined) this.write(chunk, encoding);\n\n  // .end() fully uncorks\n  if (state.corked) {\n    state.corked = 1;\n    this.uncork();\n  }\n\n  // ignore unnecessary end() calls.\n  if (!state.ending && !state.finished) endWritable(this, state, cb);\n};\n\nfunction needFinish(state) {\n  return state.ending && state.length === 0 && state.bufferedRequest === null && !state.finished && !state.writing;\n}\nfunction callFinal(stream, state) {\n  stream._final(function (err) {\n    state.pendingcb--;\n    if (err) {\n      stream.emit('error', err);\n    }\n    state.prefinished = true;\n    stream.emit('prefinish');\n    finishMaybe(stream, state);\n  });\n}\nfunction prefinish(stream, state) {\n  if (!state.prefinished && !state.finalCalled) {\n    if (typeof stream._final === 'function') {\n      state.pendingcb++;\n      state.finalCalled = true;\n      processNextTick(callFinal, stream, state);\n    } else {\n      state.prefinished = true;\n      stream.emit('prefinish');\n    }\n  }\n}\n\nfunction finishMaybe(stream, state) {\n  var need = needFinish(state);\n  if (need) {\n    prefinish(stream, state);\n    if (state.pendingcb === 0) {\n      state.finished = true;\n      stream.emit('finish');\n    }\n  }\n  return need;\n}\n\nfunction endWritable(stream, state, cb) {\n  state.ending = true;\n  finishMaybe(stream, state);\n  if (cb) {\n    if (state.finished) processNextTick(cb);else stream.once('finish', cb);\n  }\n  state.ended = true;\n  stream.writable = false;\n}\n\nfunction onCorkedFinish(corkReq, state, err) {\n  var entry = corkReq.entry;\n  corkReq.entry = null;\n  while (entry) {\n    var cb = entry.callback;\n    state.pendingcb--;\n    cb(err);\n    entry = entry.next;\n  }\n  if (state.corkedRequestsFree) {\n    state.corkedRequestsFree.next = corkReq;\n  } else {\n    state.corkedRequestsFree = corkReq;\n  }\n}\n\nObject.defineProperty(Writable.prototype, 'destroyed', {\n  get: function () {\n    if (this._writableState === undefined) {\n      return false;\n    }\n    return this._writableState.destroyed;\n  },\n  set: function (value) {\n    // we ignore the value if the stream\n    // has not been initialized yet\n    if (!this._writableState) {\n      return;\n    }\n\n    // backward compatibility, the user is explicitly\n    // managing destroyed\n    this._writableState.destroyed = value;\n  }\n});\n\nWritable.prototype.destroy = destroyImpl.destroy;\nWritable.prototype._undestroy = destroyImpl.undestroy;\nWritable.prototype._destroy = function (err, cb) {\n  this.end();\n  cb(err);\n};\n\n\n// WEBPACK FOOTER //\n// ./node_modules/readable-stream/lib/_stream_writable.js","var toString = {}.toString;\n\nmodule.exports = Array.isArray || function (arr) {\n  return toString.call(arr) == '[object Array]';\n};\n\n\n\n// WEBPACK FOOTER //\n// ./node_modules/isarray/index.js","'use strict';\n\nvar utils = exports;\n\nfunction toArray(msg, enc) {\n  if (Array.isArray(msg))\n    return msg.slice();\n  if (!msg)\n    return [];\n  var res = [];\n  if (typeof msg !== 'string') {\n    for (var i = 0; i < msg.length; i++)\n      res[i] = msg[i] | 0;\n    return res;\n  }\n  if (enc === 'hex') {\n    msg = msg.replace(/[^a-z0-9]+/ig, '');\n    if (msg.length % 2 !== 0)\n      msg = '0' + msg;\n    for (var i = 0; i < msg.length; i += 2)\n      res.push(parseInt(msg[i] + msg[i + 1], 16));\n  } else {\n    for (var i = 0; i < msg.length; i++) {\n      var c = msg.charCodeAt(i);\n      var hi = c >> 8;\n      var lo = c & 0xff;\n      if (hi)\n        res.push(hi, lo);\n      else\n        res.push(lo);\n    }\n  }\n  return res;\n}\nutils.toArray = toArray;\n\nfunction zero2(word) {\n  if (word.length === 1)\n    return '0' + word;\n  else\n    return word;\n}\nutils.zero2 = zero2;\n\nfunction toHex(msg) {\n  var res = '';\n  for (var i = 0; i < msg.length; i++)\n    res += zero2(msg[i].toString(16));\n  return res;\n}\nutils.toHex = toHex;\n\nutils.encode = function encode(arr, enc) {\n  if (enc === 'hex')\n    return toHex(arr);\n  else\n    return arr;\n};\n\n\n\n// WEBPACK FOOTER //\n// ./node_modules/minimalistic-crypto-utils/lib/utils.js","'use strict';\n\nvar utils = require('../utils');\nvar rotr32 = utils.rotr32;\n\nfunction ft_1(s, x, y, z) {\n  if (s === 0)\n    return ch32(x, y, z);\n  if (s === 1 || s === 3)\n    return p32(x, y, z);\n  if (s === 2)\n    return maj32(x, y, z);\n}\nexports.ft_1 = ft_1;\n\nfunction ch32(x, y, z) {\n  return (x & y) ^ ((~x) & z);\n}\nexports.ch32 = ch32;\n\nfunction maj32(x, y, z) {\n  return (x & y) ^ (x & z) ^ (y & z);\n}\nexports.maj32 = maj32;\n\nfunction p32(x, y, z) {\n  return x ^ y ^ z;\n}\nexports.p32 = p32;\n\nfunction s0_256(x) {\n  return rotr32(x, 2) ^ rotr32(x, 13) ^ rotr32(x, 22);\n}\nexports.s0_256 = s0_256;\n\nfunction s1_256(x) {\n  return rotr32(x, 6) ^ rotr32(x, 11) ^ rotr32(x, 25);\n}\nexports.s1_256 = s1_256;\n\nfunction g0_256(x) {\n  return rotr32(x, 7) ^ rotr32(x, 18) ^ (x >>> 3);\n}\nexports.g0_256 = g0_256;\n\nfunction g1_256(x) {\n  return rotr32(x, 17) ^ rotr32(x, 19) ^ (x >>> 10);\n}\nexports.g1_256 = g1_256;\n\n\n\n// WEBPACK FOOTER //\n// ./node_modules/hash.js/lib/hash/sha/common.js","'use strict';\n\nvar utils = require('../utils');\nvar common = require('../common');\nvar shaCommon = require('./common');\nvar assert = require('minimalistic-assert');\n\nvar sum32 = utils.sum32;\nvar sum32_4 = utils.sum32_4;\nvar sum32_5 = utils.sum32_5;\nvar ch32 = shaCommon.ch32;\nvar maj32 = shaCommon.maj32;\nvar s0_256 = shaCommon.s0_256;\nvar s1_256 = shaCommon.s1_256;\nvar g0_256 = shaCommon.g0_256;\nvar g1_256 = shaCommon.g1_256;\n\nvar BlockHash = common.BlockHash;\n\nvar sha256_K = [\n  0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5,\n  0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,\n  0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,\n  0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,\n  0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc,\n  0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,\n  0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7,\n  0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,\n  0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,\n  0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,\n  0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3,\n  0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,\n  0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5,\n  0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,\n  0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,\n  0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2\n];\n\nfunction SHA256() {\n  if (!(this instanceof SHA256))\n    return new SHA256();\n\n  BlockHash.call(this);\n  this.h = [\n    0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a,\n    0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19\n  ];\n  this.k = sha256_K;\n  this.W = new Array(64);\n}\nutils.inherits(SHA256, BlockHash);\nmodule.exports = SHA256;\n\nSHA256.blockSize = 512;\nSHA256.outSize = 256;\nSHA256.hmacStrength = 192;\nSHA256.padLength = 64;\n\nSHA256.prototype._update = function _update(msg, start) {\n  var W = this.W;\n\n  for (var i = 0; i < 16; i++)\n    W[i] = msg[start + i];\n  for (; i < W.length; i++)\n    W[i] = sum32_4(g1_256(W[i - 2]), W[i - 7], g0_256(W[i - 15]), W[i - 16]);\n\n  var a = this.h[0];\n  var b = this.h[1];\n  var c = this.h[2];\n  var d = this.h[3];\n  var e = this.h[4];\n  var f = this.h[5];\n  var g = this.h[6];\n  var h = this.h[7];\n\n  assert(this.k.length === W.length);\n  for (i = 0; i < W.length; i++) {\n    var T1 = sum32_5(h, s1_256(e), ch32(e, f, g), this.k[i], W[i]);\n    var T2 = sum32(s0_256(a), maj32(a, b, c));\n    h = g;\n    g = f;\n    f = e;\n    e = sum32(d, T1);\n    d = c;\n    c = b;\n    b = a;\n    a = sum32(T1, T2);\n  }\n\n  this.h[0] = sum32(this.h[0], a);\n  this.h[1] = sum32(this.h[1], b);\n  this.h[2] = sum32(this.h[2], c);\n  this.h[3] = sum32(this.h[3], d);\n  this.h[4] = sum32(this.h[4], e);\n  this.h[5] = sum32(this.h[5], f);\n  this.h[6] = sum32(this.h[6], g);\n  this.h[7] = sum32(this.h[7], h);\n};\n\nSHA256.prototype._digest = function digest(enc) {\n  if (enc === 'hex')\n    return utils.toHex32(this.h, 'big');\n  else\n    return utils.split32(this.h, 'big');\n};\n\n\n\n// WEBPACK FOOTER //\n// ./node_modules/hash.js/lib/hash/sha/256.js","'use strict';\n\nvar utils = require('../utils');\nvar common = require('../common');\nvar assert = require('minimalistic-assert');\n\nvar rotr64_hi = utils.rotr64_hi;\nvar rotr64_lo = utils.rotr64_lo;\nvar shr64_hi = utils.shr64_hi;\nvar shr64_lo = utils.shr64_lo;\nvar sum64 = utils.sum64;\nvar sum64_hi = utils.sum64_hi;\nvar sum64_lo = utils.sum64_lo;\nvar sum64_4_hi = utils.sum64_4_hi;\nvar sum64_4_lo = utils.sum64_4_lo;\nvar sum64_5_hi = utils.sum64_5_hi;\nvar sum64_5_lo = utils.sum64_5_lo;\n\nvar BlockHash = common.BlockHash;\n\nvar sha512_K = [\n  0x428a2f98, 0xd728ae22, 0x71374491, 0x23ef65cd,\n  0xb5c0fbcf, 0xec4d3b2f, 0xe9b5dba5, 0x8189dbbc,\n  0x3956c25b, 0xf348b538, 0x59f111f1, 0xb605d019,\n  0x923f82a4, 0xaf194f9b, 0xab1c5ed5, 0xda6d8118,\n  0xd807aa98, 0xa3030242, 0x12835b01, 0x45706fbe,\n  0x243185be, 0x4ee4b28c, 0x550c7dc3, 0xd5ffb4e2,\n  0x72be5d74, 0xf27b896f, 0x80deb1fe, 0x3b1696b1,\n  0x9bdc06a7, 0x25c71235, 0xc19bf174, 0xcf692694,\n  0xe49b69c1, 0x9ef14ad2, 0xefbe4786, 0x384f25e3,\n  0x0fc19dc6, 0x8b8cd5b5, 0x240ca1cc, 0x77ac9c65,\n  0x2de92c6f, 0x592b0275, 0x4a7484aa, 0x6ea6e483,\n  0x5cb0a9dc, 0xbd41fbd4, 0x76f988da, 0x831153b5,\n  0x983e5152, 0xee66dfab, 0xa831c66d, 0x2db43210,\n  0xb00327c8, 0x98fb213f, 0xbf597fc7, 0xbeef0ee4,\n  0xc6e00bf3, 0x3da88fc2, 0xd5a79147, 0x930aa725,\n  0x06ca6351, 0xe003826f, 0x14292967, 0x0a0e6e70,\n  0x27b70a85, 0x46d22ffc, 0x2e1b2138, 0x5c26c926,\n  0x4d2c6dfc, 0x5ac42aed, 0x53380d13, 0x9d95b3df,\n  0x650a7354, 0x8baf63de, 0x766a0abb, 0x3c77b2a8,\n  0x81c2c92e, 0x47edaee6, 0x92722c85, 0x1482353b,\n  0xa2bfe8a1, 0x4cf10364, 0xa81a664b, 0xbc423001,\n  0xc24b8b70, 0xd0f89791, 0xc76c51a3, 0x0654be30,\n  0xd192e819, 0xd6ef5218, 0xd6990624, 0x5565a910,\n  0xf40e3585, 0x5771202a, 0x106aa070, 0x32bbd1b8,\n  0x19a4c116, 0xb8d2d0c8, 0x1e376c08, 0x5141ab53,\n  0x2748774c, 0xdf8eeb99, 0x34b0bcb5, 0xe19b48a8,\n  0x391c0cb3, 0xc5c95a63, 0x4ed8aa4a, 0xe3418acb,\n  0x5b9cca4f, 0x7763e373, 0x682e6ff3, 0xd6b2b8a3,\n  0x748f82ee, 0x5defb2fc, 0x78a5636f, 0x43172f60,\n  0x84c87814, 0xa1f0ab72, 0x8cc70208, 0x1a6439ec,\n  0x90befffa, 0x23631e28, 0xa4506ceb, 0xde82bde9,\n  0xbef9a3f7, 0xb2c67915, 0xc67178f2, 0xe372532b,\n  0xca273ece, 0xea26619c, 0xd186b8c7, 0x21c0c207,\n  0xeada7dd6, 0xcde0eb1e, 0xf57d4f7f, 0xee6ed178,\n  0x06f067aa, 0x72176fba, 0x0a637dc5, 0xa2c898a6,\n  0x113f9804, 0xbef90dae, 0x1b710b35, 0x131c471b,\n  0x28db77f5, 0x23047d84, 0x32caab7b, 0x40c72493,\n  0x3c9ebe0a, 0x15c9bebc, 0x431d67c4, 0x9c100d4c,\n  0x4cc5d4be, 0xcb3e42b6, 0x597f299c, 0xfc657e2a,\n  0x5fcb6fab, 0x3ad6faec, 0x6c44198c, 0x4a475817\n];\n\nfunction SHA512() {\n  if (!(this instanceof SHA512))\n    return new SHA512();\n\n  BlockHash.call(this);\n  this.h = [\n    0x6a09e667, 0xf3bcc908,\n    0xbb67ae85, 0x84caa73b,\n    0x3c6ef372, 0xfe94f82b,\n    0xa54ff53a, 0x5f1d36f1,\n    0x510e527f, 0xade682d1,\n    0x9b05688c, 0x2b3e6c1f,\n    0x1f83d9ab, 0xfb41bd6b,\n    0x5be0cd19, 0x137e2179 ];\n  this.k = sha512_K;\n  this.W = new Array(160);\n}\nutils.inherits(SHA512, BlockHash);\nmodule.exports = SHA512;\n\nSHA512.blockSize = 1024;\nSHA512.outSize = 512;\nSHA512.hmacStrength = 192;\nSHA512.padLength = 128;\n\nSHA512.prototype._prepareBlock = function _prepareBlock(msg, start) {\n  var W = this.W;\n\n  // 32 x 32bit words\n  for (var i = 0; i < 32; i++)\n    W[i] = msg[start + i];\n  for (; i < W.length; i += 2) {\n    var c0_hi = g1_512_hi(W[i - 4], W[i - 3]);  // i - 2\n    var c0_lo = g1_512_lo(W[i - 4], W[i - 3]);\n    var c1_hi = W[i - 14];  // i - 7\n    var c1_lo = W[i - 13];\n    var c2_hi = g0_512_hi(W[i - 30], W[i - 29]);  // i - 15\n    var c2_lo = g0_512_lo(W[i - 30], W[i - 29]);\n    var c3_hi = W[i - 32];  // i - 16\n    var c3_lo = W[i - 31];\n\n    W[i] = sum64_4_hi(\n      c0_hi, c0_lo,\n      c1_hi, c1_lo,\n      c2_hi, c2_lo,\n      c3_hi, c3_lo);\n    W[i + 1] = sum64_4_lo(\n      c0_hi, c0_lo,\n      c1_hi, c1_lo,\n      c2_hi, c2_lo,\n      c3_hi, c3_lo);\n  }\n};\n\nSHA512.prototype._update = function _update(msg, start) {\n  this._prepareBlock(msg, start);\n\n  var W = this.W;\n\n  var ah = this.h[0];\n  var al = this.h[1];\n  var bh = this.h[2];\n  var bl = this.h[3];\n  var ch = this.h[4];\n  var cl = this.h[5];\n  var dh = this.h[6];\n  var dl = this.h[7];\n  var eh = this.h[8];\n  var el = this.h[9];\n  var fh = this.h[10];\n  var fl = this.h[11];\n  var gh = this.h[12];\n  var gl = this.h[13];\n  var hh = this.h[14];\n  var hl = this.h[15];\n\n  assert(this.k.length === W.length);\n  for (var i = 0; i < W.length; i += 2) {\n    var c0_hi = hh;\n    var c0_lo = hl;\n    var c1_hi = s1_512_hi(eh, el);\n    var c1_lo = s1_512_lo(eh, el);\n    var c2_hi = ch64_hi(eh, el, fh, fl, gh, gl);\n    var c2_lo = ch64_lo(eh, el, fh, fl, gh, gl);\n    var c3_hi = this.k[i];\n    var c3_lo = this.k[i + 1];\n    var c4_hi = W[i];\n    var c4_lo = W[i + 1];\n\n    var T1_hi = sum64_5_hi(\n      c0_hi, c0_lo,\n      c1_hi, c1_lo,\n      c2_hi, c2_lo,\n      c3_hi, c3_lo,\n      c4_hi, c4_lo);\n    var T1_lo = sum64_5_lo(\n      c0_hi, c0_lo,\n      c1_hi, c1_lo,\n      c2_hi, c2_lo,\n      c3_hi, c3_lo,\n      c4_hi, c4_lo);\n\n    c0_hi = s0_512_hi(ah, al);\n    c0_lo = s0_512_lo(ah, al);\n    c1_hi = maj64_hi(ah, al, bh, bl, ch, cl);\n    c1_lo = maj64_lo(ah, al, bh, bl, ch, cl);\n\n    var T2_hi = sum64_hi(c0_hi, c0_lo, c1_hi, c1_lo);\n    var T2_lo = sum64_lo(c0_hi, c0_lo, c1_hi, c1_lo);\n\n    hh = gh;\n    hl = gl;\n\n    gh = fh;\n    gl = fl;\n\n    fh = eh;\n    fl = el;\n\n    eh = sum64_hi(dh, dl, T1_hi, T1_lo);\n    el = sum64_lo(dl, dl, T1_hi, T1_lo);\n\n    dh = ch;\n    dl = cl;\n\n    ch = bh;\n    cl = bl;\n\n    bh = ah;\n    bl = al;\n\n    ah = sum64_hi(T1_hi, T1_lo, T2_hi, T2_lo);\n    al = sum64_lo(T1_hi, T1_lo, T2_hi, T2_lo);\n  }\n\n  sum64(this.h, 0, ah, al);\n  sum64(this.h, 2, bh, bl);\n  sum64(this.h, 4, ch, cl);\n  sum64(this.h, 6, dh, dl);\n  sum64(this.h, 8, eh, el);\n  sum64(this.h, 10, fh, fl);\n  sum64(this.h, 12, gh, gl);\n  sum64(this.h, 14, hh, hl);\n};\n\nSHA512.prototype._digest = function digest(enc) {\n  if (enc === 'hex')\n    return utils.toHex32(this.h, 'big');\n  else\n    return utils.split32(this.h, 'big');\n};\n\nfunction ch64_hi(xh, xl, yh, yl, zh) {\n  var r = (xh & yh) ^ ((~xh) & zh);\n  if (r < 0)\n    r += 0x100000000;\n  return r;\n}\n\nfunction ch64_lo(xh, xl, yh, yl, zh, zl) {\n  var r = (xl & yl) ^ ((~xl) & zl);\n  if (r < 0)\n    r += 0x100000000;\n  return r;\n}\n\nfunction maj64_hi(xh, xl, yh, yl, zh) {\n  var r = (xh & yh) ^ (xh & zh) ^ (yh & zh);\n  if (r < 0)\n    r += 0x100000000;\n  return r;\n}\n\nfunction maj64_lo(xh, xl, yh, yl, zh, zl) {\n  var r = (xl & yl) ^ (xl & zl) ^ (yl & zl);\n  if (r < 0)\n    r += 0x100000000;\n  return r;\n}\n\nfunction s0_512_hi(xh, xl) {\n  var c0_hi = rotr64_hi(xh, xl, 28);\n  var c1_hi = rotr64_hi(xl, xh, 2);  // 34\n  var c2_hi = rotr64_hi(xl, xh, 7);  // 39\n\n  var r = c0_hi ^ c1_hi ^ c2_hi;\n  if (r < 0)\n    r += 0x100000000;\n  return r;\n}\n\nfunction s0_512_lo(xh, xl) {\n  var c0_lo = rotr64_lo(xh, xl, 28);\n  var c1_lo = rotr64_lo(xl, xh, 2);  // 34\n  var c2_lo = rotr64_lo(xl, xh, 7);  // 39\n\n  var r = c0_lo ^ c1_lo ^ c2_lo;\n  if (r < 0)\n    r += 0x100000000;\n  return r;\n}\n\nfunction s1_512_hi(xh, xl) {\n  var c0_hi = rotr64_hi(xh, xl, 14);\n  var c1_hi = rotr64_hi(xh, xl, 18);\n  var c2_hi = rotr64_hi(xl, xh, 9);  // 41\n\n  var r = c0_hi ^ c1_hi ^ c2_hi;\n  if (r < 0)\n    r += 0x100000000;\n  return r;\n}\n\nfunction s1_512_lo(xh, xl) {\n  var c0_lo = rotr64_lo(xh, xl, 14);\n  var c1_lo = rotr64_lo(xh, xl, 18);\n  var c2_lo = rotr64_lo(xl, xh, 9);  // 41\n\n  var r = c0_lo ^ c1_lo ^ c2_lo;\n  if (r < 0)\n    r += 0x100000000;\n  return r;\n}\n\nfunction g0_512_hi(xh, xl) {\n  var c0_hi = rotr64_hi(xh, xl, 1);\n  var c1_hi = rotr64_hi(xh, xl, 8);\n  var c2_hi = shr64_hi(xh, xl, 7);\n\n  var r = c0_hi ^ c1_hi ^ c2_hi;\n  if (r < 0)\n    r += 0x100000000;\n  return r;\n}\n\nfunction g0_512_lo(xh, xl) {\n  var c0_lo = rotr64_lo(xh, xl, 1);\n  var c1_lo = rotr64_lo(xh, xl, 8);\n  var c2_lo = shr64_lo(xh, xl, 7);\n\n  var r = c0_lo ^ c1_lo ^ c2_lo;\n  if (r < 0)\n    r += 0x100000000;\n  return r;\n}\n\nfunction g1_512_hi(xh, xl) {\n  var c0_hi = rotr64_hi(xh, xl, 19);\n  var c1_hi = rotr64_hi(xl, xh, 29);  // 61\n  var c2_hi = shr64_hi(xh, xl, 6);\n\n  var r = c0_hi ^ c1_hi ^ c2_hi;\n  if (r < 0)\n    r += 0x100000000;\n  return r;\n}\n\nfunction g1_512_lo(xh, xl) {\n  var c0_lo = rotr64_lo(xh, xl, 19);\n  var c1_lo = rotr64_lo(xl, xh, 29);  // 61\n  var c2_lo = shr64_lo(xh, xl, 6);\n\n  var r = c0_lo ^ c1_lo ^ c2_lo;\n  if (r < 0)\n    r += 0x100000000;\n  return r;\n}\n\n\n\n// WEBPACK FOOTER //\n// ./node_modules/hash.js/lib/hash/sha/512.js","'use strict';\n\n// compare and isBuffer taken from https://github.com/feross/buffer/blob/680e9e5e488f22aac27599a57dc844a6315928dd/index.js\n// original notice:\n\n/*!\n * The buffer module from node.js, for the browser.\n *\n * @author   Feross Aboukhadijeh <feross@feross.org> <http://feross.org>\n * @license  MIT\n */\nfunction compare(a, b) {\n  if (a === b) {\n    return 0;\n  }\n\n  var x = a.length;\n  var y = b.length;\n\n  for (var i = 0, len = Math.min(x, y); i < len; ++i) {\n    if (a[i] !== b[i]) {\n      x = a[i];\n      y = b[i];\n      break;\n    }\n  }\n\n  if (x < y) {\n    return -1;\n  }\n  if (y < x) {\n    return 1;\n  }\n  return 0;\n}\nfunction isBuffer(b) {\n  if (global.Buffer && typeof global.Buffer.isBuffer === 'function') {\n    return global.Buffer.isBuffer(b);\n  }\n  return !!(b != null && b._isBuffer);\n}\n\n// based on node assert, original notice:\n\n// http://wiki.commonjs.org/wiki/Unit_Testing/1.0\n//\n// THIS IS NOT TESTED NOR LIKELY TO WORK OUTSIDE V8!\n//\n// Originally from narwhal.js (http://narwhaljs.org)\n// Copyright (c) 2009 Thomas Robinson <280north.com>\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the 'Software'), to\n// deal in the Software without restriction, including without limitation the\n// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or\n// sell copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN\n// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION\n// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nvar util = require('util/');\nvar hasOwn = Object.prototype.hasOwnProperty;\nvar pSlice = Array.prototype.slice;\nvar functionsHaveNames = (function () {\n  return function foo() {}.name === 'foo';\n}());\nfunction pToString (obj) {\n  return Object.prototype.toString.call(obj);\n}\nfunction isView(arrbuf) {\n  if (isBuffer(arrbuf)) {\n    return false;\n  }\n  if (typeof global.ArrayBuffer !== 'function') {\n    return false;\n  }\n  if (typeof ArrayBuffer.isView === 'function') {\n    return ArrayBuffer.isView(arrbuf);\n  }\n  if (!arrbuf) {\n    return false;\n  }\n  if (arrbuf instanceof DataView) {\n    return true;\n  }\n  if (arrbuf.buffer && arrbuf.buffer instanceof ArrayBuffer) {\n    return true;\n  }\n  return false;\n}\n// 1. The assert module provides functions that throw\n// AssertionError's when particular conditions are not met. The\n// assert module must conform to the following interface.\n\nvar assert = module.exports = ok;\n\n// 2. The AssertionError is defined in assert.\n// new assert.AssertionError({ message: message,\n//                             actual: actual,\n//                             expected: expected })\n\nvar regex = /\\s*function\\s+([^\\(\\s]*)\\s*/;\n// based on https://github.com/ljharb/function.prototype.name/blob/adeeeec8bfcc6068b187d7d9fb3d5bb1d3a30899/implementation.js\nfunction getName(func) {\n  if (!util.isFunction(func)) {\n    return;\n  }\n  if (functionsHaveNames) {\n    return func.name;\n  }\n  var str = func.toString();\n  var match = str.match(regex);\n  return match && match[1];\n}\nassert.AssertionError = function AssertionError(options) {\n  this.name = 'AssertionError';\n  this.actual = options.actual;\n  this.expected = options.expected;\n  this.operator = options.operator;\n  if (options.message) {\n    this.message = options.message;\n    this.generatedMessage = false;\n  } else {\n    this.message = getMessage(this);\n    this.generatedMessage = true;\n  }\n  var stackStartFunction = options.stackStartFunction || fail;\n  if (Error.captureStackTrace) {\n    Error.captureStackTrace(this, stackStartFunction);\n  } else {\n    // non v8 browsers so we can have a stacktrace\n    var err = new Error();\n    if (err.stack) {\n      var out = err.stack;\n\n      // try to strip useless frames\n      var fn_name = getName(stackStartFunction);\n      var idx = out.indexOf('\\n' + fn_name);\n      if (idx >= 0) {\n        // once we have located the function frame\n        // we need to strip out everything before it (and its line)\n        var next_line = out.indexOf('\\n', idx + 1);\n        out = out.substring(next_line + 1);\n      }\n\n      this.stack = out;\n    }\n  }\n};\n\n// assert.AssertionError instanceof Error\nutil.inherits(assert.AssertionError, Error);\n\nfunction truncate(s, n) {\n  if (typeof s === 'string') {\n    return s.length < n ? s : s.slice(0, n);\n  } else {\n    return s;\n  }\n}\nfunction inspect(something) {\n  if (functionsHaveNames || !util.isFunction(something)) {\n    return util.inspect(something);\n  }\n  var rawname = getName(something);\n  var name = rawname ? ': ' + rawname : '';\n  return '[Function' +  name + ']';\n}\nfunction getMessage(self) {\n  return truncate(inspect(self.actual), 128) + ' ' +\n         self.operator + ' ' +\n         truncate(inspect(self.expected), 128);\n}\n\n// At present only the three keys mentioned above are used and\n// understood by the spec. Implementations or sub modules can pass\n// other keys to the AssertionError's constructor - they will be\n// ignored.\n\n// 3. All of the following functions must throw an AssertionError\n// when a corresponding condition is not met, with a message that\n// may be undefined if not provided.  All assertion methods provide\n// both the actual and expected values to the assertion error for\n// display purposes.\n\nfunction fail(actual, expected, message, operator, stackStartFunction) {\n  throw new assert.AssertionError({\n    message: message,\n    actual: actual,\n    expected: expected,\n    operator: operator,\n    stackStartFunction: stackStartFunction\n  });\n}\n\n// EXTENSION! allows for well behaved errors defined elsewhere.\nassert.fail = fail;\n\n// 4. Pure assertion tests whether a value is truthy, as determined\n// by !!guard.\n// assert.ok(guard, message_opt);\n// This statement is equivalent to assert.equal(true, !!guard,\n// message_opt);. To test strictly for the value true, use\n// assert.strictEqual(true, guard, message_opt);.\n\nfunction ok(value, message) {\n  if (!value) fail(value, true, message, '==', assert.ok);\n}\nassert.ok = ok;\n\n// 5. The equality assertion tests shallow, coercive equality with\n// ==.\n// assert.equal(actual, expected, message_opt);\n\nassert.equal = function equal(actual, expected, message) {\n  if (actual != expected) fail(actual, expected, message, '==', assert.equal);\n};\n\n// 6. The non-equality assertion tests for whether two objects are not equal\n// with != assert.notEqual(actual, expected, message_opt);\n\nassert.notEqual = function notEqual(actual, expected, message) {\n  if (actual == expected) {\n    fail(actual, expected, message, '!=', assert.notEqual);\n  }\n};\n\n// 7. The equivalence assertion tests a deep equality relation.\n// assert.deepEqual(actual, expected, message_opt);\n\nassert.deepEqual = function deepEqual(actual, expected, message) {\n  if (!_deepEqual(actual, expected, false)) {\n    fail(actual, expected, message, 'deepEqual', assert.deepEqual);\n  }\n};\n\nassert.deepStrictEqual = function deepStrictEqual(actual, expected, message) {\n  if (!_deepEqual(actual, expected, true)) {\n    fail(actual, expected, message, 'deepStrictEqual', assert.deepStrictEqual);\n  }\n};\n\nfunction _deepEqual(actual, expected, strict, memos) {\n  // 7.1. All identical values are equivalent, as determined by ===.\n  if (actual === expected) {\n    return true;\n  } else if (isBuffer(actual) && isBuffer(expected)) {\n    return compare(actual, expected) === 0;\n\n  // 7.2. If the expected value is a Date object, the actual value is\n  // equivalent if it is also a Date object that refers to the same time.\n  } else if (util.isDate(actual) && util.isDate(expected)) {\n    return actual.getTime() === expected.getTime();\n\n  // 7.3 If the expected value is a RegExp object, the actual value is\n  // equivalent if it is also a RegExp object with the same source and\n  // properties (`global`, `multiline`, `lastIndex`, `ignoreCase`).\n  } else if (util.isRegExp(actual) && util.isRegExp(expected)) {\n    return actual.source === expected.source &&\n           actual.global === expected.global &&\n           actual.multiline === expected.multiline &&\n           actual.lastIndex === expected.lastIndex &&\n           actual.ignoreCase === expected.ignoreCase;\n\n  // 7.4. Other pairs that do not both pass typeof value == 'object',\n  // equivalence is determined by ==.\n  } else if ((actual === null || typeof actual !== 'object') &&\n             (expected === null || typeof expected !== 'object')) {\n    return strict ? actual === expected : actual == expected;\n\n  // If both values are instances of typed arrays, wrap their underlying\n  // ArrayBuffers in a Buffer each to increase performance\n  // This optimization requires the arrays to have the same type as checked by\n  // Object.prototype.toString (aka pToString). Never perform binary\n  // comparisons for Float*Arrays, though, since e.g. +0 === -0 but their\n  // bit patterns are not identical.\n  } else if (isView(actual) && isView(expected) &&\n             pToString(actual) === pToString(expected) &&\n             !(actual instanceof Float32Array ||\n               actual instanceof Float64Array)) {\n    return compare(new Uint8Array(actual.buffer),\n                   new Uint8Array(expected.buffer)) === 0;\n\n  // 7.5 For all other Object pairs, including Array objects, equivalence is\n  // determined by having the same number of owned properties (as verified\n  // with Object.prototype.hasOwnProperty.call), the same set of keys\n  // (although not necessarily the same order), equivalent values for every\n  // corresponding key, and an identical 'prototype' property. Note: this\n  // accounts for both named and indexed properties on Arrays.\n  } else if (isBuffer(actual) !== isBuffer(expected)) {\n    return false;\n  } else {\n    memos = memos || {actual: [], expected: []};\n\n    var actualIndex = memos.actual.indexOf(actual);\n    if (actualIndex !== -1) {\n      if (actualIndex === memos.expected.indexOf(expected)) {\n        return true;\n      }\n    }\n\n    memos.actual.push(actual);\n    memos.expected.push(expected);\n\n    return objEquiv(actual, expected, strict, memos);\n  }\n}\n\nfunction isArguments(object) {\n  return Object.prototype.toString.call(object) == '[object Arguments]';\n}\n\nfunction objEquiv(a, b, strict, actualVisitedObjects) {\n  if (a === null || a === undefined || b === null || b === undefined)\n    return false;\n  // if one is a primitive, the other must be same\n  if (util.isPrimitive(a) || util.isPrimitive(b))\n    return a === b;\n  if (strict && Object.getPrototypeOf(a) !== Object.getPrototypeOf(b))\n    return false;\n  var aIsArgs = isArguments(a);\n  var bIsArgs = isArguments(b);\n  if ((aIsArgs && !bIsArgs) || (!aIsArgs && bIsArgs))\n    return false;\n  if (aIsArgs) {\n    a = pSlice.call(a);\n    b = pSlice.call(b);\n    return _deepEqual(a, b, strict);\n  }\n  var ka = objectKeys(a);\n  var kb = objectKeys(b);\n  var key, i;\n  // having the same number of owned properties (keys incorporates\n  // hasOwnProperty)\n  if (ka.length !== kb.length)\n    return false;\n  //the same set of keys (although not necessarily the same order),\n  ka.sort();\n  kb.sort();\n  //~~~cheap key test\n  for (i = ka.length - 1; i >= 0; i--) {\n    if (ka[i] !== kb[i])\n      return false;\n  }\n  //equivalent values for every corresponding key, and\n  //~~~possibly expensive deep test\n  for (i = ka.length - 1; i >= 0; i--) {\n    key = ka[i];\n    if (!_deepEqual(a[key], b[key], strict, actualVisitedObjects))\n      return false;\n  }\n  return true;\n}\n\n// 8. The non-equivalence assertion tests for any deep inequality.\n// assert.notDeepEqual(actual, expected, message_opt);\n\nassert.notDeepEqual = function notDeepEqual(actual, expected, message) {\n  if (_deepEqual(actual, expected, false)) {\n    fail(actual, expected, message, 'notDeepEqual', assert.notDeepEqual);\n  }\n};\n\nassert.notDeepStrictEqual = notDeepStrictEqual;\nfunction notDeepStrictEqual(actual, expected, message) {\n  if (_deepEqual(actual, expected, true)) {\n    fail(actual, expected, message, 'notDeepStrictEqual', notDeepStrictEqual);\n  }\n}\n\n\n// 9. The strict equality assertion tests strict equality, as determined by ===.\n// assert.strictEqual(actual, expected, message_opt);\n\nassert.strictEqual = function strictEqual(actual, expected, message) {\n  if (actual !== expected) {\n    fail(actual, expected, message, '===', assert.strictEqual);\n  }\n};\n\n// 10. The strict non-equality assertion tests for strict inequality, as\n// determined by !==.  assert.notStrictEqual(actual, expected, message_opt);\n\nassert.notStrictEqual = function notStrictEqual(actual, expected, message) {\n  if (actual === expected) {\n    fail(actual, expected, message, '!==', assert.notStrictEqual);\n  }\n};\n\nfunction expectedException(actual, expected) {\n  if (!actual || !expected) {\n    return false;\n  }\n\n  if (Object.prototype.toString.call(expected) == '[object RegExp]') {\n    return expected.test(actual);\n  }\n\n  try {\n    if (actual instanceof expected) {\n      return true;\n    }\n  } catch (e) {\n    // Ignore.  The instanceof check doesn't work for arrow functions.\n  }\n\n  if (Error.isPrototypeOf(expected)) {\n    return false;\n  }\n\n  return expected.call({}, actual) === true;\n}\n\nfunction _tryBlock(block) {\n  var error;\n  try {\n    block();\n  } catch (e) {\n    error = e;\n  }\n  return error;\n}\n\nfunction _throws(shouldThrow, block, expected, message) {\n  var actual;\n\n  if (typeof block !== 'function') {\n    throw new TypeError('\"block\" argument must be a function');\n  }\n\n  if (typeof expected === 'string') {\n    message = expected;\n    expected = null;\n  }\n\n  actual = _tryBlock(block);\n\n  message = (expected && expected.name ? ' (' + expected.name + ').' : '.') +\n            (message ? ' ' + message : '.');\n\n  if (shouldThrow && !actual) {\n    fail(actual, expected, 'Missing expected exception' + message);\n  }\n\n  var userProvidedMessage = typeof message === 'string';\n  var isUnwantedException = !shouldThrow && util.isError(actual);\n  var isUnexpectedException = !shouldThrow && actual && !expected;\n\n  if ((isUnwantedException &&\n      userProvidedMessage &&\n      expectedException(actual, expected)) ||\n      isUnexpectedException) {\n    fail(actual, expected, 'Got unwanted exception' + message);\n  }\n\n  if ((shouldThrow && actual && expected &&\n      !expectedException(actual, expected)) || (!shouldThrow && actual)) {\n    throw actual;\n  }\n}\n\n// 11. Expected to throw an error:\n// assert.throws(block, Error_opt, message_opt);\n\nassert.throws = function(block, /*optional*/error, /*optional*/message) {\n  _throws(true, block, error, message);\n};\n\n// EXTENSION! This is annoying to write outside this module.\nassert.doesNotThrow = function(block, /*optional*/error, /*optional*/message) {\n  _throws(false, block, error, message);\n};\n\nassert.ifError = function(err) { if (err) throw err; };\n\nvar objectKeys = Object.keys || function (obj) {\n  var keys = [];\n  for (var key in obj) {\n    if (hasOwn.call(obj, key)) keys.push(key);\n  }\n  return keys;\n};\n\n\n\n// WEBPACK FOOTER //\n// ./node_modules/assert/assert.js","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nmodule.exports = Stream;\n\nvar EE = require('events').EventEmitter;\nvar inherits = require('inherits');\n\ninherits(Stream, EE);\nStream.Readable = require('readable-stream/readable.js');\nStream.Writable = require('readable-stream/writable.js');\nStream.Duplex = require('readable-stream/duplex.js');\nStream.Transform = require('readable-stream/transform.js');\nStream.PassThrough = require('readable-stream/passthrough.js');\n\n// Backwards-compat with node 0.4.x\nStream.Stream = Stream;\n\n\n\n// old-style streams.  Note that the pipe method (the only relevant\n// part of this class) is overridden in the Readable class.\n\nfunction Stream() {\n  EE.call(this);\n}\n\nStream.prototype.pipe = function(dest, options) {\n  var source = this;\n\n  function ondata(chunk) {\n    if (dest.writable) {\n      if (false === dest.write(chunk) && source.pause) {\n        source.pause();\n      }\n    }\n  }\n\n  source.on('data', ondata);\n\n  function ondrain() {\n    if (source.readable && source.resume) {\n      source.resume();\n    }\n  }\n\n  dest.on('drain', ondrain);\n\n  // If the 'end' option is not supplied, dest.end() will be called when\n  // source gets the 'end' or 'close' events.  Only dest.end() once.\n  if (!dest._isStdio && (!options || options.end !== false)) {\n    source.on('end', onend);\n    source.on('close', onclose);\n  }\n\n  var didOnEnd = false;\n  function onend() {\n    if (didOnEnd) return;\n    didOnEnd = true;\n\n    dest.end();\n  }\n\n\n  function onclose() {\n    if (didOnEnd) return;\n    didOnEnd = true;\n\n    if (typeof dest.destroy === 'function') dest.destroy();\n  }\n\n  // don't leave dangling pipes when there are errors.\n  function onerror(er) {\n    cleanup();\n    if (EE.listenerCount(this, 'error') === 0) {\n      throw er; // Unhandled stream error in pipe.\n    }\n  }\n\n  source.on('error', onerror);\n  dest.on('error', onerror);\n\n  // remove all the event listeners that were added.\n  function cleanup() {\n    source.removeListener('data', ondata);\n    dest.removeListener('drain', ondrain);\n\n    source.removeListener('end', onend);\n    source.removeListener('close', onclose);\n\n    source.removeListener('error', onerror);\n    dest.removeListener('error', onerror);\n\n    source.removeListener('end', cleanup);\n    source.removeListener('close', cleanup);\n\n    dest.removeListener('close', cleanup);\n  }\n\n  source.on('end', cleanup);\n  source.on('close', cleanup);\n\n  dest.on('close', cleanup);\n\n  dest.emit('pipe', source);\n\n  // Allow for unix-like usage: A.pipe(B).pipe(C)\n  return dest;\n};\n\n\n\n// WEBPACK FOOTER //\n// ./node_modules/stream-browserify/index.js","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n'use strict';\n\n/*<replacement>*/\n\nvar processNextTick = require('process-nextick-args');\n/*</replacement>*/\n\nmodule.exports = Readable;\n\n/*<replacement>*/\nvar isArray = require('isarray');\n/*</replacement>*/\n\n/*<replacement>*/\nvar Duplex;\n/*</replacement>*/\n\nReadable.ReadableState = ReadableState;\n\n/*<replacement>*/\nvar EE = require('events').EventEmitter;\n\nvar EElistenerCount = function (emitter, type) {\n  return emitter.listeners(type).length;\n};\n/*</replacement>*/\n\n/*<replacement>*/\nvar Stream = require('./internal/streams/stream');\n/*</replacement>*/\n\n// TODO(bmeurer): Change this back to const once hole checks are\n// properly optimized away early in Ignition+TurboFan.\n/*<replacement>*/\nvar Buffer = require('safe-buffer').Buffer;\nvar OurUint8Array = global.Uint8Array || function () {};\nfunction _uint8ArrayToBuffer(chunk) {\n  return Buffer.from(chunk);\n}\nfunction _isUint8Array(obj) {\n  return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;\n}\n/*</replacement>*/\n\n/*<replacement>*/\nvar util = require('core-util-is');\nutil.inherits = require('inherits');\n/*</replacement>*/\n\n/*<replacement>*/\nvar debugUtil = require('util');\nvar debug = void 0;\nif (debugUtil && debugUtil.debuglog) {\n  debug = debugUtil.debuglog('stream');\n} else {\n  debug = function () {};\n}\n/*</replacement>*/\n\nvar BufferList = require('./internal/streams/BufferList');\nvar destroyImpl = require('./internal/streams/destroy');\nvar StringDecoder;\n\nutil.inherits(Readable, Stream);\n\nvar kProxyEvents = ['error', 'close', 'destroy', 'pause', 'resume'];\n\nfunction prependListener(emitter, event, fn) {\n  // Sadly this is not cacheable as some libraries bundle their own\n  // event emitter implementation with them.\n  if (typeof emitter.prependListener === 'function') {\n    return emitter.prependListener(event, fn);\n  } else {\n    // This is a hack to make sure that our error handler is attached before any\n    // userland ones.  NEVER DO THIS. This is here only because this code needs\n    // to continue to work with older versions of Node.js that do not include\n    // the prependListener() method. The goal is to eventually remove this hack.\n    if (!emitter._events || !emitter._events[event]) emitter.on(event, fn);else if (isArray(emitter._events[event])) emitter._events[event].unshift(fn);else emitter._events[event] = [fn, emitter._events[event]];\n  }\n}\n\nfunction ReadableState(options, stream) {\n  Duplex = Duplex || require('./_stream_duplex');\n\n  options = options || {};\n\n  // object stream flag. Used to make read(n) ignore n and to\n  // make all the buffer merging and length checks go away\n  this.objectMode = !!options.objectMode;\n\n  if (stream instanceof Duplex) this.objectMode = this.objectMode || !!options.readableObjectMode;\n\n  // the point at which it stops calling _read() to fill the buffer\n  // Note: 0 is a valid value, means \"don't call _read preemptively ever\"\n  var hwm = options.highWaterMark;\n  var defaultHwm = this.objectMode ? 16 : 16 * 1024;\n  this.highWaterMark = hwm || hwm === 0 ? hwm : defaultHwm;\n\n  // cast to ints.\n  this.highWaterMark = Math.floor(this.highWaterMark);\n\n  // A linked list is used to store data chunks instead of an array because the\n  // linked list can remove elements from the beginning faster than\n  // array.shift()\n  this.buffer = new BufferList();\n  this.length = 0;\n  this.pipes = null;\n  this.pipesCount = 0;\n  this.flowing = null;\n  this.ended = false;\n  this.endEmitted = false;\n  this.reading = false;\n\n  // a flag to be able to tell if the event 'readable'/'data' is emitted\n  // immediately, or on a later tick.  We set this to true at first, because\n  // any actions that shouldn't happen until \"later\" should generally also\n  // not happen before the first read call.\n  this.sync = true;\n\n  // whenever we return null, then we set a flag to say\n  // that we're awaiting a 'readable' event emission.\n  this.needReadable = false;\n  this.emittedReadable = false;\n  this.readableListening = false;\n  this.resumeScheduled = false;\n\n  // has it been destroyed\n  this.destroyed = false;\n\n  // Crypto is kind of old and crusty.  Historically, its default string\n  // encoding is 'binary' so we have to make this configurable.\n  // Everything else in the universe uses 'utf8', though.\n  this.defaultEncoding = options.defaultEncoding || 'utf8';\n\n  // the number of writers that are awaiting a drain event in .pipe()s\n  this.awaitDrain = 0;\n\n  // if true, a maybeReadMore has been scheduled\n  this.readingMore = false;\n\n  this.decoder = null;\n  this.encoding = null;\n  if (options.encoding) {\n    if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder;\n    this.decoder = new StringDecoder(options.encoding);\n    this.encoding = options.encoding;\n  }\n}\n\nfunction Readable(options) {\n  Duplex = Duplex || require('./_stream_duplex');\n\n  if (!(this instanceof Readable)) return new Readable(options);\n\n  this._readableState = new ReadableState(options, this);\n\n  // legacy\n  this.readable = true;\n\n  if (options) {\n    if (typeof options.read === 'function') this._read = options.read;\n\n    if (typeof options.destroy === 'function') this._destroy = options.destroy;\n  }\n\n  Stream.call(this);\n}\n\nObject.defineProperty(Readable.prototype, 'destroyed', {\n  get: function () {\n    if (this._readableState === undefined) {\n      return false;\n    }\n    return this._readableState.destroyed;\n  },\n  set: function (value) {\n    // we ignore the value if the stream\n    // has not been initialized yet\n    if (!this._readableState) {\n      return;\n    }\n\n    // backward compatibility, the user is explicitly\n    // managing destroyed\n    this._readableState.destroyed = value;\n  }\n});\n\nReadable.prototype.destroy = destroyImpl.destroy;\nReadable.prototype._undestroy = destroyImpl.undestroy;\nReadable.prototype._destroy = function (err, cb) {\n  this.push(null);\n  cb(err);\n};\n\n// Manually shove something into the read() buffer.\n// This returns true if the highWaterMark has not been hit yet,\n// similar to how Writable.write() returns true if you should\n// write() some more.\nReadable.prototype.push = function (chunk, encoding) {\n  var state = this._readableState;\n  var skipChunkCheck;\n\n  if (!state.objectMode) {\n    if (typeof chunk === 'string') {\n      encoding = encoding || state.defaultEncoding;\n      if (encoding !== state.encoding) {\n        chunk = Buffer.from(chunk, encoding);\n        encoding = '';\n      }\n      skipChunkCheck = true;\n    }\n  } else {\n    skipChunkCheck = true;\n  }\n\n  return readableAddChunk(this, chunk, encoding, false, skipChunkCheck);\n};\n\n// Unshift should *always* be something directly out of read()\nReadable.prototype.unshift = function (chunk) {\n  return readableAddChunk(this, chunk, null, true, false);\n};\n\nfunction readableAddChunk(stream, chunk, encoding, addToFront, skipChunkCheck) {\n  var state = stream._readableState;\n  if (chunk === null) {\n    state.reading = false;\n    onEofChunk(stream, state);\n  } else {\n    var er;\n    if (!skipChunkCheck) er = chunkInvalid(state, chunk);\n    if (er) {\n      stream.emit('error', er);\n    } else if (state.objectMode || chunk && chunk.length > 0) {\n      if (typeof chunk !== 'string' && !state.objectMode && Object.getPrototypeOf(chunk) !== Buffer.prototype) {\n        chunk = _uint8ArrayToBuffer(chunk);\n      }\n\n      if (addToFront) {\n        if (state.endEmitted) stream.emit('error', new Error('stream.unshift() after end event'));else addChunk(stream, state, chunk, true);\n      } else if (state.ended) {\n        stream.emit('error', new Error('stream.push() after EOF'));\n      } else {\n        state.reading = false;\n        if (state.decoder && !encoding) {\n          chunk = state.decoder.write(chunk);\n          if (state.objectMode || chunk.length !== 0) addChunk(stream, state, chunk, false);else maybeReadMore(stream, state);\n        } else {\n          addChunk(stream, state, chunk, false);\n        }\n      }\n    } else if (!addToFront) {\n      state.reading = false;\n    }\n  }\n\n  return needMoreData(state);\n}\n\nfunction addChunk(stream, state, chunk, addToFront) {\n  if (state.flowing && state.length === 0 && !state.sync) {\n    stream.emit('data', chunk);\n    stream.read(0);\n  } else {\n    // update the buffer info.\n    state.length += state.objectMode ? 1 : chunk.length;\n    if (addToFront) state.buffer.unshift(chunk);else state.buffer.push(chunk);\n\n    if (state.needReadable) emitReadable(stream);\n  }\n  maybeReadMore(stream, state);\n}\n\nfunction chunkInvalid(state, chunk) {\n  var er;\n  if (!_isUint8Array(chunk) && typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) {\n    er = new TypeError('Invalid non-string/buffer chunk');\n  }\n  return er;\n}\n\n// if it's past the high water mark, we can push in some more.\n// Also, if we have no data yet, we can stand some\n// more bytes.  This is to work around cases where hwm=0,\n// such as the repl.  Also, if the push() triggered a\n// readable event, and the user called read(largeNumber) such that\n// needReadable was set, then we ought to push more, so that another\n// 'readable' event will be triggered.\nfunction needMoreData(state) {\n  return !state.ended && (state.needReadable || state.length < state.highWaterMark || state.length === 0);\n}\n\nReadable.prototype.isPaused = function () {\n  return this._readableState.flowing === false;\n};\n\n// backwards compatibility.\nReadable.prototype.setEncoding = function (enc) {\n  if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder;\n  this._readableState.decoder = new StringDecoder(enc);\n  this._readableState.encoding = enc;\n  return this;\n};\n\n// Don't raise the hwm > 8MB\nvar MAX_HWM = 0x800000;\nfunction computeNewHighWaterMark(n) {\n  if (n >= MAX_HWM) {\n    n = MAX_HWM;\n  } else {\n    // Get the next highest power of 2 to prevent increasing hwm excessively in\n    // tiny amounts\n    n--;\n    n |= n >>> 1;\n    n |= n >>> 2;\n    n |= n >>> 4;\n    n |= n >>> 8;\n    n |= n >>> 16;\n    n++;\n  }\n  return n;\n}\n\n// This function is designed to be inlinable, so please take care when making\n// changes to the function body.\nfunction howMuchToRead(n, state) {\n  if (n <= 0 || state.length === 0 && state.ended) return 0;\n  if (state.objectMode) return 1;\n  if (n !== n) {\n    // Only flow one buffer at a time\n    if (state.flowing && state.length) return state.buffer.head.data.length;else return state.length;\n  }\n  // If we're asking for more than the current hwm, then raise the hwm.\n  if (n > state.highWaterMark) state.highWaterMark = computeNewHighWaterMark(n);\n  if (n <= state.length) return n;\n  // Don't have enough\n  if (!state.ended) {\n    state.needReadable = true;\n    return 0;\n  }\n  return state.length;\n}\n\n// you can override either this method, or the async _read(n) below.\nReadable.prototype.read = function (n) {\n  debug('read', n);\n  n = parseInt(n, 10);\n  var state = this._readableState;\n  var nOrig = n;\n\n  if (n !== 0) state.emittedReadable = false;\n\n  // if we're doing read(0) to trigger a readable event, but we\n  // already have a bunch of data in the buffer, then just trigger\n  // the 'readable' event and move on.\n  if (n === 0 && state.needReadable && (state.length >= state.highWaterMark || state.ended)) {\n    debug('read: emitReadable', state.length, state.ended);\n    if (state.length === 0 && state.ended) endReadable(this);else emitReadable(this);\n    return null;\n  }\n\n  n = howMuchToRead(n, state);\n\n  // if we've ended, and we're now clear, then finish it up.\n  if (n === 0 && state.ended) {\n    if (state.length === 0) endReadable(this);\n    return null;\n  }\n\n  // All the actual chunk generation logic needs to be\n  // *below* the call to _read.  The reason is that in certain\n  // synthetic stream cases, such as passthrough streams, _read\n  // may be a completely synchronous operation which may change\n  // the state of the read buffer, providing enough data when\n  // before there was *not* enough.\n  //\n  // So, the steps are:\n  // 1. Figure out what the state of things will be after we do\n  // a read from the buffer.\n  //\n  // 2. If that resulting state will trigger a _read, then call _read.\n  // Note that this may be asynchronous, or synchronous.  Yes, it is\n  // deeply ugly to write APIs this way, but that still doesn't mean\n  // that the Readable class should behave improperly, as streams are\n  // designed to be sync/async agnostic.\n  // Take note if the _read call is sync or async (ie, if the read call\n  // has returned yet), so that we know whether or not it's safe to emit\n  // 'readable' etc.\n  //\n  // 3. Actually pull the requested chunks out of the buffer and return.\n\n  // if we need a readable event, then we need to do some reading.\n  var doRead = state.needReadable;\n  debug('need readable', doRead);\n\n  // if we currently have less than the highWaterMark, then also read some\n  if (state.length === 0 || state.length - n < state.highWaterMark) {\n    doRead = true;\n    debug('length less than watermark', doRead);\n  }\n\n  // however, if we've ended, then there's no point, and if we're already\n  // reading, then it's unnecessary.\n  if (state.ended || state.reading) {\n    doRead = false;\n    debug('reading or ended', doRead);\n  } else if (doRead) {\n    debug('do read');\n    state.reading = true;\n    state.sync = true;\n    // if the length is currently zero, then we *need* a readable event.\n    if (state.length === 0) state.needReadable = true;\n    // call internal read method\n    this._read(state.highWaterMark);\n    state.sync = false;\n    // If _read pushed data synchronously, then `reading` will be false,\n    // and we need to re-evaluate how much data we can return to the user.\n    if (!state.reading) n = howMuchToRead(nOrig, state);\n  }\n\n  var ret;\n  if (n > 0) ret = fromList(n, state);else ret = null;\n\n  if (ret === null) {\n    state.needReadable = true;\n    n = 0;\n  } else {\n    state.length -= n;\n  }\n\n  if (state.length === 0) {\n    // If we have nothing in the buffer, then we want to know\n    // as soon as we *do* get something into the buffer.\n    if (!state.ended) state.needReadable = true;\n\n    // If we tried to read() past the EOF, then emit end on the next tick.\n    if (nOrig !== n && state.ended) endReadable(this);\n  }\n\n  if (ret !== null) this.emit('data', ret);\n\n  return ret;\n};\n\nfunction onEofChunk(stream, state) {\n  if (state.ended) return;\n  if (state.decoder) {\n    var chunk = state.decoder.end();\n    if (chunk && chunk.length) {\n      state.buffer.push(chunk);\n      state.length += state.objectMode ? 1 : chunk.length;\n    }\n  }\n  state.ended = true;\n\n  // emit 'readable' now to make sure it gets picked up.\n  emitReadable(stream);\n}\n\n// Don't emit readable right away in sync mode, because this can trigger\n// another read() call => stack overflow.  This way, it might trigger\n// a nextTick recursion warning, but that's not so bad.\nfunction emitReadable(stream) {\n  var state = stream._readableState;\n  state.needReadable = false;\n  if (!state.emittedReadable) {\n    debug('emitReadable', state.flowing);\n    state.emittedReadable = true;\n    if (state.sync) processNextTick(emitReadable_, stream);else emitReadable_(stream);\n  }\n}\n\nfunction emitReadable_(stream) {\n  debug('emit readable');\n  stream.emit('readable');\n  flow(stream);\n}\n\n// at this point, the user has presumably seen the 'readable' event,\n// and called read() to consume some data.  that may have triggered\n// in turn another _read(n) call, in which case reading = true if\n// it's in progress.\n// However, if we're not ended, or reading, and the length < hwm,\n// then go ahead and try to read some more preemptively.\nfunction maybeReadMore(stream, state) {\n  if (!state.readingMore) {\n    state.readingMore = true;\n    processNextTick(maybeReadMore_, stream, state);\n  }\n}\n\nfunction maybeReadMore_(stream, state) {\n  var len = state.length;\n  while (!state.reading && !state.flowing && !state.ended && state.length < state.highWaterMark) {\n    debug('maybeReadMore read 0');\n    stream.read(0);\n    if (len === state.length)\n      // didn't get any data, stop spinning.\n      break;else len = state.length;\n  }\n  state.readingMore = false;\n}\n\n// abstract method.  to be overridden in specific implementation classes.\n// call cb(er, data) where data is <= n in length.\n// for virtual (non-string, non-buffer) streams, \"length\" is somewhat\n// arbitrary, and perhaps not very meaningful.\nReadable.prototype._read = function (n) {\n  this.emit('error', new Error('_read() is not implemented'));\n};\n\nReadable.prototype.pipe = function (dest, pipeOpts) {\n  var src = this;\n  var state = this._readableState;\n\n  switch (state.pipesCount) {\n    case 0:\n      state.pipes = dest;\n      break;\n    case 1:\n      state.pipes = [state.pipes, dest];\n      break;\n    default:\n      state.pipes.push(dest);\n      break;\n  }\n  state.pipesCount += 1;\n  debug('pipe count=%d opts=%j', state.pipesCount, pipeOpts);\n\n  var doEnd = (!pipeOpts || pipeOpts.end !== false) && dest !== process.stdout && dest !== process.stderr;\n\n  var endFn = doEnd ? onend : unpipe;\n  if (state.endEmitted) processNextTick(endFn);else src.once('end', endFn);\n\n  dest.on('unpipe', onunpipe);\n  function onunpipe(readable, unpipeInfo) {\n    debug('onunpipe');\n    if (readable === src) {\n      if (unpipeInfo && unpipeInfo.hasUnpiped === false) {\n        unpipeInfo.hasUnpiped = true;\n        cleanup();\n      }\n    }\n  }\n\n  function onend() {\n    debug('onend');\n    dest.end();\n  }\n\n  // when the dest drains, it reduces the awaitDrain counter\n  // on the source.  This would be more elegant with a .once()\n  // handler in flow(), but adding and removing repeatedly is\n  // too slow.\n  var ondrain = pipeOnDrain(src);\n  dest.on('drain', ondrain);\n\n  var cleanedUp = false;\n  function cleanup() {\n    debug('cleanup');\n    // cleanup event handlers once the pipe is broken\n    dest.removeListener('close', onclose);\n    dest.removeListener('finish', onfinish);\n    dest.removeListener('drain', ondrain);\n    dest.removeListener('error', onerror);\n    dest.removeListener('unpipe', onunpipe);\n    src.removeListener('end', onend);\n    src.removeListener('end', unpipe);\n    src.removeListener('data', ondata);\n\n    cleanedUp = true;\n\n    // if the reader is waiting for a drain event from this\n    // specific writer, then it would cause it to never start\n    // flowing again.\n    // So, if this is awaiting a drain, then we just call it now.\n    // If we don't know, then assume that we are waiting for one.\n    if (state.awaitDrain && (!dest._writableState || dest._writableState.needDrain)) ondrain();\n  }\n\n  // If the user pushes more data while we're writing to dest then we'll end up\n  // in ondata again. However, we only want to increase awaitDrain once because\n  // dest will only emit one 'drain' event for the multiple writes.\n  // => Introduce a guard on increasing awaitDrain.\n  var increasedAwaitDrain = false;\n  src.on('data', ondata);\n  function ondata(chunk) {\n    debug('ondata');\n    increasedAwaitDrain = false;\n    var ret = dest.write(chunk);\n    if (false === ret && !increasedAwaitDrain) {\n      // If the user unpiped during `dest.write()`, it is possible\n      // to get stuck in a permanently paused state if that write\n      // also returned false.\n      // => Check whether `dest` is still a piping destination.\n      if ((state.pipesCount === 1 && state.pipes === dest || state.pipesCount > 1 && indexOf(state.pipes, dest) !== -1) && !cleanedUp) {\n        debug('false write response, pause', src._readableState.awaitDrain);\n        src._readableState.awaitDrain++;\n        increasedAwaitDrain = true;\n      }\n      src.pause();\n    }\n  }\n\n  // if the dest has an error, then stop piping into it.\n  // however, don't suppress the throwing behavior for this.\n  function onerror(er) {\n    debug('onerror', er);\n    unpipe();\n    dest.removeListener('error', onerror);\n    if (EElistenerCount(dest, 'error') === 0) dest.emit('error', er);\n  }\n\n  // Make sure our error handler is attached before userland ones.\n  prependListener(dest, 'error', onerror);\n\n  // Both close and finish should trigger unpipe, but only once.\n  function onclose() {\n    dest.removeListener('finish', onfinish);\n    unpipe();\n  }\n  dest.once('close', onclose);\n  function onfinish() {\n    debug('onfinish');\n    dest.removeListener('close', onclose);\n    unpipe();\n  }\n  dest.once('finish', onfinish);\n\n  function unpipe() {\n    debug('unpipe');\n    src.unpipe(dest);\n  }\n\n  // tell the dest that it's being piped to\n  dest.emit('pipe', src);\n\n  // start the flow if it hasn't been started already.\n  if (!state.flowing) {\n    debug('pipe resume');\n    src.resume();\n  }\n\n  return dest;\n};\n\nfunction pipeOnDrain(src) {\n  return function () {\n    var state = src._readableState;\n    debug('pipeOnDrain', state.awaitDrain);\n    if (state.awaitDrain) state.awaitDrain--;\n    if (state.awaitDrain === 0 && EElistenerCount(src, 'data')) {\n      state.flowing = true;\n      flow(src);\n    }\n  };\n}\n\nReadable.prototype.unpipe = function (dest) {\n  var state = this._readableState;\n  var unpipeInfo = { hasUnpiped: false };\n\n  // if we're not piping anywhere, then do nothing.\n  if (state.pipesCount === 0) return this;\n\n  // just one destination.  most common case.\n  if (state.pipesCount === 1) {\n    // passed in one, but it's not the right one.\n    if (dest && dest !== state.pipes) return this;\n\n    if (!dest) dest = state.pipes;\n\n    // got a match.\n    state.pipes = null;\n    state.pipesCount = 0;\n    state.flowing = false;\n    if (dest) dest.emit('unpipe', this, unpipeInfo);\n    return this;\n  }\n\n  // slow case. multiple pipe destinations.\n\n  if (!dest) {\n    // remove all.\n    var dests = state.pipes;\n    var len = state.pipesCount;\n    state.pipes = null;\n    state.pipesCount = 0;\n    state.flowing = false;\n\n    for (var i = 0; i < len; i++) {\n      dests[i].emit('unpipe', this, unpipeInfo);\n    }return this;\n  }\n\n  // try to find the right one.\n  var index = indexOf(state.pipes, dest);\n  if (index === -1) return this;\n\n  state.pipes.splice(index, 1);\n  state.pipesCount -= 1;\n  if (state.pipesCount === 1) state.pipes = state.pipes[0];\n\n  dest.emit('unpipe', this, unpipeInfo);\n\n  return this;\n};\n\n// set up data events if they are asked for\n// Ensure readable listeners eventually get something\nReadable.prototype.on = function (ev, fn) {\n  var res = Stream.prototype.on.call(this, ev, fn);\n\n  if (ev === 'data') {\n    // Start flowing on next tick if stream isn't explicitly paused\n    if (this._readableState.flowing !== false) this.resume();\n  } else if (ev === 'readable') {\n    var state = this._readableState;\n    if (!state.endEmitted && !state.readableListening) {\n      state.readableListening = state.needReadable = true;\n      state.emittedReadable = false;\n      if (!state.reading) {\n        processNextTick(nReadingNextTick, this);\n      } else if (state.length) {\n        emitReadable(this);\n      }\n    }\n  }\n\n  return res;\n};\nReadable.prototype.addListener = Readable.prototype.on;\n\nfunction nReadingNextTick(self) {\n  debug('readable nexttick read 0');\n  self.read(0);\n}\n\n// pause() and resume() are remnants of the legacy readable stream API\n// If the user uses them, then switch into old mode.\nReadable.prototype.resume = function () {\n  var state = this._readableState;\n  if (!state.flowing) {\n    debug('resume');\n    state.flowing = true;\n    resume(this, state);\n  }\n  return this;\n};\n\nfunction resume(stream, state) {\n  if (!state.resumeScheduled) {\n    state.resumeScheduled = true;\n    processNextTick(resume_, stream, state);\n  }\n}\n\nfunction resume_(stream, state) {\n  if (!state.reading) {\n    debug('resume read 0');\n    stream.read(0);\n  }\n\n  state.resumeScheduled = false;\n  state.awaitDrain = 0;\n  stream.emit('resume');\n  flow(stream);\n  if (state.flowing && !state.reading) stream.read(0);\n}\n\nReadable.prototype.pause = function () {\n  debug('call pause flowing=%j', this._readableState.flowing);\n  if (false !== this._readableState.flowing) {\n    debug('pause');\n    this._readableState.flowing = false;\n    this.emit('pause');\n  }\n  return this;\n};\n\nfunction flow(stream) {\n  var state = stream._readableState;\n  debug('flow', state.flowing);\n  while (state.flowing && stream.read() !== null) {}\n}\n\n// wrap an old-style stream as the async data source.\n// This is *not* part of the readable stream interface.\n// It is an ugly unfortunate mess of history.\nReadable.prototype.wrap = function (stream) {\n  var state = this._readableState;\n  var paused = false;\n\n  var self = this;\n  stream.on('end', function () {\n    debug('wrapped end');\n    if (state.decoder && !state.ended) {\n      var chunk = state.decoder.end();\n      if (chunk && chunk.length) self.push(chunk);\n    }\n\n    self.push(null);\n  });\n\n  stream.on('data', function (chunk) {\n    debug('wrapped data');\n    if (state.decoder) chunk = state.decoder.write(chunk);\n\n    // don't skip over falsy values in objectMode\n    if (state.objectMode && (chunk === null || chunk === undefined)) return;else if (!state.objectMode && (!chunk || !chunk.length)) return;\n\n    var ret = self.push(chunk);\n    if (!ret) {\n      paused = true;\n      stream.pause();\n    }\n  });\n\n  // proxy all the other methods.\n  // important when wrapping filters and duplexes.\n  for (var i in stream) {\n    if (this[i] === undefined && typeof stream[i] === 'function') {\n      this[i] = function (method) {\n        return function () {\n          return stream[method].apply(stream, arguments);\n        };\n      }(i);\n    }\n  }\n\n  // proxy certain important events.\n  for (var n = 0; n < kProxyEvents.length; n++) {\n    stream.on(kProxyEvents[n], self.emit.bind(self, kProxyEvents[n]));\n  }\n\n  // when we try to consume some more bytes, simply unpause the\n  // underlying stream.\n  self._read = function (n) {\n    debug('wrapped _read', n);\n    if (paused) {\n      paused = false;\n      stream.resume();\n    }\n  };\n\n  return self;\n};\n\n// exposed for testing purposes only.\nReadable._fromList = fromList;\n\n// Pluck off n bytes from an array of buffers.\n// Length is the combined lengths of all the buffers in the list.\n// This function is designed to be inlinable, so please take care when making\n// changes to the function body.\nfunction fromList(n, state) {\n  // nothing buffered\n  if (state.length === 0) return null;\n\n  var ret;\n  if (state.objectMode) ret = state.buffer.shift();else if (!n || n >= state.length) {\n    // read it all, truncate the list\n    if (state.decoder) ret = state.buffer.join('');else if (state.buffer.length === 1) ret = state.buffer.head.data;else ret = state.buffer.concat(state.length);\n    state.buffer.clear();\n  } else {\n    // read part of list\n    ret = fromListPartial(n, state.buffer, state.decoder);\n  }\n\n  return ret;\n}\n\n// Extracts only enough buffered data to satisfy the amount requested.\n// This function is designed to be inlinable, so please take care when making\n// changes to the function body.\nfunction fromListPartial(n, list, hasStrings) {\n  var ret;\n  if (n < list.head.data.length) {\n    // slice is the same for buffers and strings\n    ret = list.head.data.slice(0, n);\n    list.head.data = list.head.data.slice(n);\n  } else if (n === list.head.data.length) {\n    // first chunk is a perfect match\n    ret = list.shift();\n  } else {\n    // result spans more than one buffer\n    ret = hasStrings ? copyFromBufferString(n, list) : copyFromBuffer(n, list);\n  }\n  return ret;\n}\n\n// Copies a specified amount of characters from the list of buffered data\n// chunks.\n// This function is designed to be inlinable, so please take care when making\n// changes to the function body.\nfunction copyFromBufferString(n, list) {\n  var p = list.head;\n  var c = 1;\n  var ret = p.data;\n  n -= ret.length;\n  while (p = p.next) {\n    var str = p.data;\n    var nb = n > str.length ? str.length : n;\n    if (nb === str.length) ret += str;else ret += str.slice(0, n);\n    n -= nb;\n    if (n === 0) {\n      if (nb === str.length) {\n        ++c;\n        if (p.next) list.head = p.next;else list.head = list.tail = null;\n      } else {\n        list.head = p;\n        p.data = str.slice(nb);\n      }\n      break;\n    }\n    ++c;\n  }\n  list.length -= c;\n  return ret;\n}\n\n// Copies a specified amount of bytes from the list of buffered data chunks.\n// This function is designed to be inlinable, so please take care when making\n// changes to the function body.\nfunction copyFromBuffer(n, list) {\n  var ret = Buffer.allocUnsafe(n);\n  var p = list.head;\n  var c = 1;\n  p.data.copy(ret);\n  n -= p.data.length;\n  while (p = p.next) {\n    var buf = p.data;\n    var nb = n > buf.length ? buf.length : n;\n    buf.copy(ret, ret.length - n, 0, nb);\n    n -= nb;\n    if (n === 0) {\n      if (nb === buf.length) {\n        ++c;\n        if (p.next) list.head = p.next;else list.head = list.tail = null;\n      } else {\n        list.head = p;\n        p.data = buf.slice(nb);\n      }\n      break;\n    }\n    ++c;\n  }\n  list.length -= c;\n  return ret;\n}\n\nfunction endReadable(stream) {\n  var state = stream._readableState;\n\n  // If we get here before consuming all the bytes, then that is a\n  // bug in node.  Should never happen.\n  if (state.length > 0) throw new Error('\"endReadable()\" called on non-empty stream');\n\n  if (!state.endEmitted) {\n    state.ended = true;\n    processNextTick(endReadableNT, state, stream);\n  }\n}\n\nfunction endReadableNT(state, stream) {\n  // Check that we didn't get one last unshift.\n  if (!state.endEmitted && state.length === 0) {\n    state.endEmitted = true;\n    stream.readable = false;\n    stream.emit('end');\n  }\n}\n\nfunction forEach(xs, f) {\n  for (var i = 0, l = xs.length; i < l; i++) {\n    f(xs[i], i);\n  }\n}\n\nfunction indexOf(xs, x) {\n  for (var i = 0, l = xs.length; i < l; i++) {\n    if (xs[i] === x) return i;\n  }\n  return -1;\n}\n\n\n// WEBPACK FOOTER //\n// ./node_modules/readable-stream/lib/_stream_readable.js","module.exports = require('events').EventEmitter;\n\n\n\n// WEBPACK FOOTER //\n// ./node_modules/readable-stream/lib/internal/streams/stream-browser.js","'use strict';\n\n/*<replacement>*/\n\nvar processNextTick = require('process-nextick-args');\n/*</replacement>*/\n\n// undocumented cb() API, needed for core, not for public API\nfunction destroy(err, cb) {\n  var _this = this;\n\n  var readableDestroyed = this._readableState && this._readableState.destroyed;\n  var writableDestroyed = this._writableState && this._writableState.destroyed;\n\n  if (readableDestroyed || writableDestroyed) {\n    if (cb) {\n      cb(err);\n    } else if (err && (!this._writableState || !this._writableState.errorEmitted)) {\n      processNextTick(emitErrorNT, this, err);\n    }\n    return;\n  }\n\n  // we set destroyed to true before firing error callbacks in order\n  // to make it re-entrance safe in case destroy() is called within callbacks\n\n  if (this._readableState) {\n    this._readableState.destroyed = true;\n  }\n\n  // if this is a duplex stream mark the writable part as destroyed as well\n  if (this._writableState) {\n    this._writableState.destroyed = true;\n  }\n\n  this._destroy(err || null, function (err) {\n    if (!cb && err) {\n      processNextTick(emitErrorNT, _this, err);\n      if (_this._writableState) {\n        _this._writableState.errorEmitted = true;\n      }\n    } else if (cb) {\n      cb(err);\n    }\n  });\n}\n\nfunction undestroy() {\n  if (this._readableState) {\n    this._readableState.destroyed = false;\n    this._readableState.reading = false;\n    this._readableState.ended = false;\n    this._readableState.endEmitted = false;\n  }\n\n  if (this._writableState) {\n    this._writableState.destroyed = false;\n    this._writableState.ended = false;\n    this._writableState.ending = false;\n    this._writableState.finished = false;\n    this._writableState.errorEmitted = false;\n  }\n}\n\nfunction emitErrorNT(self, err) {\n  self.emit('error', err);\n}\n\nmodule.exports = {\n  destroy: destroy,\n  undestroy: undestroy\n};\n\n\n// WEBPACK FOOTER //\n// ./node_modules/readable-stream/lib/internal/streams/destroy.js","'use strict';\n\nvar Buffer = require('safe-buffer').Buffer;\n\nvar isEncoding = Buffer.isEncoding || function (encoding) {\n  encoding = '' + encoding;\n  switch (encoding && encoding.toLowerCase()) {\n    case 'hex':case 'utf8':case 'utf-8':case 'ascii':case 'binary':case 'base64':case 'ucs2':case 'ucs-2':case 'utf16le':case 'utf-16le':case 'raw':\n      return true;\n    default:\n      return false;\n  }\n};\n\nfunction _normalizeEncoding(enc) {\n  if (!enc) return 'utf8';\n  var retried;\n  while (true) {\n    switch (enc) {\n      case 'utf8':\n      case 'utf-8':\n        return 'utf8';\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return 'utf16le';\n      case 'latin1':\n      case 'binary':\n        return 'latin1';\n      case 'base64':\n      case 'ascii':\n      case 'hex':\n        return enc;\n      default:\n        if (retried) return; // undefined\n        enc = ('' + enc).toLowerCase();\n        retried = true;\n    }\n  }\n};\n\n// Do not cache `Buffer.isEncoding` when checking encoding names as some\n// modules monkey-patch it to support additional encodings\nfunction normalizeEncoding(enc) {\n  var nenc = _normalizeEncoding(enc);\n  if (typeof nenc !== 'string' && (Buffer.isEncoding === isEncoding || !isEncoding(enc))) throw new Error('Unknown encoding: ' + enc);\n  return nenc || enc;\n}\n\n// StringDecoder provides an interface for efficiently splitting a series of\n// buffers into a series of JS strings without breaking apart multi-byte\n// characters.\nexports.StringDecoder = StringDecoder;\nfunction StringDecoder(encoding) {\n  this.encoding = normalizeEncoding(encoding);\n  var nb;\n  switch (this.encoding) {\n    case 'utf16le':\n      this.text = utf16Text;\n      this.end = utf16End;\n      nb = 4;\n      break;\n    case 'utf8':\n      this.fillLast = utf8FillLast;\n      nb = 4;\n      break;\n    case 'base64':\n      this.text = base64Text;\n      this.end = base64End;\n      nb = 3;\n      break;\n    default:\n      this.write = simpleWrite;\n      this.end = simpleEnd;\n      return;\n  }\n  this.lastNeed = 0;\n  this.lastTotal = 0;\n  this.lastChar = Buffer.allocUnsafe(nb);\n}\n\nStringDecoder.prototype.write = function (buf) {\n  if (buf.length === 0) return '';\n  var r;\n  var i;\n  if (this.lastNeed) {\n    r = this.fillLast(buf);\n    if (r === undefined) return '';\n    i = this.lastNeed;\n    this.lastNeed = 0;\n  } else {\n    i = 0;\n  }\n  if (i < buf.length) return r ? r + this.text(buf, i) : this.text(buf, i);\n  return r || '';\n};\n\nStringDecoder.prototype.end = utf8End;\n\n// Returns only complete characters in a Buffer\nStringDecoder.prototype.text = utf8Text;\n\n// Attempts to complete a partial non-UTF-8 character using bytes from a Buffer\nStringDecoder.prototype.fillLast = function (buf) {\n  if (this.lastNeed <= buf.length) {\n    buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, this.lastNeed);\n    return this.lastChar.toString(this.encoding, 0, this.lastTotal);\n  }\n  buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, buf.length);\n  this.lastNeed -= buf.length;\n};\n\n// Checks the type of a UTF-8 byte, whether it's ASCII, a leading byte, or a\n// continuation byte.\nfunction utf8CheckByte(byte) {\n  if (byte <= 0x7F) return 0;else if (byte >> 5 === 0x06) return 2;else if (byte >> 4 === 0x0E) return 3;else if (byte >> 3 === 0x1E) return 4;\n  return -1;\n}\n\n// Checks at most 3 bytes at the end of a Buffer in order to detect an\n// incomplete multi-byte UTF-8 character. The total number of bytes (2, 3, or 4)\n// needed to complete the UTF-8 character (if applicable) are returned.\nfunction utf8CheckIncomplete(self, buf, i) {\n  var j = buf.length - 1;\n  if (j < i) return 0;\n  var nb = utf8CheckByte(buf[j]);\n  if (nb >= 0) {\n    if (nb > 0) self.lastNeed = nb - 1;\n    return nb;\n  }\n  if (--j < i) return 0;\n  nb = utf8CheckByte(buf[j]);\n  if (nb >= 0) {\n    if (nb > 0) self.lastNeed = nb - 2;\n    return nb;\n  }\n  if (--j < i) return 0;\n  nb = utf8CheckByte(buf[j]);\n  if (nb >= 0) {\n    if (nb > 0) {\n      if (nb === 2) nb = 0;else self.lastNeed = nb - 3;\n    }\n    return nb;\n  }\n  return 0;\n}\n\n// Validates as many continuation bytes for a multi-byte UTF-8 character as\n// needed or are available. If we see a non-continuation byte where we expect\n// one, we \"replace\" the validated continuation bytes we've seen so far with\n// UTF-8 replacement characters ('\\ufffd'), to match v8's UTF-8 decoding\n// behavior. The continuation byte check is included three times in the case\n// where all of the continuation bytes for a character exist in the same buffer.\n// It is also done this way as a slight performance increase instead of using a\n// loop.\nfunction utf8CheckExtraBytes(self, buf, p) {\n  if ((buf[0] & 0xC0) !== 0x80) {\n    self.lastNeed = 0;\n    return '\\ufffd'.repeat(p);\n  }\n  if (self.lastNeed > 1 && buf.length > 1) {\n    if ((buf[1] & 0xC0) !== 0x80) {\n      self.lastNeed = 1;\n      return '\\ufffd'.repeat(p + 1);\n    }\n    if (self.lastNeed > 2 && buf.length > 2) {\n      if ((buf[2] & 0xC0) !== 0x80) {\n        self.lastNeed = 2;\n        return '\\ufffd'.repeat(p + 2);\n      }\n    }\n  }\n}\n\n// Attempts to complete a multi-byte UTF-8 character using bytes from a Buffer.\nfunction utf8FillLast(buf) {\n  var p = this.lastTotal - this.lastNeed;\n  var r = utf8CheckExtraBytes(this, buf, p);\n  if (r !== undefined) return r;\n  if (this.lastNeed <= buf.length) {\n    buf.copy(this.lastChar, p, 0, this.lastNeed);\n    return this.lastChar.toString(this.encoding, 0, this.lastTotal);\n  }\n  buf.copy(this.lastChar, p, 0, buf.length);\n  this.lastNeed -= buf.length;\n}\n\n// Returns all complete UTF-8 characters in a Buffer. If the Buffer ended on a\n// partial character, the character's bytes are buffered until the required\n// number of bytes are available.\nfunction utf8Text(buf, i) {\n  var total = utf8CheckIncomplete(this, buf, i);\n  if (!this.lastNeed) return buf.toString('utf8', i);\n  this.lastTotal = total;\n  var end = buf.length - (total - this.lastNeed);\n  buf.copy(this.lastChar, 0, end);\n  return buf.toString('utf8', i, end);\n}\n\n// For UTF-8, a replacement character for each buffered byte of a (partial)\n// character needs to be added to the output.\nfunction utf8End(buf) {\n  var r = buf && buf.length ? this.write(buf) : '';\n  if (this.lastNeed) return r + '\\ufffd'.repeat(this.lastTotal - this.lastNeed);\n  return r;\n}\n\n// UTF-16LE typically needs two bytes per character, but even if we have an even\n// number of bytes available, we need to check if we end on a leading/high\n// surrogate. In that case, we need to wait for the next two bytes in order to\n// decode the last character properly.\nfunction utf16Text(buf, i) {\n  if ((buf.length - i) % 2 === 0) {\n    var r = buf.toString('utf16le', i);\n    if (r) {\n      var c = r.charCodeAt(r.length - 1);\n      if (c >= 0xD800 && c <= 0xDBFF) {\n        this.lastNeed = 2;\n        this.lastTotal = 4;\n        this.lastChar[0] = buf[buf.length - 2];\n        this.lastChar[1] = buf[buf.length - 1];\n        return r.slice(0, -1);\n      }\n    }\n    return r;\n  }\n  this.lastNeed = 1;\n  this.lastTotal = 2;\n  this.lastChar[0] = buf[buf.length - 1];\n  return buf.toString('utf16le', i, buf.length - 1);\n}\n\n// For UTF-16LE we do not explicitly append special replacement characters if we\n// end on a partial character, we simply let v8 handle that.\nfunction utf16End(buf) {\n  var r = buf && buf.length ? this.write(buf) : '';\n  if (this.lastNeed) {\n    var end = this.lastTotal - this.lastNeed;\n    return r + this.lastChar.toString('utf16le', 0, end);\n  }\n  return r;\n}\n\nfunction base64Text(buf, i) {\n  var n = (buf.length - i) % 3;\n  if (n === 0) return buf.toString('base64', i);\n  this.lastNeed = 3 - n;\n  this.lastTotal = 3;\n  if (n === 1) {\n    this.lastChar[0] = buf[buf.length - 1];\n  } else {\n    this.lastChar[0] = buf[buf.length - 2];\n    this.lastChar[1] = buf[buf.length - 1];\n  }\n  return buf.toString('base64', i, buf.length - n);\n}\n\nfunction base64End(buf) {\n  var r = buf && buf.length ? this.write(buf) : '';\n  if (this.lastNeed) return r + this.lastChar.toString('base64', 0, 3 - this.lastNeed);\n  return r;\n}\n\n// Pass bytes on through for single-byte encodings (e.g. ascii, latin1, hex)\nfunction simpleWrite(buf) {\n  return buf.toString(this.encoding);\n}\n\nfunction simpleEnd(buf) {\n  return buf && buf.length ? this.write(buf) : '';\n}\n\n\n// WEBPACK FOOTER //\n// ./node_modules/string_decoder/lib/string_decoder.js","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// a transform stream is a readable/writable stream where you do\n// something with the data.  Sometimes it's called a \"filter\",\n// but that's not a great name for it, since that implies a thing where\n// some bits pass through, and others are simply ignored.  (That would\n// be a valid example of a transform, of course.)\n//\n// While the output is causally related to the input, it's not a\n// necessarily symmetric or synchronous transformation.  For example,\n// a zlib stream might take multiple plain-text writes(), and then\n// emit a single compressed chunk some time in the future.\n//\n// Here's how this works:\n//\n// The Transform stream has all the aspects of the readable and writable\n// stream classes.  When you write(chunk), that calls _write(chunk,cb)\n// internally, and returns false if there's a lot of pending writes\n// buffered up.  When you call read(), that calls _read(n) until\n// there's enough pending readable data buffered up.\n//\n// In a transform stream, the written data is placed in a buffer.  When\n// _read(n) is called, it transforms the queued up data, calling the\n// buffered _write cb's as it consumes chunks.  If consuming a single\n// written chunk would result in multiple output chunks, then the first\n// outputted bit calls the readcb, and subsequent chunks just go into\n// the read buffer, and will cause it to emit 'readable' if necessary.\n//\n// This way, back-pressure is actually determined by the reading side,\n// since _read has to be called to start processing a new chunk.  However,\n// a pathological inflate type of transform can cause excessive buffering\n// here.  For example, imagine a stream where every byte of input is\n// interpreted as an integer from 0-255, and then results in that many\n// bytes of output.  Writing the 4 bytes {ff,ff,ff,ff} would result in\n// 1kb of data being output.  In this case, you could write a very small\n// amount of input, and end up with a very large amount of output.  In\n// such a pathological inflating mechanism, there'd be no way to tell\n// the system to stop doing the transform.  A single 4MB write could\n// cause the system to run out of memory.\n//\n// However, even in such a pathological case, only a single written chunk\n// would be consumed, and then the rest would wait (un-transformed) until\n// the results of the previous transformed chunk were consumed.\n\n'use strict';\n\nmodule.exports = Transform;\n\nvar Duplex = require('./_stream_duplex');\n\n/*<replacement>*/\nvar util = require('core-util-is');\nutil.inherits = require('inherits');\n/*</replacement>*/\n\nutil.inherits(Transform, Duplex);\n\nfunction TransformState(stream) {\n  this.afterTransform = function (er, data) {\n    return afterTransform(stream, er, data);\n  };\n\n  this.needTransform = false;\n  this.transforming = false;\n  this.writecb = null;\n  this.writechunk = null;\n  this.writeencoding = null;\n}\n\nfunction afterTransform(stream, er, data) {\n  var ts = stream._transformState;\n  ts.transforming = false;\n\n  var cb = ts.writecb;\n\n  if (!cb) {\n    return stream.emit('error', new Error('write callback called multiple times'));\n  }\n\n  ts.writechunk = null;\n  ts.writecb = null;\n\n  if (data !== null && data !== undefined) stream.push(data);\n\n  cb(er);\n\n  var rs = stream._readableState;\n  rs.reading = false;\n  if (rs.needReadable || rs.length < rs.highWaterMark) {\n    stream._read(rs.highWaterMark);\n  }\n}\n\nfunction Transform(options) {\n  if (!(this instanceof Transform)) return new Transform(options);\n\n  Duplex.call(this, options);\n\n  this._transformState = new TransformState(this);\n\n  var stream = this;\n\n  // start out asking for a readable event once data is transformed.\n  this._readableState.needReadable = true;\n\n  // we have implemented the _read method, and done the other things\n  // that Readable wants before the first _read call, so unset the\n  // sync guard flag.\n  this._readableState.sync = false;\n\n  if (options) {\n    if (typeof options.transform === 'function') this._transform = options.transform;\n\n    if (typeof options.flush === 'function') this._flush = options.flush;\n  }\n\n  // When the writable side finishes, then flush out anything remaining.\n  this.once('prefinish', function () {\n    if (typeof this._flush === 'function') this._flush(function (er, data) {\n      done(stream, er, data);\n    });else done(stream);\n  });\n}\n\nTransform.prototype.push = function (chunk, encoding) {\n  this._transformState.needTransform = false;\n  return Duplex.prototype.push.call(this, chunk, encoding);\n};\n\n// This is the part where you do stuff!\n// override this function in implementation classes.\n// 'chunk' is an input chunk.\n//\n// Call `push(newChunk)` to pass along transformed output\n// to the readable side.  You may call 'push' zero or more times.\n//\n// Call `cb(err)` when you are done with this chunk.  If you pass\n// an error, then that'll put the hurt on the whole operation.  If you\n// never call cb(), then you'll never get another chunk.\nTransform.prototype._transform = function (chunk, encoding, cb) {\n  throw new Error('_transform() is not implemented');\n};\n\nTransform.prototype._write = function (chunk, encoding, cb) {\n  var ts = this._transformState;\n  ts.writecb = cb;\n  ts.writechunk = chunk;\n  ts.writeencoding = encoding;\n  if (!ts.transforming) {\n    var rs = this._readableState;\n    if (ts.needTransform || rs.needReadable || rs.length < rs.highWaterMark) this._read(rs.highWaterMark);\n  }\n};\n\n// Doesn't matter what the args are here.\n// _transform does all the work.\n// That we got here means that the readable side wants more data.\nTransform.prototype._read = function (n) {\n  var ts = this._transformState;\n\n  if (ts.writechunk !== null && ts.writecb && !ts.transforming) {\n    ts.transforming = true;\n    this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform);\n  } else {\n    // mark that we need a transform, so that any data that comes in\n    // will get processed, now that we've asked for it.\n    ts.needTransform = true;\n  }\n};\n\nTransform.prototype._destroy = function (err, cb) {\n  var _this = this;\n\n  Duplex.prototype._destroy.call(this, err, function (err2) {\n    cb(err2);\n    _this.emit('close');\n  });\n};\n\nfunction done(stream, er, data) {\n  if (er) return stream.emit('error', er);\n\n  if (data !== null && data !== undefined) stream.push(data);\n\n  // if there's nothing in the write buffer, then that means\n  // that nothing more will ever be provided\n  var ws = stream._writableState;\n  var ts = stream._transformState;\n\n  if (ws.length) throw new Error('Calling transform done when ws.length != 0');\n\n  if (ts.transforming) throw new Error('Calling transform done when still transforming');\n\n  return stream.push(null);\n}\n\n\n// WEBPACK FOOTER //\n// ./node_modules/readable-stream/lib/_stream_transform.js","const EC       = require('elliptic').ec\r\nconst ec       = new EC('secp256k1')\r\nconst ecparams = ec.curve\r\n\r\nconst BN       = require('bn.js')\r\n\r\nconst rlp      = require('./rlp')\r\nconst {sha3}   = require('./keccak')\r\n\r\n// ===============================\r\n// ethereumjs-util.privateToPublic\r\n// ===============================\r\nconst privateToPublic = function(privateKey, compressed=false) {\r\n  if (typeof privateKey === 'string')\r\n    privateKey = rlp.toBuffer('0x' + rlp.stripHexPrefix(privateKey))\r\n\r\n  if (! Buffer.isBuffer(privateKey))\r\n    throw new Error('invalid private key')\r\n\r\n  let d = new BN(privateKey)\r\n  if (d.cmp(ecparams.n) >= 0 || d.isZero())\r\n    throw new Error('invalid private key')\r\n\r\n  let publicKey = Buffer.from(ec.keyFromPrivate(privateKey).getPublic(compressed, true))\r\n  return publicKey.toString('hex')\r\n}\r\n\r\n// ===============================\r\n// ethereumjs-util.publicToAddress\r\n// ===============================\r\nconst publicToAddress = function(publicKey) {\r\n  if (typeof publicKey === 'string')\r\n    publicKey = rlp.toBuffer('0x' + rlp.stripHexPrefix(publicKey))\r\n\r\n  if (! Buffer.isBuffer(publicKey))\r\n    throw new Error('invalid public key')\r\n\r\n  if (publicKey.length === 65)\r\n    publicKey = publicKey.slice(1)\r\n\r\n  if (publicKey.length !== 64)\r\n    throw new Error(`Length of public key is ${publicKey.length} bytes. Expected length is 64 bytes.`)\r\n\r\n  // address contains the lower 160bits of the hash => 20 bytes => 40 hex-encoded string characters\r\n  return sha3(publicKey).slice(-40)\r\n}\r\n\r\nconst genKeyPair = function() {\r\n  let key = ec.genKeyPair()\r\n\r\n  let privateKey = key.getPrivate('hex')\r\n  let publicKey  = key.getPublic().encode('hex')\r\n  let address    = publicToAddress(publicKey)\r\n\r\n  return {privateKey, publicKey, address}\r\n}\r\n\r\nmodule.exports = {privateToPublic, publicToAddress, genKeyPair}\r\n\n\n\n// WEBPACK FOOTER //\n// ./../lib/keypairs.js","const {Buffer} = require('buffer')\r\n\r\nconst BN = require('bn.js')\r\n\r\nconst {sign, verify, unsign} = require('../../index')\r\nconst {privateToPublic, publicToAddress, genKeyPair} = require('../../lib/keypairs')\r\nconst {encode, isHexPrefixed, stripHexPrefix, stripZeros, intToHex, padToEven, intToBuffer, toBuffer, bufferToHex, bufferToInt} = require('../../lib/rlp')\r\nconst {createKeccakHash, sha3} = require('../../lib/keccak')\r\n\r\nconst ethereumjs_tx_sign = {\r\n  sign,\r\n  verify,\r\n  unsign,\r\n  keypairs: {privateToPublic, publicToAddress, genKeyPair},\r\n  rlp:      {encode, isHexPrefixed, stripHexPrefix, stripZeros, intToHex, padToEven, intToBuffer, toBuffer, bufferToHex, bufferToInt},\r\n  keccak:   {createKeccakHash, sha3}\r\n}\r\n\r\nwindow.Buffer = Buffer\r\n\r\nwindow.BN = BN\r\n\r\nwindow.ethereumjs_tx_sign = ethereumjs_tx_sign\r\n\n\n\n// WEBPACK FOOTER //\n// ./src/globals.js","'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\nrevLookup['-'.charCodeAt(0)] = 62\nrevLookup['_'.charCodeAt(0)] = 63\n\nfunction placeHoldersCount (b64) {\n  var len = b64.length\n  if (len % 4 > 0) {\n    throw new Error('Invalid string. Length must be a multiple of 4')\n  }\n\n  // the number of equal signs (place holders)\n  // if there are two placeholders, than the two characters before it\n  // represent one byte\n  // if there is only one, then the three characters before it represent 2 bytes\n  // this is just a cheap hack to not do indexOf twice\n  return b64[len - 2] === '=' ? 2 : b64[len - 1] === '=' ? 1 : 0\n}\n\nfunction byteLength (b64) {\n  // base64 is 4/3 + up to two characters of the original data\n  return (b64.length * 3 / 4) - placeHoldersCount(b64)\n}\n\nfunction toByteArray (b64) {\n  var i, l, tmp, placeHolders, arr\n  var len = b64.length\n  placeHolders = placeHoldersCount(b64)\n\n  arr = new Arr((len * 3 / 4) - placeHolders)\n\n  // if there are placeholders, only get up to the last complete 4 chars\n  l = placeHolders > 0 ? len - 4 : len\n\n  var L = 0\n\n  for (i = 0; i < l; i += 4) {\n    tmp = (revLookup[b64.charCodeAt(i)] << 18) | (revLookup[b64.charCodeAt(i + 1)] << 12) | (revLookup[b64.charCodeAt(i + 2)] << 6) | revLookup[b64.charCodeAt(i + 3)]\n    arr[L++] = (tmp >> 16) & 0xFF\n    arr[L++] = (tmp >> 8) & 0xFF\n    arr[L++] = tmp & 0xFF\n  }\n\n  if (placeHolders === 2) {\n    tmp = (revLookup[b64.charCodeAt(i)] << 2) | (revLookup[b64.charCodeAt(i + 1)] >> 4)\n    arr[L++] = tmp & 0xFF\n  } else if (placeHolders === 1) {\n    tmp = (revLookup[b64.charCodeAt(i)] << 10) | (revLookup[b64.charCodeAt(i + 1)] << 4) | (revLookup[b64.charCodeAt(i + 2)] >> 2)\n    arr[L++] = (tmp >> 8) & 0xFF\n    arr[L++] = tmp & 0xFF\n  }\n\n  return arr\n}\n\nfunction tripletToBase64 (num) {\n  return lookup[num >> 18 & 0x3F] + lookup[num >> 12 & 0x3F] + lookup[num >> 6 & 0x3F] + 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 = (uint8[i] << 16) + (uint8[i + 1] << 8) + (uint8[i + 2])\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 output = ''\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    output += lookup[tmp >> 2]\n    output += lookup[(tmp << 4) & 0x3F]\n    output += '=='\n  } else if (extraBytes === 2) {\n    tmp = (uint8[len - 2] << 8) + (uint8[len - 1])\n    output += lookup[tmp >> 10]\n    output += lookup[(tmp >> 4) & 0x3F]\n    output += lookup[(tmp << 2) & 0x3F]\n    output += '='\n  }\n\n  parts.push(output)\n\n  return parts.join('')\n}\n\n\n\n// WEBPACK FOOTER //\n// ./node_modules/base64-js/index.js","exports.read = function (buffer, offset, isLE, mLen, nBytes) {\n  var e, m\n  var eLen = nBytes * 8 - mLen - 1\n  var eMax = (1 << eLen) - 1\n  var eBias = eMax >> 1\n  var nBits = -7\n  var i = isLE ? (nBytes - 1) : 0\n  var d = isLE ? -1 : 1\n  var s = buffer[offset + i]\n\n  i += d\n\n  e = s & ((1 << (-nBits)) - 1)\n  s >>= (-nBits)\n  nBits += eLen\n  for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8) {}\n\n  m = e & ((1 << (-nBits)) - 1)\n  e >>= (-nBits)\n  nBits += mLen\n  for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8) {}\n\n  if (e === 0) {\n    e = 1 - eBias\n  } else if (e === eMax) {\n    return m ? NaN : ((s ? -1 : 1) * Infinity)\n  } else {\n    m = m + Math.pow(2, mLen)\n    e = e - eBias\n  }\n  return (s ? -1 : 1) * m * Math.pow(2, e - mLen)\n}\n\nexports.write = function (buffer, value, offset, isLE, mLen, nBytes) {\n  var e, m, c\n  var eLen = nBytes * 8 - mLen - 1\n  var eMax = (1 << eLen) - 1\n  var eBias = eMax >> 1\n  var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0)\n  var i = isLE ? 0 : (nBytes - 1)\n  var d = isLE ? 1 : -1\n  var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0\n\n  value = Math.abs(value)\n\n  if (isNaN(value) || value === Infinity) {\n    m = isNaN(value) ? 1 : 0\n    e = eMax\n  } else {\n    e = Math.floor(Math.log(value) / Math.LN2)\n    if (value * (c = Math.pow(2, -e)) < 1) {\n      e--\n      c *= 2\n    }\n    if (e + eBias >= 1) {\n      value += rt / c\n    } else {\n      value += rt * Math.pow(2, 1 - eBias)\n    }\n    if (value * c >= 2) {\n      e++\n      c /= 2\n    }\n\n    if (e + eBias >= eMax) {\n      m = 0\n      e = eMax\n    } else if (e + eBias >= 1) {\n      m = (value * c - 1) * Math.pow(2, mLen)\n      e = e + eBias\n    } else {\n      m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen)\n      e = 0\n    }\n  }\n\n  for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}\n\n  e = (e << mLen) | m\n  eLen += mLen\n  for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}\n\n  buffer[offset + i - d] |= s * 128\n}\n\n\n\n// WEBPACK FOOTER //\n// ./node_modules/ieee754/index.js","module.exports = function(module) {\r\n\tif(!module.webpackPolyfill) {\r\n\t\tmodule.deprecate = function() {};\r\n\t\tmodule.paths = [];\r\n\t\t// module.parent = undefined by default\r\n\t\tif(!module.children) module.children = [];\r\n\t\tObject.defineProperty(module, \"loaded\", {\r\n\t\t\tenumerable: true,\r\n\t\t\tget: function() {\r\n\t\t\t\treturn module.l;\r\n\t\t\t}\r\n\t\t});\r\n\t\tObject.defineProperty(module, \"id\", {\r\n\t\t\tenumerable: true,\r\n\t\t\tget: function() {\r\n\t\t\t\treturn module.i;\r\n\t\t\t}\r\n\t\t});\r\n\t\tmodule.webpackPolyfill = 1;\r\n\t}\r\n\treturn module;\r\n};\r\n\n\n\n// WEBPACK FOOTER //\n// (webpack)/buildin/module.js","'use strict'\r\n\r\nconst EC = require('elliptic').ec\r\nconst ec = new EC('secp256k1')\r\nconst ecparams = ec.curve\r\n\r\nconst BN = require('bn.js')\r\n\r\nconst unsignRawTx = require('@warren-bank/ethereumjs-tx-unsign')\r\n\r\nconst rlp = require('./lib/rlp')  // {encode, isHexPrefixed, stripHexPrefix, stripZeros, intToHex, padToEven, intToBuffer, toBuffer, bufferToHex, bufferToInt}\r\n\r\nconst {sha3} = require('./lib/keccak')\r\n\r\nconst {publicToAddress} = require('./lib/keypairs')\r\n\r\nconst assert = require('assert')\r\n\r\n// ----------------------------------------------------------------------\r\n\r\n// =========================\r\n// ethereumjs-tx.constructor\r\n// =========================\r\nconst fields = [{\r\n  name: 'nonce',\r\n  length: 32,\r\n  allowLess: true,\r\n  default: new Buffer([])\r\n}, {\r\n  name: 'gasPrice',\r\n  length: 32,\r\n  allowLess: true,\r\n  default: new Buffer([])\r\n}, {\r\n  name: 'gasLimit',\r\n  alias: 'gas',\r\n  length: 32,\r\n  allowLess: true,\r\n  default: new Buffer([])\r\n}, {\r\n  name: 'to',\r\n  allowZero: true,\r\n  length: 20,\r\n  default: new Buffer([])\r\n}, {\r\n  name: 'value',\r\n  length: 32,\r\n  allowLess: true,\r\n  default: new Buffer([])\r\n}, {\r\n  name: 'data',\r\n  alias: 'input',\r\n  allowZero: true,\r\n  default: new Buffer([])\r\n}, {\r\n  name: 'v',\r\n  allowZero: true,\r\n  default: new Buffer([0x1c])\r\n}, {\r\n  name: 'r',\r\n  length: 32,\r\n  allowZero: true,\r\n  allowLess: true,\r\n  default: new Buffer([])\r\n}, {\r\n  name: 's',\r\n  length: 32,\r\n  allowZero: true,\r\n  allowLess: true,\r\n  default: new Buffer([])\r\n}]\r\n\r\n// ================================\r\n// ethereumjs-util.defineProperties\r\n// ================================\r\nconst process_data = function(data, use_defaults=true) {\r\n  let raw = []\r\n  let keys = Object.keys(data)\r\n\r\n  fields.forEach(function (field, index) {\r\n    let value\r\n    if      (keys.indexOf(field.name)  !== -1)               value = get_field_value(field, data[field.name])\r\n    else if (keys.indexOf(field.alias) !== -1)               value = get_field_value(field, data[field.alias])\r\n    else if (use_defaults && (field.default !== undefined))  value = field.default\r\n    if (value !== undefined) raw[index] = value\r\n  })\r\n\r\n  return raw\r\n}\r\n\r\nconst get_field_value = function(field, value) {\r\n  let v      = rlp.toBuffer(value)\r\n  let isZero = (v.toString('hex').match(/^0+$/) !== null)\r\n\r\n  // modify value\r\n  if (isZero) {\r\n    if (!field.allowZero)     v = Buffer.allocUnsafe(0)\r\n    else if (field.allowLess) v = Buffer.alloc(1, 0)\r\n    else if (field.length)    v = Buffer.alloc(field.length, 0)\r\n  }\r\n  else {\r\n    if (field.allowLess)      v = rlp.stripZeros(v)\r\n  }\r\n\r\n  // validate value\r\n  if (field.length) {\r\n    if (field.allowLess)      assert(field.length  >= v.length, 'The field ' + field.name + ' must not have more ' + field.length + ' bytes')\r\n    else                      assert(field.length === v.length, 'The field ' + field.name + ' must have byte length of ' + field.length)\r\n  }\r\n\r\n  return v\r\n}\r\n\r\n// ==================\r\n// ethereumjs-tx.sign\r\n// ==================\r\nconst get_signature = function(rawData, chainId, privateKey) {\r\n  let msgHash    = get_hash(rawData, chainId)\r\n  let {DER, sig} = get_raw_signature(msgHash, privateKey)\r\n  let rawSigData = format_raw_signature(sig)\r\n  if (chainId)\r\n    rawSigData.v += (chainId * 2) + 8\r\n  rawSigData     = process_data(rawSigData, false)\r\n  rawSigData.forEach((value, index) => {\r\n    if (value !== undefined) rawData[index] = value\r\n  })\r\n\r\n  return {msgHash, DER, signature: sig.signature}\r\n}\r\n\r\n// ==================\r\n// ethereumjs-tx.hash\r\n// ==================\r\nconst get_hash = function(rawData, chainId) {\r\n  let items = rawData.slice(0, 6)  // \"nonce\",\"gasPrice\",\"gasLimit\",\"to\",\"value\",\"data\"\r\n  if (chainId) {\r\n    let rawSigData = {v: chainId, r: null, s: null}\r\n    rawSigData     = process_data(rawSigData, false)\r\n    rawSigData.forEach((value, index) => {\r\n      if (value !== undefined) items[index] = value\r\n    })\r\n  }\r\n\r\n  let msgHash = sha3(rlp.encode(items))\r\n  return rlp.stripHexPrefix(msgHash)\r\n}\r\n\r\n// ===================\r\n// secp256k1-node.sign\r\n// ===================\r\nconst get_raw_signature = function(msgHash, privateKey) {\r\n  let d = new BN(rlp.bufferToHex(privateKey, false), 16)\r\n  if (d.cmp(ecparams.n) >= 0 || d.isZero()) throw new Error(\"nonce generation function failed or private key is invalid\")\r\n\r\n  let signed_msgHash = ec.sign(msgHash, privateKey, { canonical: true })\r\n  let DER = signed_msgHash.toDER()\r\n  let sig = {\r\n    signature: Buffer.concat([\r\n      signed_msgHash.r.toArrayLike(Buffer, 'be', 32),\r\n      signed_msgHash.s.toArrayLike(Buffer, 'be', 32)\r\n    ]),\r\n    recovery: signed_msgHash.recoveryParam\r\n  }\r\n  return {DER, sig}\r\n}\r\n\r\n// ======================\r\n// ethereumjs-util.ecsign\r\n// ======================\r\nconst format_raw_signature = function(sig) {\r\n  let data = {}\r\n  data.v = sig.recovery + 27\r\n  data.r = sig.signature.slice(0, 32)\r\n  data.s = sig.signature.slice(32, 64)\r\n  return data\r\n}\r\n\r\n// ===\r\n// API\r\n// ===\r\nconst sign = function(data, privateKey) {\r\n  privateKey                    = rlp.toBuffer('0x' + rlp.stripHexPrefix(privateKey))\r\n  let rawData                   = process_data(data)\r\n  let {msgHash, DER, signature} = get_signature(rawData, data.chainId, privateKey)\r\n  let rawTx                     = rlp.encode(rawData).toString('hex')\r\n  return {rawData, msgHash, DER, signature, rawTx}\r\n}\r\n\r\n// =====================\r\n// secp256k1-node.verify\r\n// =====================\r\nconst verify = function(msgHash, signature, publicKey) {\r\n  publicKey  = rlp.toBuffer('0x' + rlp.stripHexPrefix(publicKey))\r\n\r\n  // skip this step if signature is DER encoded\r\n  if (Buffer.isBuffer(signature) && (signature.length === 64)) {\r\n    let sigObj = {r: signature.slice(0, 32), s: signature.slice(32, 64)}\r\n\r\n    let sigr = new BN(sigObj.r.toString('hex'), 16)\r\n    let sigs = new BN(sigObj.s.toString('hex'), 16)\r\n    if (sigr.cmp(ecparams.n) >= 0 || sigs.cmp(ecparams.n) >= 0) throw new Error(\"couldn't parse signature\")\r\n    if (sigs.cmp(ec.nh) === 1 || sigr.isZero() || sigs.isZero()) return false\r\n\r\n    signature = sigObj\r\n  }\r\n\r\n  return ec.verify(msgHash, signature, publicKey)\r\n}\r\n\r\nconst unsign = function(rawTx) {\r\n  let {txData, signature} = unsignRawTx(rawTx, true, true, false)\r\n\r\n  let rawData = process_data(txData)\r\n  let msgHash = get_hash(rawData, txData.chainId)\r\n\r\n  let ec_msgHash = new BN(msgHash, 16)\r\n  let ec_signature = {\r\n    r: signature.r,\r\n    s: signature.s\r\n  }\r\n  let ec_recovery = parseInt(signature.v, 16) - 27\r\n  if (txData.chainId)\r\n    ec_recovery -= (txData.chainId * 2) + 8\r\n\r\n  let publicKey = ec.recoverPubKey(ec_msgHash, ec_signature, ec_recovery).encode('hex')\r\n  let address = publicToAddress(publicKey)\r\n\r\n  return {txData, signature, msgHash, publicKey, address}\r\n}\r\n\r\nmodule.exports = {sign, verify, unsign}\r\n\r\n// ----------------------------------------------------------------------\r\n\n\n\n// WEBPACK FOOTER //\n// ./../index.js","module.exports = {\"_args\":[[\"elliptic@6.4.0\",\"c:\\\\_z\\\\ethereumjs-tx-sign\\\\browser-build\"]],\"_development\":true,\"_from\":\"elliptic@6.4.0\",\"_id\":\"elliptic@6.4.0\",\"_inBundle\":false,\"_integrity\":\"sha1-ysmvh2LIWDYYcAPI3+GT5eLq5d8=\",\"_location\":\"/elliptic\",\"_phantomChildren\":{},\"_requested\":{\"type\":\"version\",\"registry\":true,\"raw\":\"elliptic@6.4.0\",\"name\":\"elliptic\",\"escapedName\":\"elliptic\",\"rawSpec\":\"6.4.0\",\"saveSpec\":null,\"fetchSpec\":\"6.4.0\"},\"_requiredBy\":[\"/browserify-sign\",\"/create-ecdh\"],\"_resolved\":\"https://registry.npmjs.org/elliptic/-/elliptic-6.4.0.tgz\",\"_spec\":\"6.4.0\",\"_where\":\"c:\\\\_z\\\\ethereumjs-tx-sign\\\\browser-build\",\"author\":{\"name\":\"Fedor Indutny\",\"email\":\"fedor@indutny.com\"},\"bugs\":{\"url\":\"https://github.com/indutny/elliptic/issues\"},\"dependencies\":{\"bn.js\":\"^4.4.0\",\"brorand\":\"^1.0.1\",\"hash.js\":\"^1.0.0\",\"hmac-drbg\":\"^1.0.0\",\"inherits\":\"^2.0.1\",\"minimalistic-assert\":\"^1.0.0\",\"minimalistic-crypto-utils\":\"^1.0.0\"},\"description\":\"EC cryptography\",\"devDependencies\":{\"brfs\":\"^1.4.3\",\"coveralls\":\"^2.11.3\",\"grunt\":\"^0.4.5\",\"grunt-browserify\":\"^5.0.0\",\"grunt-cli\":\"^1.2.0\",\"grunt-contrib-connect\":\"^1.0.0\",\"grunt-contrib-copy\":\"^1.0.0\",\"grunt-contrib-uglify\":\"^1.0.1\",\"grunt-mocha-istanbul\":\"^3.0.1\",\"grunt-saucelabs\":\"^8.6.2\",\"istanbul\":\"^0.4.2\",\"jscs\":\"^2.9.0\",\"jshint\":\"^2.6.0\",\"mocha\":\"^2.1.0\"},\"files\":[\"lib\"],\"homepage\":\"https://github.com/indutny/elliptic\",\"keywords\":[\"EC\",\"Elliptic\",\"curve\",\"Cryptography\"],\"license\":\"MIT\",\"main\":\"lib/elliptic.js\",\"name\":\"elliptic\",\"repository\":{\"type\":\"git\",\"url\":\"git+ssh://git@github.com/indutny/elliptic.git\"},\"scripts\":{\"jscs\":\"jscs benchmarks/*.js lib/*.js lib/**/*.js lib/**/**/*.js test/index.js\",\"jshint\":\"jscs benchmarks/*.js lib/*.js lib/**/*.js lib/**/**/*.js test/index.js\",\"lint\":\"npm run jscs && npm run jshint\",\"test\":\"npm run lint && npm run unit\",\"unit\":\"istanbul test _mocha --reporter=spec test/index.js\",\"version\":\"grunt dist && git add dist/\"},\"version\":\"6.4.0\"}\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/elliptic/package.json\n// module id = 40\n// module chunks = 0","'use strict';\n\nvar utils = exports;\nvar BN = require('bn.js');\nvar minAssert = require('minimalistic-assert');\nvar minUtils = require('minimalistic-crypto-utils');\n\nutils.assert = minAssert;\nutils.toArray = minUtils.toArray;\nutils.zero2 = minUtils.zero2;\nutils.toHex = minUtils.toHex;\nutils.encode = minUtils.encode;\n\n// Represent num in a w-NAF form\nfunction getNAF(num, w) {\n  var naf = [];\n  var ws = 1 << (w + 1);\n  var k = num.clone();\n  while (k.cmpn(1) >= 0) {\n    var z;\n    if (k.isOdd()) {\n      var mod = k.andln(ws - 1);\n      if (mod > (ws >> 1) - 1)\n        z = (ws >> 1) - mod;\n      else\n        z = mod;\n      k.isubn(z);\n    } else {\n      z = 0;\n    }\n    naf.push(z);\n\n    // Optimization, shift by word if possible\n    var shift = (k.cmpn(0) !== 0 && k.andln(ws - 1) === 0) ? (w + 1) : 1;\n    for (var i = 1; i < shift; i++)\n      naf.push(0);\n    k.iushrn(shift);\n  }\n\n  return naf;\n}\nutils.getNAF = getNAF;\n\n// Represent k1, k2 in a Joint Sparse Form\nfunction getJSF(k1, k2) {\n  var jsf = [\n    [],\n    []\n  ];\n\n  k1 = k1.clone();\n  k2 = k2.clone();\n  var d1 = 0;\n  var d2 = 0;\n  while (k1.cmpn(-d1) > 0 || k2.cmpn(-d2) > 0) {\n\n    // First phase\n    var m14 = (k1.andln(3) + d1) & 3;\n    var m24 = (k2.andln(3) + d2) & 3;\n    if (m14 === 3)\n      m14 = -1;\n    if (m24 === 3)\n      m24 = -1;\n    var u1;\n    if ((m14 & 1) === 0) {\n      u1 = 0;\n    } else {\n      var m8 = (k1.andln(7) + d1) & 7;\n      if ((m8 === 3 || m8 === 5) && m24 === 2)\n        u1 = -m14;\n      else\n        u1 = m14;\n    }\n    jsf[0].push(u1);\n\n    var u2;\n    if ((m24 & 1) === 0) {\n      u2 = 0;\n    } else {\n      var m8 = (k2.andln(7) + d2) & 7;\n      if ((m8 === 3 || m8 === 5) && m14 === 2)\n        u2 = -m24;\n      else\n        u2 = m24;\n    }\n    jsf[1].push(u2);\n\n    // Second phase\n    if (2 * d1 === u1 + 1)\n      d1 = 1 - d1;\n    if (2 * d2 === u2 + 1)\n      d2 = 1 - d2;\n    k1.iushrn(1);\n    k2.iushrn(1);\n  }\n\n  return jsf;\n}\nutils.getJSF = getJSF;\n\nfunction cachedProperty(obj, name, computer) {\n  var key = '_' + name;\n  obj.prototype[name] = function cachedProperty() {\n    return this[key] !== undefined ? this[key] :\n           this[key] = computer.call(this);\n  };\n}\nutils.cachedProperty = cachedProperty;\n\nfunction parseBytes(bytes) {\n  return typeof bytes === 'string' ? utils.toArray(bytes, 'hex') :\n                                     bytes;\n}\nutils.parseBytes = parseBytes;\n\nfunction intFromLE(bytes) {\n  return new BN(bytes, 'hex', 'le');\n}\nutils.intFromLE = intFromLE;\n\n\n\n\n// WEBPACK FOOTER //\n// ./node_modules/elliptic/lib/elliptic/utils.js","var r;\n\nmodule.exports = function rand(len) {\n  if (!r)\n    r = new Rand(null);\n\n  return r.generate(len);\n};\n\nfunction Rand(rand) {\n  this.rand = rand;\n}\nmodule.exports.Rand = Rand;\n\nRand.prototype.generate = function generate(len) {\n  return this._rand(len);\n};\n\n// Emulate crypto API using randy\nRand.prototype._rand = function _rand(n) {\n  if (this.rand.getBytes)\n    return this.rand.getBytes(n);\n\n  var res = new Uint8Array(n);\n  for (var i = 0; i < res.length; i++)\n    res[i] = this.rand.getByte();\n  return res;\n};\n\nif (typeof self === 'object') {\n  if (self.crypto && self.crypto.getRandomValues) {\n    // Modern browsers\n    Rand.prototype._rand = function _rand(n) {\n      var arr = new Uint8Array(n);\n      self.crypto.getRandomValues(arr);\n      return arr;\n    };\n  } else if (self.msCrypto && self.msCrypto.getRandomValues) {\n    // IE\n    Rand.prototype._rand = function _rand(n) {\n      var arr = new Uint8Array(n);\n      self.msCrypto.getRandomValues(arr);\n      return arr;\n    };\n\n  // Safari's WebWorkers do not have `crypto`\n  } else if (typeof window === 'object') {\n    // Old junk\n    Rand.prototype._rand = function() {\n      throw new Error('Not implemented yet');\n    };\n  }\n} else {\n  // Node.js or Web worker with no crypto support\n  try {\n    var crypto = require('crypto');\n    if (typeof crypto.randomBytes !== 'function')\n      throw new Error('Not supported');\n\n    Rand.prototype._rand = function _rand(n) {\n      return crypto.randomBytes(n);\n    };\n  } catch (e) {\n  }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./node_modules/brorand/index.js","'use strict';\n\nvar BN = require('bn.js');\nvar elliptic = require('../../elliptic');\nvar utils = elliptic.utils;\nvar getNAF = utils.getNAF;\nvar getJSF = utils.getJSF;\nvar assert = utils.assert;\n\nfunction BaseCurve(type, conf) {\n  this.type = type;\n  this.p = new BN(conf.p, 16);\n\n  // Use Montgomery, when there is no fast reduction for the prime\n  this.red = conf.prime ? BN.red(conf.prime) : BN.mont(this.p);\n\n  // Useful for many curves\n  this.zero = new BN(0).toRed(this.red);\n  this.one = new BN(1).toRed(this.red);\n  this.two = new BN(2).toRed(this.red);\n\n  // Curve configuration, optional\n  this.n = conf.n && new BN(conf.n, 16);\n  this.g = conf.g && this.pointFromJSON(conf.g, conf.gRed);\n\n  // Temporary arrays\n  this._wnafT1 = new Array(4);\n  this._wnafT2 = new Array(4);\n  this._wnafT3 = new Array(4);\n  this._wnafT4 = new Array(4);\n\n  // Generalized Greg Maxwell's trick\n  var adjustCount = this.n && this.p.div(this.n);\n  if (!adjustCount || adjustCount.cmpn(100) > 0) {\n    this.redN = null;\n  } else {\n    this._maxwellTrick = true;\n    this.redN = this.n.toRed(this.red);\n  }\n}\nmodule.exports = BaseCurve;\n\nBaseCurve.prototype.point = function point() {\n  throw new Error('Not implemented');\n};\n\nBaseCurve.prototype.validate = function validate() {\n  throw new Error('Not implemented');\n};\n\nBaseCurve.prototype._fixedNafMul = function _fixedNafMul(p, k) {\n  assert(p.precomputed);\n  var doubles = p._getDoubles();\n\n  var naf = getNAF(k, 1);\n  var I = (1 << (doubles.step + 1)) - (doubles.step % 2 === 0 ? 2 : 1);\n  I /= 3;\n\n  // Translate into more windowed form\n  var repr = [];\n  for (var j = 0; j < naf.length; j += doubles.step) {\n    var nafW = 0;\n    for (var k = j + doubles.step - 1; k >= j; k--)\n      nafW = (nafW << 1) + naf[k];\n    repr.push(nafW);\n  }\n\n  var a = this.jpoint(null, null, null);\n  var b = this.jpoint(null, null, null);\n  for (var i = I; i > 0; i--) {\n    for (var j = 0; j < repr.length; j++) {\n      var nafW = repr[j];\n      if (nafW === i)\n        b = b.mixedAdd(doubles.points[j]);\n      else if (nafW === -i)\n        b = b.mixedAdd(doubles.points[j].neg());\n    }\n    a = a.add(b);\n  }\n  return a.toP();\n};\n\nBaseCurve.prototype._wnafMul = function _wnafMul(p, k) {\n  var w = 4;\n\n  // Precompute window\n  var nafPoints = p._getNAFPoints(w);\n  w = nafPoints.wnd;\n  var wnd = nafPoints.points;\n\n  // Get NAF form\n  var naf = getNAF(k, w);\n\n  // Add `this`*(N+1) for every w-NAF index\n  var acc = this.jpoint(null, null, null);\n  for (var i = naf.length - 1; i >= 0; i--) {\n    // Count zeroes\n    for (var k = 0; i >= 0 && naf[i] === 0; i--)\n      k++;\n    if (i >= 0)\n      k++;\n    acc = acc.dblp(k);\n\n    if (i < 0)\n      break;\n    var z = naf[i];\n    assert(z !== 0);\n    if (p.type === 'affine') {\n      // J +- P\n      if (z > 0)\n        acc = acc.mixedAdd(wnd[(z - 1) >> 1]);\n      else\n        acc = acc.mixedAdd(wnd[(-z - 1) >> 1].neg());\n    } else {\n      // J +- J\n      if (z > 0)\n        acc = acc.add(wnd[(z - 1) >> 1]);\n      else\n        acc = acc.add(wnd[(-z - 1) >> 1].neg());\n    }\n  }\n  return p.type === 'affine' ? acc.toP() : acc;\n};\n\nBaseCurve.prototype._wnafMulAdd = function _wnafMulAdd(defW,\n                                                       points,\n                                                       coeffs,\n                                                       len,\n                                                       jacobianResult) {\n  var wndWidth = this._wnafT1;\n  var wnd = this._wnafT2;\n  var naf = this._wnafT3;\n\n  // Fill all arrays\n  var max = 0;\n  for (var i = 0; i < len; i++) {\n    var p = points[i];\n    var nafPoints = p._getNAFPoints(defW);\n    wndWidth[i] = nafPoints.wnd;\n    wnd[i] = nafPoints.points;\n  }\n\n  // Comb small window NAFs\n  for (var i = len - 1; i >= 1; i -= 2) {\n    var a = i - 1;\n    var b = i;\n    if (wndWidth[a] !== 1 || wndWidth[b] !== 1) {\n      naf[a] = getNAF(coeffs[a], wndWidth[a]);\n      naf[b] = getNAF(coeffs[b], wndWidth[b]);\n      max = Math.max(naf[a].length, max);\n      max = Math.max(naf[b].length, max);\n      continue;\n    }\n\n    var comb = [\n      points[a], /* 1 */\n      null, /* 3 */\n      null, /* 5 */\n      points[b] /* 7 */\n    ];\n\n    // Try to avoid Projective points, if possible\n    if (points[a].y.cmp(points[b].y) === 0) {\n      comb[1] = points[a].add(points[b]);\n      comb[2] = points[a].toJ().mixedAdd(points[b].neg());\n    } else if (points[a].y.cmp(points[b].y.redNeg()) === 0) {\n      comb[1] = points[a].toJ().mixedAdd(points[b]);\n      comb[2] = points[a].add(points[b].neg());\n    } else {\n      comb[1] = points[a].toJ().mixedAdd(points[b]);\n      comb[2] = points[a].toJ().mixedAdd(points[b].neg());\n    }\n\n    var index = [\n      -3, /* -1 -1 */\n      -1, /* -1 0 */\n      -5, /* -1 1 */\n      -7, /* 0 -1 */\n      0, /* 0 0 */\n      7, /* 0 1 */\n      5, /* 1 -1 */\n      1, /* 1 0 */\n      3  /* 1 1 */\n    ];\n\n    var jsf = getJSF(coeffs[a], coeffs[b]);\n    max = Math.max(jsf[0].length, max);\n    naf[a] = new Array(max);\n    naf[b] = new Array(max);\n    for (var j = 0; j < max; j++) {\n      var ja = jsf[0][j] | 0;\n      var jb = jsf[1][j] | 0;\n\n      naf[a][j] = index[(ja + 1) * 3 + (jb + 1)];\n      naf[b][j] = 0;\n      wnd[a] = comb;\n    }\n  }\n\n  var acc = this.jpoint(null, null, null);\n  var tmp = this._wnafT4;\n  for (var i = max; i >= 0; i--) {\n    var k = 0;\n\n    while (i >= 0) {\n      var zero = true;\n      for (var j = 0; j < len; j++) {\n        tmp[j] = naf[j][i] | 0;\n        if (tmp[j] !== 0)\n          zero = false;\n      }\n      if (!zero)\n        break;\n      k++;\n      i--;\n    }\n    if (i >= 0)\n      k++;\n    acc = acc.dblp(k);\n    if (i < 0)\n      break;\n\n    for (var j = 0; j < len; j++) {\n      var z = tmp[j];\n      var p;\n      if (z === 0)\n        continue;\n      else if (z > 0)\n        p = wnd[j][(z - 1) >> 1];\n      else if (z < 0)\n        p = wnd[j][(-z - 1) >> 1].neg();\n\n      if (p.type === 'affine')\n        acc = acc.mixedAdd(p);\n      else\n        acc = acc.add(p);\n    }\n  }\n  // Zeroify references\n  for (var i = 0; i < len; i++)\n    wnd[i] = null;\n\n  if (jacobianResult)\n    return acc;\n  else\n    return acc.toP();\n};\n\nfunction BasePoint(curve, type) {\n  this.curve = curve;\n  this.type = type;\n  this.precomputed = null;\n}\nBaseCurve.BasePoint = BasePoint;\n\nBasePoint.prototype.eq = function eq(/*other*/) {\n  throw new Error('Not implemented');\n};\n\nBasePoint.prototype.validate = function validate() {\n  return this.curve.validate(this);\n};\n\nBaseCurve.prototype.decodePoint = function decodePoint(bytes, enc) {\n  bytes = utils.toArray(bytes, enc);\n\n  var len = this.p.byteLength();\n\n  // uncompressed, hybrid-odd, hybrid-even\n  if ((bytes[0] === 0x04 || bytes[0] === 0x06 || bytes[0] === 0x07) &&\n      bytes.length - 1 === 2 * len) {\n    if (bytes[0] === 0x06)\n      assert(bytes[bytes.length - 1] % 2 === 0);\n    else if (bytes[0] === 0x07)\n      assert(bytes[bytes.length - 1] % 2 === 1);\n\n    var res =  this.point(bytes.slice(1, 1 + len),\n                          bytes.slice(1 + len, 1 + 2 * len));\n\n    return res;\n  } else if ((bytes[0] === 0x02 || bytes[0] === 0x03) &&\n              bytes.length - 1 === len) {\n    return this.pointFromX(bytes.slice(1, 1 + len), bytes[0] === 0x03);\n  }\n  throw new Error('Unknown point format');\n};\n\nBasePoint.prototype.encodeCompressed = function encodeCompressed(enc) {\n  return this.encode(enc, true);\n};\n\nBasePoint.prototype._encode = function _encode(compact) {\n  var len = this.curve.p.byteLength();\n  var x = this.getX().toArray('be', len);\n\n  if (compact)\n    return [ this.getY().isEven() ? 0x02 : 0x03 ].concat(x);\n\n  return [ 0x04 ].concat(x, this.getY().toArray('be', len)) ;\n};\n\nBasePoint.prototype.encode = function encode(enc, compact) {\n  return utils.encode(this._encode(compact), enc);\n};\n\nBasePoint.prototype.precompute = function precompute(power) {\n  if (this.precomputed)\n    return this;\n\n  var precomputed = {\n    doubles: null,\n    naf: null,\n    beta: null\n  };\n  precomputed.naf = this._getNAFPoints(8);\n  precomputed.doubles = this._getDoubles(4, power);\n  precomputed.beta = this._getBeta();\n  this.precomputed = precomputed;\n\n  return this;\n};\n\nBasePoint.prototype._hasDoubles = function _hasDoubles(k) {\n  if (!this.precomputed)\n    return false;\n\n  var doubles = this.precomputed.doubles;\n  if (!doubles)\n    return false;\n\n  return doubles.points.length >= Math.ceil((k.bitLength() + 1) / doubles.step);\n};\n\nBasePoint.prototype._getDoubles = function _getDoubles(step, power) {\n  if (this.precomputed && this.precomputed.doubles)\n    return this.precomputed.doubles;\n\n  var doubles = [ this ];\n  var acc = this;\n  for (var i = 0; i < power; i += step) {\n    for (var j = 0; j < step; j++)\n      acc = acc.dbl();\n    doubles.push(acc);\n  }\n  return {\n    step: step,\n    points: doubles\n  };\n};\n\nBasePoint.prototype._getNAFPoints = function _getNAFPoints(wnd) {\n  if (this.precomputed && this.precomputed.naf)\n    return this.precomputed.naf;\n\n  var res = [ this ];\n  var max = (1 << wnd) - 1;\n  var dbl = max === 1 ? null : this.dbl();\n  for (var i = 1; i < max; i++)\n    res[i] = res[i - 1].add(dbl);\n  return {\n    wnd: wnd,\n    points: res\n  };\n};\n\nBasePoint.prototype._getBeta = function _getBeta() {\n  return null;\n};\n\nBasePoint.prototype.dblp = function dblp(k) {\n  var r = this;\n  for (var i = 0; i < k; i++)\n    r = r.dbl();\n  return r;\n};\n\n\n\n// WEBPACK FOOTER //\n// ./node_modules/elliptic/lib/elliptic/curve/base.js","'use strict';\n\nvar curve = require('../curve');\nvar elliptic = require('../../elliptic');\nvar BN = require('bn.js');\nvar inherits = require('inherits');\nvar Base = curve.base;\n\nvar assert = elliptic.utils.assert;\n\nfunction ShortCurve(conf) {\n  Base.call(this, 'short', conf);\n\n  this.a = new BN(conf.a, 16).toRed(this.red);\n  this.b = new BN(conf.b, 16).toRed(this.red);\n  this.tinv = this.two.redInvm();\n\n  this.zeroA = this.a.fromRed().cmpn(0) === 0;\n  this.threeA = this.a.fromRed().sub(this.p).cmpn(-3) === 0;\n\n  // If the curve is endomorphic, precalculate beta and lambda\n  this.endo = this._getEndomorphism(conf);\n  this._endoWnafT1 = new Array(4);\n  this._endoWnafT2 = new Array(4);\n}\ninherits(ShortCurve, Base);\nmodule.exports = ShortCurve;\n\nShortCurve.prototype._getEndomorphism = function _getEndomorphism(conf) {\n  // No efficient endomorphism\n  if (!this.zeroA || !this.g || !this.n || this.p.modn(3) !== 1)\n    return;\n\n  // Compute beta and lambda, that lambda * P = (beta * Px; Py)\n  var beta;\n  var lambda;\n  if (conf.beta) {\n    beta = new BN(conf.beta, 16).toRed(this.red);\n  } else {\n    var betas = this._getEndoRoots(this.p);\n    // Choose the smallest beta\n    beta = betas[0].cmp(betas[1]) < 0 ? betas[0] : betas[1];\n    beta = beta.toRed(this.red);\n  }\n  if (conf.lambda) {\n    lambda = new BN(conf.lambda, 16);\n  } else {\n    // Choose the lambda that is matching selected beta\n    var lambdas = this._getEndoRoots(this.n);\n    if (this.g.mul(lambdas[0]).x.cmp(this.g.x.redMul(beta)) === 0) {\n      lambda = lambdas[0];\n    } else {\n      lambda = lambdas[1];\n      assert(this.g.mul(lambda).x.cmp(this.g.x.redMul(beta)) === 0);\n    }\n  }\n\n  // Get basis vectors, used for balanced length-two representation\n  var basis;\n  if (conf.basis) {\n    basis = conf.basis.map(function(vec) {\n      return {\n        a: new BN(vec.a, 16),\n        b: new BN(vec.b, 16)\n      };\n    });\n  } else {\n    basis = this._getEndoBasis(lambda);\n  }\n\n  return {\n    beta: beta,\n    lambda: lambda,\n    basis: basis\n  };\n};\n\nShortCurve.prototype._getEndoRoots = function _getEndoRoots(num) {\n  // Find roots of for x^2 + x + 1 in F\n  // Root = (-1 +- Sqrt(-3)) / 2\n  //\n  var red = num === this.p ? this.red : BN.mont(num);\n  var tinv = new BN(2).toRed(red).redInvm();\n  var ntinv = tinv.redNeg();\n\n  var s = new BN(3).toRed(red).redNeg().redSqrt().redMul(tinv);\n\n  var l1 = ntinv.redAdd(s).fromRed();\n  var l2 = ntinv.redSub(s).fromRed();\n  return [ l1, l2 ];\n};\n\nShortCurve.prototype._getEndoBasis = function _getEndoBasis(lambda) {\n  // aprxSqrt >= sqrt(this.n)\n  var aprxSqrt = this.n.ushrn(Math.floor(this.n.bitLength() / 2));\n\n  // 3.74\n  // Run EGCD, until r(L + 1) < aprxSqrt\n  var u = lambda;\n  var v = this.n.clone();\n  var x1 = new BN(1);\n  var y1 = new BN(0);\n  var x2 = new BN(0);\n  var y2 = new BN(1);\n\n  // NOTE: all vectors are roots of: a + b * lambda = 0 (mod n)\n  var a0;\n  var b0;\n  // First vector\n  var a1;\n  var b1;\n  // Second vector\n  var a2;\n  var b2;\n\n  var prevR;\n  var i = 0;\n  var r;\n  var x;\n  while (u.cmpn(0) !== 0) {\n    var q = v.div(u);\n    r = v.sub(q.mul(u));\n    x = x2.sub(q.mul(x1));\n    var y = y2.sub(q.mul(y1));\n\n    if (!a1 && r.cmp(aprxSqrt) < 0) {\n      a0 = prevR.neg();\n      b0 = x1;\n      a1 = r.neg();\n      b1 = x;\n    } else if (a1 && ++i === 2) {\n      break;\n    }\n    prevR = r;\n\n    v = u;\n    u = r;\n    x2 = x1;\n    x1 = x;\n    y2 = y1;\n    y1 = y;\n  }\n  a2 = r.neg();\n  b2 = x;\n\n  var len1 = a1.sqr().add(b1.sqr());\n  var len2 = a2.sqr().add(b2.sqr());\n  if (len2.cmp(len1) >= 0) {\n    a2 = a0;\n    b2 = b0;\n  }\n\n  // Normalize signs\n  if (a1.negative) {\n    a1 = a1.neg();\n    b1 = b1.neg();\n  }\n  if (a2.negative) {\n    a2 = a2.neg();\n    b2 = b2.neg();\n  }\n\n  return [\n    { a: a1, b: b1 },\n    { a: a2, b: b2 }\n  ];\n};\n\nShortCurve.prototype._endoSplit = function _endoSplit(k) {\n  var basis = this.endo.basis;\n  var v1 = basis[0];\n  var v2 = basis[1];\n\n  var c1 = v2.b.mul(k).divRound(this.n);\n  var c2 = v1.b.neg().mul(k).divRound(this.n);\n\n  var p1 = c1.mul(v1.a);\n  var p2 = c2.mul(v2.a);\n  var q1 = c1.mul(v1.b);\n  var q2 = c2.mul(v2.b);\n\n  // Calculate answer\n  var k1 = k.sub(p1).sub(p2);\n  var k2 = q1.add(q2).neg();\n  return { k1: k1, k2: k2 };\n};\n\nShortCurve.prototype.pointFromX = function pointFromX(x, odd) {\n  x = new BN(x, 16);\n  if (!x.red)\n    x = x.toRed(this.red);\n\n  var y2 = x.redSqr().redMul(x).redIAdd(x.redMul(this.a)).redIAdd(this.b);\n  var y = y2.redSqrt();\n  if (y.redSqr().redSub(y2).cmp(this.zero) !== 0)\n    throw new Error('invalid point');\n\n  // XXX Is there any way to tell if the number is odd without converting it\n  // to non-red form?\n  var isOdd = y.fromRed().isOdd();\n  if (odd && !isOdd || !odd && isOdd)\n    y = y.redNeg();\n\n  return this.point(x, y);\n};\n\nShortCurve.prototype.validate = function validate(point) {\n  if (point.inf)\n    return true;\n\n  var x = point.x;\n  var y = point.y;\n\n  var ax = this.a.redMul(x);\n  var rhs = x.redSqr().redMul(x).redIAdd(ax).redIAdd(this.b);\n  return y.redSqr().redISub(rhs).cmpn(0) === 0;\n};\n\nShortCurve.prototype._endoWnafMulAdd =\n    function _endoWnafMulAdd(points, coeffs, jacobianResult) {\n  var npoints = this._endoWnafT1;\n  var ncoeffs = this._endoWnafT2;\n  for (var i = 0; i < points.length; i++) {\n    var split = this._endoSplit(coeffs[i]);\n    var p = points[i];\n    var beta = p._getBeta();\n\n    if (split.k1.negative) {\n      split.k1.ineg();\n      p = p.neg(true);\n    }\n    if (split.k2.negative) {\n      split.k2.ineg();\n      beta = beta.neg(true);\n    }\n\n    npoints[i * 2] = p;\n    npoints[i * 2 + 1] = beta;\n    ncoeffs[i * 2] = split.k1;\n    ncoeffs[i * 2 + 1] = split.k2;\n  }\n  var res = this._wnafMulAdd(1, npoints, ncoeffs, i * 2, jacobianResult);\n\n  // Clean-up references to points and coefficients\n  for (var j = 0; j < i * 2; j++) {\n    npoints[j] = null;\n    ncoeffs[j] = null;\n  }\n  return res;\n};\n\nfunction Point(curve, x, y, isRed) {\n  Base.BasePoint.call(this, curve, 'affine');\n  if (x === null && y === null) {\n    this.x = null;\n    this.y = null;\n    this.inf = true;\n  } else {\n    this.x = new BN(x, 16);\n    this.y = new BN(y, 16);\n    // Force redgomery representation when loading from JSON\n    if (isRed) {\n      this.x.forceRed(this.curve.red);\n      this.y.forceRed(this.curve.red);\n    }\n    if (!this.x.red)\n      this.x = this.x.toRed(this.curve.red);\n    if (!this.y.red)\n      this.y = this.y.toRed(this.curve.red);\n    this.inf = false;\n  }\n}\ninherits(Point, Base.BasePoint);\n\nShortCurve.prototype.point = function point(x, y, isRed) {\n  return new Point(this, x, y, isRed);\n};\n\nShortCurve.prototype.pointFromJSON = function pointFromJSON(obj, red) {\n  return Point.fromJSON(this, obj, red);\n};\n\nPoint.prototype._getBeta = function _getBeta() {\n  if (!this.curve.endo)\n    return;\n\n  var pre = this.precomputed;\n  if (pre && pre.beta)\n    return pre.beta;\n\n  var beta = this.curve.point(this.x.redMul(this.curve.endo.beta), this.y);\n  if (pre) {\n    var curve = this.curve;\n    var endoMul = function(p) {\n      return curve.point(p.x.redMul(curve.endo.beta), p.y);\n    };\n    pre.beta = beta;\n    beta.precomputed = {\n      beta: null,\n      naf: pre.naf && {\n        wnd: pre.naf.wnd,\n        points: pre.naf.points.map(endoMul)\n      },\n      doubles: pre.doubles && {\n        step: pre.doubles.step,\n        points: pre.doubles.points.map(endoMul)\n      }\n    };\n  }\n  return beta;\n};\n\nPoint.prototype.toJSON = function toJSON() {\n  if (!this.precomputed)\n    return [ this.x, this.y ];\n\n  return [ this.x, this.y, this.precomputed && {\n    doubles: this.precomputed.doubles && {\n      step: this.precomputed.doubles.step,\n      points: this.precomputed.doubles.points.slice(1)\n    },\n    naf: this.precomputed.naf && {\n      wnd: this.precomputed.naf.wnd,\n      points: this.precomputed.naf.points.slice(1)\n    }\n  } ];\n};\n\nPoint.fromJSON = function fromJSON(curve, obj, red) {\n  if (typeof obj === 'string')\n    obj = JSON.parse(obj);\n  var res = curve.point(obj[0], obj[1], red);\n  if (!obj[2])\n    return res;\n\n  function obj2point(obj) {\n    return curve.point(obj[0], obj[1], red);\n  }\n\n  var pre = obj[2];\n  res.precomputed = {\n    beta: null,\n    doubles: pre.doubles && {\n      step: pre.doubles.step,\n      points: [ res ].concat(pre.doubles.points.map(obj2point))\n    },\n    naf: pre.naf && {\n      wnd: pre.naf.wnd,\n      points: [ res ].concat(pre.naf.points.map(obj2point))\n    }\n  };\n  return res;\n};\n\nPoint.prototype.inspect = function inspect() {\n  if (this.isInfinity())\n    return '<EC Point Infinity>';\n  return '<EC Point x: ' + this.x.fromRed().toString(16, 2) +\n      ' y: ' + this.y.fromRed().toString(16, 2) + '>';\n};\n\nPoint.prototype.isInfinity = function isInfinity() {\n  return this.inf;\n};\n\nPoint.prototype.add = function add(p) {\n  // O + P = P\n  if (this.inf)\n    return p;\n\n  // P + O = P\n  if (p.inf)\n    return this;\n\n  // P + P = 2P\n  if (this.eq(p))\n    return this.dbl();\n\n  // P + (-P) = O\n  if (this.neg().eq(p))\n    return this.curve.point(null, null);\n\n  // P + Q = O\n  if (this.x.cmp(p.x) === 0)\n    return this.curve.point(null, null);\n\n  var c = this.y.redSub(p.y);\n  if (c.cmpn(0) !== 0)\n    c = c.redMul(this.x.redSub(p.x).redInvm());\n  var nx = c.redSqr().redISub(this.x).redISub(p.x);\n  var ny = c.redMul(this.x.redSub(nx)).redISub(this.y);\n  return this.curve.point(nx, ny);\n};\n\nPoint.prototype.dbl = function dbl() {\n  if (this.inf)\n    return this;\n\n  // 2P = O\n  var ys1 = this.y.redAdd(this.y);\n  if (ys1.cmpn(0) === 0)\n    return this.curve.point(null, null);\n\n  var a = this.curve.a;\n\n  var x2 = this.x.redSqr();\n  var dyinv = ys1.redInvm();\n  var c = x2.redAdd(x2).redIAdd(x2).redIAdd(a).redMul(dyinv);\n\n  var nx = c.redSqr().redISub(this.x.redAdd(this.x));\n  var ny = c.redMul(this.x.redSub(nx)).redISub(this.y);\n  return this.curve.point(nx, ny);\n};\n\nPoint.prototype.getX = function getX() {\n  return this.x.fromRed();\n};\n\nPoint.prototype.getY = function getY() {\n  return this.y.fromRed();\n};\n\nPoint.prototype.mul = function mul(k) {\n  k = new BN(k, 16);\n\n  if (this._hasDoubles(k))\n    return this.curve._fixedNafMul(this, k);\n  else if (this.curve.endo)\n    return this.curve._endoWnafMulAdd([ this ], [ k ]);\n  else\n    return this.curve._wnafMul(this, k);\n};\n\nPoint.prototype.mulAdd = function mulAdd(k1, p2, k2) {\n  var points = [ this, p2 ];\n  var coeffs = [ k1, k2 ];\n  if (this.curve.endo)\n    return this.curve._endoWnafMulAdd(points, coeffs);\n  else\n    return this.curve._wnafMulAdd(1, points, coeffs, 2);\n};\n\nPoint.prototype.jmulAdd = function jmulAdd(k1, p2, k2) {\n  var points = [ this, p2 ];\n  var coeffs = [ k1, k2 ];\n  if (this.curve.endo)\n    return this.curve._endoWnafMulAdd(points, coeffs, true);\n  else\n    return this.curve._wnafMulAdd(1, points, coeffs, 2, true);\n};\n\nPoint.prototype.eq = function eq(p) {\n  return this === p ||\n         this.inf === p.inf &&\n             (this.inf || this.x.cmp(p.x) === 0 && this.y.cmp(p.y) === 0);\n};\n\nPoint.prototype.neg = function neg(_precompute) {\n  if (this.inf)\n    return this;\n\n  var res = this.curve.point(this.x, this.y.redNeg());\n  if (_precompute && this.precomputed) {\n    var pre = this.precomputed;\n    var negate = function(p) {\n      return p.neg();\n    };\n    res.precomputed = {\n      naf: pre.naf && {\n        wnd: pre.naf.wnd,\n        points: pre.naf.points.map(negate)\n      },\n      doubles: pre.doubles && {\n        step: pre.doubles.step,\n        points: pre.doubles.points.map(negate)\n      }\n    };\n  }\n  return res;\n};\n\nPoint.prototype.toJ = function toJ() {\n  if (this.inf)\n    return this.curve.jpoint(null, null, null);\n\n  var res = this.curve.jpoint(this.x, this.y, this.curve.one);\n  return res;\n};\n\nfunction JPoint(curve, x, y, z) {\n  Base.BasePoint.call(this, curve, 'jacobian');\n  if (x === null && y === null && z === null) {\n    this.x = this.curve.one;\n    this.y = this.curve.one;\n    this.z = new BN(0);\n  } else {\n    this.x = new BN(x, 16);\n    this.y = new BN(y, 16);\n    this.z = new BN(z, 16);\n  }\n  if (!this.x.red)\n    this.x = this.x.toRed(this.curve.red);\n  if (!this.y.red)\n    this.y = this.y.toRed(this.curve.red);\n  if (!this.z.red)\n    this.z = this.z.toRed(this.curve.red);\n\n  this.zOne = this.z === this.curve.one;\n}\ninherits(JPoint, Base.BasePoint);\n\nShortCurve.prototype.jpoint = function jpoint(x, y, z) {\n  return new JPoint(this, x, y, z);\n};\n\nJPoint.prototype.toP = function toP() {\n  if (this.isInfinity())\n    return this.curve.point(null, null);\n\n  var zinv = this.z.redInvm();\n  var zinv2 = zinv.redSqr();\n  var ax = this.x.redMul(zinv2);\n  var ay = this.y.redMul(zinv2).redMul(zinv);\n\n  return this.curve.point(ax, ay);\n};\n\nJPoint.prototype.neg = function neg() {\n  return this.curve.jpoint(this.x, this.y.redNeg(), this.z);\n};\n\nJPoint.prototype.add = function add(p) {\n  // O + P = P\n  if (this.isInfinity())\n    return p;\n\n  // P + O = P\n  if (p.isInfinity())\n    return this;\n\n  // 12M + 4S + 7A\n  var pz2 = p.z.redSqr();\n  var z2 = this.z.redSqr();\n  var u1 = this.x.redMul(pz2);\n  var u2 = p.x.redMul(z2);\n  var s1 = this.y.redMul(pz2.redMul(p.z));\n  var s2 = p.y.redMul(z2.redMul(this.z));\n\n  var h = u1.redSub(u2);\n  var r = s1.redSub(s2);\n  if (h.cmpn(0) === 0) {\n    if (r.cmpn(0) !== 0)\n      return this.curve.jpoint(null, null, null);\n    else\n      return this.dbl();\n  }\n\n  var h2 = h.redSqr();\n  var h3 = h2.redMul(h);\n  var v = u1.redMul(h2);\n\n  var nx = r.redSqr().redIAdd(h3).redISub(v).redISub(v);\n  var ny = r.redMul(v.redISub(nx)).redISub(s1.redMul(h3));\n  var nz = this.z.redMul(p.z).redMul(h);\n\n  return this.curve.jpoint(nx, ny, nz);\n};\n\nJPoint.prototype.mixedAdd = function mixedAdd(p) {\n  // O + P = P\n  if (this.isInfinity())\n    return p.toJ();\n\n  // P + O = P\n  if (p.isInfinity())\n    return this;\n\n  // 8M + 3S + 7A\n  var z2 = this.z.redSqr();\n  var u1 = this.x;\n  var u2 = p.x.redMul(z2);\n  var s1 = this.y;\n  var s2 = p.y.redMul(z2).redMul(this.z);\n\n  var h = u1.redSub(u2);\n  var r = s1.redSub(s2);\n  if (h.cmpn(0) === 0) {\n    if (r.cmpn(0) !== 0)\n      return this.curve.jpoint(null, null, null);\n    else\n      return this.dbl();\n  }\n\n  var h2 = h.redSqr();\n  var h3 = h2.redMul(h);\n  var v = u1.redMul(h2);\n\n  var nx = r.redSqr().redIAdd(h3).redISub(v).redISub(v);\n  var ny = r.redMul(v.redISub(nx)).redISub(s1.redMul(h3));\n  var nz = this.z.redMul(h);\n\n  return this.curve.jpoint(nx, ny, nz);\n};\n\nJPoint.prototype.dblp = function dblp(pow) {\n  if (pow === 0)\n    return this;\n  if (this.isInfinity())\n    return this;\n  if (!pow)\n    return this.dbl();\n\n  if (this.curve.zeroA || this.curve.threeA) {\n    var r = this;\n    for (var i = 0; i < pow; i++)\n      r = r.dbl();\n    return r;\n  }\n\n  // 1M + 2S + 1A + N * (4S + 5M + 8A)\n  // N = 1 => 6M + 6S + 9A\n  var a = this.curve.a;\n  var tinv = this.curve.tinv;\n\n  var jx = this.x;\n  var jy = this.y;\n  var jz = this.z;\n  var jz4 = jz.redSqr().redSqr();\n\n  // Reuse results\n  var jyd = jy.redAdd(jy);\n  for (var i = 0; i < pow; i++) {\n    var jx2 = jx.redSqr();\n    var jyd2 = jyd.redSqr();\n    var jyd4 = jyd2.redSqr();\n    var c = jx2.redAdd(jx2).redIAdd(jx2).redIAdd(a.redMul(jz4));\n\n    var t1 = jx.redMul(jyd2);\n    var nx = c.redSqr().redISub(t1.redAdd(t1));\n    var t2 = t1.redISub(nx);\n    var dny = c.redMul(t2);\n    dny = dny.redIAdd(dny).redISub(jyd4);\n    var nz = jyd.redMul(jz);\n    if (i + 1 < pow)\n      jz4 = jz4.redMul(jyd4);\n\n    jx = nx;\n    jz = nz;\n    jyd = dny;\n  }\n\n  return this.curve.jpoint(jx, jyd.redMul(tinv), jz);\n};\n\nJPoint.prototype.dbl = function dbl() {\n  if (this.isInfinity())\n    return this;\n\n  if (this.curve.zeroA)\n    return this._zeroDbl();\n  else if (this.curve.threeA)\n    return this._threeDbl();\n  else\n    return this._dbl();\n};\n\nJPoint.prototype._zeroDbl = function _zeroDbl() {\n  var nx;\n  var ny;\n  var nz;\n  // Z = 1\n  if (this.zOne) {\n    // hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-0.html\n    //     #doubling-mdbl-2007-bl\n    // 1M + 5S + 14A\n\n    // XX = X1^2\n    var xx = this.x.redSqr();\n    // YY = Y1^2\n    var yy = this.y.redSqr();\n    // YYYY = YY^2\n    var yyyy = yy.redSqr();\n    // S = 2 * ((X1 + YY)^2 - XX - YYYY)\n    var s = this.x.redAdd(yy).redSqr().redISub(xx).redISub(yyyy);\n    s = s.redIAdd(s);\n    // M = 3 * XX + a; a = 0\n    var m = xx.redAdd(xx).redIAdd(xx);\n    // T = M ^ 2 - 2*S\n    var t = m.redSqr().redISub(s).redISub(s);\n\n    // 8 * YYYY\n    var yyyy8 = yyyy.redIAdd(yyyy);\n    yyyy8 = yyyy8.redIAdd(yyyy8);\n    yyyy8 = yyyy8.redIAdd(yyyy8);\n\n    // X3 = T\n    nx = t;\n    // Y3 = M * (S - T) - 8 * YYYY\n    ny = m.redMul(s.redISub(t)).redISub(yyyy8);\n    // Z3 = 2*Y1\n    nz = this.y.redAdd(this.y);\n  } else {\n    // hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-0.html\n    //     #doubling-dbl-2009-l\n    // 2M + 5S + 13A\n\n    // A = X1^2\n    var a = this.x.redSqr();\n    // B = Y1^2\n    var b = this.y.redSqr();\n    // C = B^2\n    var c = b.redSqr();\n    // D = 2 * ((X1 + B)^2 - A - C)\n    var d = this.x.redAdd(b).redSqr().redISub(a).redISub(c);\n    d = d.redIAdd(d);\n    // E = 3 * A\n    var e = a.redAdd(a).redIAdd(a);\n    // F = E^2\n    var f = e.redSqr();\n\n    // 8 * C\n    var c8 = c.redIAdd(c);\n    c8 = c8.redIAdd(c8);\n    c8 = c8.redIAdd(c8);\n\n    // X3 = F - 2 * D\n    nx = f.redISub(d).redISub(d);\n    // Y3 = E * (D - X3) - 8 * C\n    ny = e.redMul(d.redISub(nx)).redISub(c8);\n    // Z3 = 2 * Y1 * Z1\n    nz = this.y.redMul(this.z);\n    nz = nz.redIAdd(nz);\n  }\n\n  return this.curve.jpoint(nx, ny, nz);\n};\n\nJPoint.prototype._threeDbl = function _threeDbl() {\n  var nx;\n  var ny;\n  var nz;\n  // Z = 1\n  if (this.zOne) {\n    // hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-3.html\n    //     #doubling-mdbl-2007-bl\n    // 1M + 5S + 15A\n\n    // XX = X1^2\n    var xx = this.x.redSqr();\n    // YY = Y1^2\n    var yy = this.y.redSqr();\n    // YYYY = YY^2\n    var yyyy = yy.redSqr();\n    // S = 2 * ((X1 + YY)^2 - XX - YYYY)\n    var s = this.x.redAdd(yy).redSqr().redISub(xx).redISub(yyyy);\n    s = s.redIAdd(s);\n    // M = 3 * XX + a\n    var m = xx.redAdd(xx).redIAdd(xx).redIAdd(this.curve.a);\n    // T = M^2 - 2 * S\n    var t = m.redSqr().redISub(s).redISub(s);\n    // X3 = T\n    nx = t;\n    // Y3 = M * (S - T) - 8 * YYYY\n    var yyyy8 = yyyy.redIAdd(yyyy);\n    yyyy8 = yyyy8.redIAdd(yyyy8);\n    yyyy8 = yyyy8.redIAdd(yyyy8);\n    ny = m.redMul(s.redISub(t)).redISub(yyyy8);\n    // Z3 = 2 * Y1\n    nz = this.y.redAdd(this.y);\n  } else {\n    // hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-3.html#doubling-dbl-2001-b\n    // 3M + 5S\n\n    // delta = Z1^2\n    var delta = this.z.redSqr();\n    // gamma = Y1^2\n    var gamma = this.y.redSqr();\n    // beta = X1 * gamma\n    var beta = this.x.redMul(gamma);\n    // alpha = 3 * (X1 - delta) * (X1 + delta)\n    var alpha = this.x.redSub(delta).redMul(this.x.redAdd(delta));\n    alpha = alpha.redAdd(alpha).redIAdd(alpha);\n    // X3 = alpha^2 - 8 * beta\n    var beta4 = beta.redIAdd(beta);\n    beta4 = beta4.redIAdd(beta4);\n    var beta8 = beta4.redAdd(beta4);\n    nx = alpha.redSqr().redISub(beta8);\n    // Z3 = (Y1 + Z1)^2 - gamma - delta\n    nz = this.y.redAdd(this.z).redSqr().redISub(gamma).redISub(delta);\n    // Y3 = alpha * (4 * beta - X3) - 8 * gamma^2\n    var ggamma8 = gamma.redSqr();\n    ggamma8 = ggamma8.redIAdd(ggamma8);\n    ggamma8 = ggamma8.redIAdd(ggamma8);\n    ggamma8 = ggamma8.redIAdd(ggamma8);\n    ny = alpha.redMul(beta4.redISub(nx)).redISub(ggamma8);\n  }\n\n  return this.curve.jpoint(nx, ny, nz);\n};\n\nJPoint.prototype._dbl = function _dbl() {\n  var a = this.curve.a;\n\n  // 4M + 6S + 10A\n  var jx = this.x;\n  var jy = this.y;\n  var jz = this.z;\n  var jz4 = jz.redSqr().redSqr();\n\n  var jx2 = jx.redSqr();\n  var jy2 = jy.redSqr();\n\n  var c = jx2.redAdd(jx2).redIAdd(jx2).redIAdd(a.redMul(jz4));\n\n  var jxd4 = jx.redAdd(jx);\n  jxd4 = jxd4.redIAdd(jxd4);\n  var t1 = jxd4.redMul(jy2);\n  var nx = c.redSqr().redISub(t1.redAdd(t1));\n  var t2 = t1.redISub(nx);\n\n  var jyd8 = jy2.redSqr();\n  jyd8 = jyd8.redIAdd(jyd8);\n  jyd8 = jyd8.redIAdd(jyd8);\n  jyd8 = jyd8.redIAdd(jyd8);\n  var ny = c.redMul(t2).redISub(jyd8);\n  var nz = jy.redAdd(jy).redMul(jz);\n\n  return this.curve.jpoint(nx, ny, nz);\n};\n\nJPoint.prototype.trpl = function trpl() {\n  if (!this.curve.zeroA)\n    return this.dbl().add(this);\n\n  // hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-0.html#tripling-tpl-2007-bl\n  // 5M + 10S + ...\n\n  // XX = X1^2\n  var xx = this.x.redSqr();\n  // YY = Y1^2\n  var yy = this.y.redSqr();\n  // ZZ = Z1^2\n  var zz = this.z.redSqr();\n  // YYYY = YY^2\n  var yyyy = yy.redSqr();\n  // M = 3 * XX + a * ZZ2; a = 0\n  var m = xx.redAdd(xx).redIAdd(xx);\n  // MM = M^2\n  var mm = m.redSqr();\n  // E = 6 * ((X1 + YY)^2 - XX - YYYY) - MM\n  var e = this.x.redAdd(yy).redSqr().redISub(xx).redISub(yyyy);\n  e = e.redIAdd(e);\n  e = e.redAdd(e).redIAdd(e);\n  e = e.redISub(mm);\n  // EE = E^2\n  var ee = e.redSqr();\n  // T = 16*YYYY\n  var t = yyyy.redIAdd(yyyy);\n  t = t.redIAdd(t);\n  t = t.redIAdd(t);\n  t = t.redIAdd(t);\n  // U = (M + E)^2 - MM - EE - T\n  var u = m.redIAdd(e).redSqr().redISub(mm).redISub(ee).redISub(t);\n  // X3 = 4 * (X1 * EE - 4 * YY * U)\n  var yyu4 = yy.redMul(u);\n  yyu4 = yyu4.redIAdd(yyu4);\n  yyu4 = yyu4.redIAdd(yyu4);\n  var nx = this.x.redMul(ee).redISub(yyu4);\n  nx = nx.redIAdd(nx);\n  nx = nx.redIAdd(nx);\n  // Y3 = 8 * Y1 * (U * (T - U) - E * EE)\n  var ny = this.y.redMul(u.redMul(t.redISub(u)).redISub(e.redMul(ee)));\n  ny = ny.redIAdd(ny);\n  ny = ny.redIAdd(ny);\n  ny = ny.redIAdd(ny);\n  // Z3 = (Z1 + E)^2 - ZZ - EE\n  var nz = this.z.redAdd(e).redSqr().redISub(zz).redISub(ee);\n\n  return this.curve.jpoint(nx, ny, nz);\n};\n\nJPoint.prototype.mul = function mul(k, kbase) {\n  k = new BN(k, kbase);\n\n  return this.curve._wnafMul(this, k);\n};\n\nJPoint.prototype.eq = function eq(p) {\n  if (p.type === 'affine')\n    return this.eq(p.toJ());\n\n  if (this === p)\n    return true;\n\n  // x1 * z2^2 == x2 * z1^2\n  var z2 = this.z.redSqr();\n  var pz2 = p.z.redSqr();\n  if (this.x.redMul(pz2).redISub(p.x.redMul(z2)).cmpn(0) !== 0)\n    return false;\n\n  // y1 * z2^3 == y2 * z1^3\n  var z3 = z2.redMul(this.z);\n  var pz3 = pz2.redMul(p.z);\n  return this.y.redMul(pz3).redISub(p.y.redMul(z3)).cmpn(0) === 0;\n};\n\nJPoint.prototype.eqXToP = function eqXToP(x) {\n  var zs = this.z.redSqr();\n  var rx = x.toRed(this.curve.red).redMul(zs);\n  if (this.x.cmp(rx) === 0)\n    return true;\n\n  var xc = x.clone();\n  var t = this.curve.redN.redMul(zs);\n  for (;;) {\n    xc.iadd(this.curve.n);\n    if (xc.cmp(this.curve.p) >= 0)\n      return false;\n\n    rx.redIAdd(t);\n    if (this.x.cmp(rx) === 0)\n      return true;\n  }\n  return false;\n};\n\nJPoint.prototype.inspect = function inspect() {\n  if (this.isInfinity())\n    return '<EC JPoint Infinity>';\n  return '<EC JPoint x: ' + this.x.toString(16, 2) +\n      ' y: ' + this.y.toString(16, 2) +\n      ' z: ' + this.z.toString(16, 2) + '>';\n};\n\nJPoint.prototype.isInfinity = function isInfinity() {\n  // XXX This code assumes that zero is always zero in red\n  return this.z.cmpn(0) === 0;\n};\n\n\n\n// WEBPACK FOOTER //\n// ./node_modules/elliptic/lib/elliptic/curve/short.js","'use strict';\n\nvar curve = require('../curve');\nvar BN = require('bn.js');\nvar inherits = require('inherits');\nvar Base = curve.base;\n\nvar elliptic = require('../../elliptic');\nvar utils = elliptic.utils;\n\nfunction MontCurve(conf) {\n  Base.call(this, 'mont', conf);\n\n  this.a = new BN(conf.a, 16).toRed(this.red);\n  this.b = new BN(conf.b, 16).toRed(this.red);\n  this.i4 = new BN(4).toRed(this.red).redInvm();\n  this.two = new BN(2).toRed(this.red);\n  this.a24 = this.i4.redMul(this.a.redAdd(this.two));\n}\ninherits(MontCurve, Base);\nmodule.exports = MontCurve;\n\nMontCurve.prototype.validate = function validate(point) {\n  var x = point.normalize().x;\n  var x2 = x.redSqr();\n  var rhs = x2.redMul(x).redAdd(x2.redMul(this.a)).redAdd(x);\n  var y = rhs.redSqrt();\n\n  return y.redSqr().cmp(rhs) === 0;\n};\n\nfunction Point(curve, x, z) {\n  Base.BasePoint.call(this, curve, 'projective');\n  if (x === null && z === null) {\n    this.x = this.curve.one;\n    this.z = this.curve.zero;\n  } else {\n    this.x = new BN(x, 16);\n    this.z = new BN(z, 16);\n    if (!this.x.red)\n      this.x = this.x.toRed(this.curve.red);\n    if (!this.z.red)\n      this.z = this.z.toRed(this.curve.red);\n  }\n}\ninherits(Point, Base.BasePoint);\n\nMontCurve.prototype.decodePoint = function decodePoint(bytes, enc) {\n  return this.point(utils.toArray(bytes, enc), 1);\n};\n\nMontCurve.prototype.point = function point(x, z) {\n  return new Point(this, x, z);\n};\n\nMontCurve.prototype.pointFromJSON = function pointFromJSON(obj) {\n  return Point.fromJSON(this, obj);\n};\n\nPoint.prototype.precompute = function precompute() {\n  // No-op\n};\n\nPoint.prototype._encode = function _encode() {\n  return this.getX().toArray('be', this.curve.p.byteLength());\n};\n\nPoint.fromJSON = function fromJSON(curve, obj) {\n  return new Point(curve, obj[0], obj[1] || curve.one);\n};\n\nPoint.prototype.inspect = function inspect() {\n  if (this.isInfinity())\n    return '<EC Point Infinity>';\n  return '<EC Point x: ' + this.x.fromRed().toString(16, 2) +\n      ' z: ' + this.z.fromRed().toString(16, 2) + '>';\n};\n\nPoint.prototype.isInfinity = function isInfinity() {\n  // XXX This code assumes that zero is always zero in red\n  return this.z.cmpn(0) === 0;\n};\n\nPoint.prototype.dbl = function dbl() {\n  // http://hyperelliptic.org/EFD/g1p/auto-montgom-xz.html#doubling-dbl-1987-m-3\n  // 2M + 2S + 4A\n\n  // A = X1 + Z1\n  var a = this.x.redAdd(this.z);\n  // AA = A^2\n  var aa = a.redSqr();\n  // B = X1 - Z1\n  var b = this.x.redSub(this.z);\n  // BB = B^2\n  var bb = b.redSqr();\n  // C = AA - BB\n  var c = aa.redSub(bb);\n  // X3 = AA * BB\n  var nx = aa.redMul(bb);\n  // Z3 = C * (BB + A24 * C)\n  var nz = c.redMul(bb.redAdd(this.curve.a24.redMul(c)));\n  return this.curve.point(nx, nz);\n};\n\nPoint.prototype.add = function add() {\n  throw new Error('Not supported on Montgomery curve');\n};\n\nPoint.prototype.diffAdd = function diffAdd(p, diff) {\n  // http://hyperelliptic.org/EFD/g1p/auto-montgom-xz.html#diffadd-dadd-1987-m-3\n  // 4M + 2S + 6A\n\n  // A = X2 + Z2\n  var a = this.x.redAdd(this.z);\n  // B = X2 - Z2\n  var b = this.x.redSub(this.z);\n  // C = X3 + Z3\n  var c = p.x.redAdd(p.z);\n  // D = X3 - Z3\n  var d = p.x.redSub(p.z);\n  // DA = D * A\n  var da = d.redMul(a);\n  // CB = C * B\n  var cb = c.redMul(b);\n  // X5 = Z1 * (DA + CB)^2\n  var nx = diff.z.redMul(da.redAdd(cb).redSqr());\n  // Z5 = X1 * (DA - CB)^2\n  var nz = diff.x.redMul(da.redISub(cb).redSqr());\n  return this.curve.point(nx, nz);\n};\n\nPoint.prototype.mul = function mul(k) {\n  var t = k.clone();\n  var a = this; // (N / 2) * Q + Q\n  var b = this.curve.point(null, null); // (N / 2) * Q\n  var c = this; // Q\n\n  for (var bits = []; t.cmpn(0) !== 0; t.iushrn(1))\n    bits.push(t.andln(1));\n\n  for (var i = bits.length - 1; i >= 0; i--) {\n    if (bits[i] === 0) {\n      // N * Q + Q = ((N / 2) * Q + Q)) + (N / 2) * Q\n      a = a.diffAdd(b, c);\n      // N * Q = 2 * ((N / 2) * Q + Q))\n      b = b.dbl();\n    } else {\n      // N * Q = ((N / 2) * Q + Q) + ((N / 2) * Q)\n      b = a.diffAdd(b, c);\n      // N * Q + Q = 2 * ((N / 2) * Q + Q)\n      a = a.dbl();\n    }\n  }\n  return b;\n};\n\nPoint.prototype.mulAdd = function mulAdd() {\n  throw new Error('Not supported on Montgomery curve');\n};\n\nPoint.prototype.jumlAdd = function jumlAdd() {\n  throw new Error('Not supported on Montgomery curve');\n};\n\nPoint.prototype.eq = function eq(other) {\n  return this.getX().cmp(other.getX()) === 0;\n};\n\nPoint.prototype.normalize = function normalize() {\n  this.x = this.x.redMul(this.z.redInvm());\n  this.z = this.curve.one;\n  return this;\n};\n\nPoint.prototype.getX = function getX() {\n  // Normalize coordinates\n  this.normalize();\n\n  return this.x.fromRed();\n};\n\n\n\n// WEBPACK FOOTER //\n// ./node_modules/elliptic/lib/elliptic/curve/mont.js","'use strict';\n\nvar curve = require('../curve');\nvar elliptic = require('../../elliptic');\nvar BN = require('bn.js');\nvar inherits = require('inherits');\nvar Base = curve.base;\n\nvar assert = elliptic.utils.assert;\n\nfunction EdwardsCurve(conf) {\n  // NOTE: Important as we are creating point in Base.call()\n  this.twisted = (conf.a | 0) !== 1;\n  this.mOneA = this.twisted && (conf.a | 0) === -1;\n  this.extended = this.mOneA;\n\n  Base.call(this, 'edwards', conf);\n\n  this.a = new BN(conf.a, 16).umod(this.red.m);\n  this.a = this.a.toRed(this.red);\n  this.c = new BN(conf.c, 16).toRed(this.red);\n  this.c2 = this.c.redSqr();\n  this.d = new BN(conf.d, 16).toRed(this.red);\n  this.dd = this.d.redAdd(this.d);\n\n  assert(!this.twisted || this.c.fromRed().cmpn(1) === 0);\n  this.oneC = (conf.c | 0) === 1;\n}\ninherits(EdwardsCurve, Base);\nmodule.exports = EdwardsCurve;\n\nEdwardsCurve.prototype._mulA = function _mulA(num) {\n  if (this.mOneA)\n    return num.redNeg();\n  else\n    return this.a.redMul(num);\n};\n\nEdwardsCurve.prototype._mulC = function _mulC(num) {\n  if (this.oneC)\n    return num;\n  else\n    return this.c.redMul(num);\n};\n\n// Just for compatibility with Short curve\nEdwardsCurve.prototype.jpoint = function jpoint(x, y, z, t) {\n  return this.point(x, y, z, t);\n};\n\nEdwardsCurve.prototype.pointFromX = function pointFromX(x, odd) {\n  x = new BN(x, 16);\n  if (!x.red)\n    x = x.toRed(this.red);\n\n  var x2 = x.redSqr();\n  var rhs = this.c2.redSub(this.a.redMul(x2));\n  var lhs = this.one.redSub(this.c2.redMul(this.d).redMul(x2));\n\n  var y2 = rhs.redMul(lhs.redInvm());\n  var y = y2.redSqrt();\n  if (y.redSqr().redSub(y2).cmp(this.zero) !== 0)\n    throw new Error('invalid point');\n\n  var isOdd = y.fromRed().isOdd();\n  if (odd && !isOdd || !odd && isOdd)\n    y = y.redNeg();\n\n  return this.point(x, y);\n};\n\nEdwardsCurve.prototype.pointFromY = function pointFromY(y, odd) {\n  y = new BN(y, 16);\n  if (!y.red)\n    y = y.toRed(this.red);\n\n  // x^2 = (y^2 - 1) / (d y^2 + 1)\n  var y2 = y.redSqr();\n  var lhs = y2.redSub(this.one);\n  var rhs = y2.redMul(this.d).redAdd(this.one);\n  var x2 = lhs.redMul(rhs.redInvm());\n\n  if (x2.cmp(this.zero) === 0) {\n    if (odd)\n      throw new Error('invalid point');\n    else\n      return this.point(this.zero, y);\n  }\n\n  var x = x2.redSqrt();\n  if (x.redSqr().redSub(x2).cmp(this.zero) !== 0)\n    throw new Error('invalid point');\n\n  if (x.isOdd() !== odd)\n    x = x.redNeg();\n\n  return this.point(x, y);\n};\n\nEdwardsCurve.prototype.validate = function validate(point) {\n  if (point.isInfinity())\n    return true;\n\n  // Curve: A * X^2 + Y^2 = C^2 * (1 + D * X^2 * Y^2)\n  point.normalize();\n\n  var x2 = point.x.redSqr();\n  var y2 = point.y.redSqr();\n  var lhs = x2.redMul(this.a).redAdd(y2);\n  var rhs = this.c2.redMul(this.one.redAdd(this.d.redMul(x2).redMul(y2)));\n\n  return lhs.cmp(rhs) === 0;\n};\n\nfunction Point(curve, x, y, z, t) {\n  Base.BasePoint.call(this, curve, 'projective');\n  if (x === null && y === null && z === null) {\n    this.x = this.curve.zero;\n    this.y = this.curve.one;\n    this.z = this.curve.one;\n    this.t = this.curve.zero;\n    this.zOne = true;\n  } else {\n    this.x = new BN(x, 16);\n    this.y = new BN(y, 16);\n    this.z = z ? new BN(z, 16) : this.curve.one;\n    this.t = t && new BN(t, 16);\n    if (!this.x.red)\n      this.x = this.x.toRed(this.curve.red);\n    if (!this.y.red)\n      this.y = this.y.toRed(this.curve.red);\n    if (!this.z.red)\n      this.z = this.z.toRed(this.curve.red);\n    if (this.t && !this.t.red)\n      this.t = this.t.toRed(this.curve.red);\n    this.zOne = this.z === this.curve.one;\n\n    // Use extended coordinates\n    if (this.curve.extended && !this.t) {\n      this.t = this.x.redMul(this.y);\n      if (!this.zOne)\n        this.t = this.t.redMul(this.z.redInvm());\n    }\n  }\n}\ninherits(Point, Base.BasePoint);\n\nEdwardsCurve.prototype.pointFromJSON = function pointFromJSON(obj) {\n  return Point.fromJSON(this, obj);\n};\n\nEdwardsCurve.prototype.point = function point(x, y, z, t) {\n  return new Point(this, x, y, z, t);\n};\n\nPoint.fromJSON = function fromJSON(curve, obj) {\n  return new Point(curve, obj[0], obj[1], obj[2]);\n};\n\nPoint.prototype.inspect = function inspect() {\n  if (this.isInfinity())\n    return '<EC Point Infinity>';\n  return '<EC Point x: ' + this.x.fromRed().toString(16, 2) +\n      ' y: ' + this.y.fromRed().toString(16, 2) +\n      ' z: ' + this.z.fromRed().toString(16, 2) + '>';\n};\n\nPoint.prototype.isInfinity = function isInfinity() {\n  // XXX This code assumes that zero is always zero in red\n  return this.x.cmpn(0) === 0 &&\n         this.y.cmp(this.z) === 0;\n};\n\nPoint.prototype._extDbl = function _extDbl() {\n  // hyperelliptic.org/EFD/g1p/auto-twisted-extended-1.html\n  //     #doubling-dbl-2008-hwcd\n  // 4M + 4S\n\n  // A = X1^2\n  var a = this.x.redSqr();\n  // B = Y1^2\n  var b = this.y.redSqr();\n  // C = 2 * Z1^2\n  var c = this.z.redSqr();\n  c = c.redIAdd(c);\n  // D = a * A\n  var d = this.curve._mulA(a);\n  // E = (X1 + Y1)^2 - A - B\n  var e = this.x.redAdd(this.y).redSqr().redISub(a).redISub(b);\n  // G = D + B\n  var g = d.redAdd(b);\n  // F = G - C\n  var f = g.redSub(c);\n  // H = D - B\n  var h = d.redSub(b);\n  // X3 = E * F\n  var nx = e.redMul(f);\n  // Y3 = G * H\n  var ny = g.redMul(h);\n  // T3 = E * H\n  var nt = e.redMul(h);\n  // Z3 = F * G\n  var nz = f.redMul(g);\n  return this.curve.point(nx, ny, nz, nt);\n};\n\nPoint.prototype._projDbl = function _projDbl() {\n  // hyperelliptic.org/EFD/g1p/auto-twisted-projective.html\n  //     #doubling-dbl-2008-bbjlp\n  //     #doubling-dbl-2007-bl\n  // and others\n  // Generally 3M + 4S or 2M + 4S\n\n  // B = (X1 + Y1)^2\n  var b = this.x.redAdd(this.y).redSqr();\n  // C = X1^2\n  var c = this.x.redSqr();\n  // D = Y1^2\n  var d = this.y.redSqr();\n\n  var nx;\n  var ny;\n  var nz;\n  if (this.curve.twisted) {\n    // E = a * C\n    var e = this.curve._mulA(c);\n    // F = E + D\n    var f = e.redAdd(d);\n    if (this.zOne) {\n      // X3 = (B - C - D) * (F - 2)\n      nx = b.redSub(c).redSub(d).redMul(f.redSub(this.curve.two));\n      // Y3 = F * (E - D)\n      ny = f.redMul(e.redSub(d));\n      // Z3 = F^2 - 2 * F\n      nz = f.redSqr().redSub(f).redSub(f);\n    } else {\n      // H = Z1^2\n      var h = this.z.redSqr();\n      // J = F - 2 * H\n      var j = f.redSub(h).redISub(h);\n      // X3 = (B-C-D)*J\n      nx = b.redSub(c).redISub(d).redMul(j);\n      // Y3 = F * (E - D)\n      ny = f.redMul(e.redSub(d));\n      // Z3 = F * J\n      nz = f.redMul(j);\n    }\n  } else {\n    // E = C + D\n    var e = c.redAdd(d);\n    // H = (c * Z1)^2\n    var h = this.curve._mulC(this.c.redMul(this.z)).redSqr();\n    // J = E - 2 * H\n    var j = e.redSub(h).redSub(h);\n    // X3 = c * (B - E) * J\n    nx = this.curve._mulC(b.redISub(e)).redMul(j);\n    // Y3 = c * E * (C - D)\n    ny = this.curve._mulC(e).redMul(c.redISub(d));\n    // Z3 = E * J\n    nz = e.redMul(j);\n  }\n  return this.curve.point(nx, ny, nz);\n};\n\nPoint.prototype.dbl = function dbl() {\n  if (this.isInfinity())\n    return this;\n\n  // Double in extended coordinates\n  if (this.curve.extended)\n    return this._extDbl();\n  else\n    return this._projDbl();\n};\n\nPoint.prototype._extAdd = function _extAdd(p) {\n  // hyperelliptic.org/EFD/g1p/auto-twisted-extended-1.html\n  //     #addition-add-2008-hwcd-3\n  // 8M\n\n  // A = (Y1 - X1) * (Y2 - X2)\n  var a = this.y.redSub(this.x).redMul(p.y.redSub(p.x));\n  // B = (Y1 + X1) * (Y2 + X2)\n  var b = this.y.redAdd(this.x).redMul(p.y.redAdd(p.x));\n  // C = T1 * k * T2\n  var c = this.t.redMul(this.curve.dd).redMul(p.t);\n  // D = Z1 * 2 * Z2\n  var d = this.z.redMul(p.z.redAdd(p.z));\n  // E = B - A\n  var e = b.redSub(a);\n  // F = D - C\n  var f = d.redSub(c);\n  // G = D + C\n  var g = d.redAdd(c);\n  // H = B + A\n  var h = b.redAdd(a);\n  // X3 = E * F\n  var nx = e.redMul(f);\n  // Y3 = G * H\n  var ny = g.redMul(h);\n  // T3 = E * H\n  var nt = e.redMul(h);\n  // Z3 = F * G\n  var nz = f.redMul(g);\n  return this.curve.point(nx, ny, nz, nt);\n};\n\nPoint.prototype._projAdd = function _projAdd(p) {\n  // hyperelliptic.org/EFD/g1p/auto-twisted-projective.html\n  //     #addition-add-2008-bbjlp\n  //     #addition-add-2007-bl\n  // 10M + 1S\n\n  // A = Z1 * Z2\n  var a = this.z.redMul(p.z);\n  // B = A^2\n  var b = a.redSqr();\n  // C = X1 * X2\n  var c = this.x.redMul(p.x);\n  // D = Y1 * Y2\n  var d = this.y.redMul(p.y);\n  // E = d * C * D\n  var e = this.curve.d.redMul(c).redMul(d);\n  // F = B - E\n  var f = b.redSub(e);\n  // G = B + E\n  var g = b.redAdd(e);\n  // X3 = A * F * ((X1 + Y1) * (X2 + Y2) - C - D)\n  var tmp = this.x.redAdd(this.y).redMul(p.x.redAdd(p.y)).redISub(c).redISub(d);\n  var nx = a.redMul(f).redMul(tmp);\n  var ny;\n  var nz;\n  if (this.curve.twisted) {\n    // Y3 = A * G * (D - a * C)\n    ny = a.redMul(g).redMul(d.redSub(this.curve._mulA(c)));\n    // Z3 = F * G\n    nz = f.redMul(g);\n  } else {\n    // Y3 = A * G * (D - C)\n    ny = a.redMul(g).redMul(d.redSub(c));\n    // Z3 = c * F * G\n    nz = this.curve._mulC(f).redMul(g);\n  }\n  return this.curve.point(nx, ny, nz);\n};\n\nPoint.prototype.add = function add(p) {\n  if (this.isInfinity())\n    return p;\n  if (p.isInfinity())\n    return this;\n\n  if (this.curve.extended)\n    return this._extAdd(p);\n  else\n    return this._projAdd(p);\n};\n\nPoint.prototype.mul = function mul(k) {\n  if (this._hasDoubles(k))\n    return this.curve._fixedNafMul(this, k);\n  else\n    return this.curve._wnafMul(this, k);\n};\n\nPoint.prototype.mulAdd = function mulAdd(k1, p, k2) {\n  return this.curve._wnafMulAdd(1, [ this, p ], [ k1, k2 ], 2, false);\n};\n\nPoint.prototype.jmulAdd = function jmulAdd(k1, p, k2) {\n  return this.curve._wnafMulAdd(1, [ this, p ], [ k1, k2 ], 2, true);\n};\n\nPoint.prototype.normalize = function normalize() {\n  if (this.zOne)\n    return this;\n\n  // Normalize coordinates\n  var zi = this.z.redInvm();\n  this.x = this.x.redMul(zi);\n  this.y = this.y.redMul(zi);\n  if (this.t)\n    this.t = this.t.redMul(zi);\n  this.z = this.curve.one;\n  this.zOne = true;\n  return this;\n};\n\nPoint.prototype.neg = function neg() {\n  return this.curve.point(this.x.redNeg(),\n                          this.y,\n                          this.z,\n                          this.t && this.t.redNeg());\n};\n\nPoint.prototype.getX = function getX() {\n  this.normalize();\n  return this.x.fromRed();\n};\n\nPoint.prototype.getY = function getY() {\n  this.normalize();\n  return this.y.fromRed();\n};\n\nPoint.prototype.eq = function eq(other) {\n  return this === other ||\n         this.getX().cmp(other.getX()) === 0 &&\n         this.getY().cmp(other.getY()) === 0;\n};\n\nPoint.prototype.eqXToP = function eqXToP(x) {\n  var rx = x.toRed(this.curve.red).redMul(this.z);\n  if (this.x.cmp(rx) === 0)\n    return true;\n\n  var xc = x.clone();\n  var t = this.curve.redN.redMul(this.z);\n  for (;;) {\n    xc.iadd(this.curve.n);\n    if (xc.cmp(this.curve.p) >= 0)\n      return false;\n\n    rx.redIAdd(t);\n    if (this.x.cmp(rx) === 0)\n      return true;\n  }\n  return false;\n};\n\n// Compatibility with BaseCurve\nPoint.prototype.toP = Point.prototype.normalize;\nPoint.prototype.mixedAdd = Point.prototype.add;\n\n\n\n// WEBPACK FOOTER //\n// ./node_modules/elliptic/lib/elliptic/curve/edwards.js","'use strict';\n\nvar curves = exports;\n\nvar hash = require('hash.js');\nvar elliptic = require('../elliptic');\n\nvar assert = elliptic.utils.assert;\n\nfunction PresetCurve(options) {\n  if (options.type === 'short')\n    this.curve = new elliptic.curve.short(options);\n  else if (options.type === 'edwards')\n    this.curve = new elliptic.curve.edwards(options);\n  else\n    this.curve = new elliptic.curve.mont(options);\n  this.g = this.curve.g;\n  this.n = this.curve.n;\n  this.hash = options.hash;\n\n  assert(this.g.validate(), 'Invalid curve');\n  assert(this.g.mul(this.n).isInfinity(), 'Invalid curve, G*N != O');\n}\ncurves.PresetCurve = PresetCurve;\n\nfunction defineCurve(name, options) {\n  Object.defineProperty(curves, name, {\n    configurable: true,\n    enumerable: true,\n    get: function() {\n      var curve = new PresetCurve(options);\n      Object.defineProperty(curves, name, {\n        configurable: true,\n        enumerable: true,\n        value: curve\n      });\n      return curve;\n    }\n  });\n}\n\ndefineCurve('p192', {\n  type: 'short',\n  prime: 'p192',\n  p: 'ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff',\n  a: 'ffffffff ffffffff ffffffff fffffffe ffffffff fffffffc',\n  b: '64210519 e59c80e7 0fa7e9ab 72243049 feb8deec c146b9b1',\n  n: 'ffffffff ffffffff ffffffff 99def836 146bc9b1 b4d22831',\n  hash: hash.sha256,\n  gRed: false,\n  g: [\n    '188da80e b03090f6 7cbf20eb 43a18800 f4ff0afd 82ff1012',\n    '07192b95 ffc8da78 631011ed 6b24cdd5 73f977a1 1e794811'\n  ]\n});\n\ndefineCurve('p224', {\n  type: 'short',\n  prime: 'p224',\n  p: 'ffffffff ffffffff ffffffff ffffffff 00000000 00000000 00000001',\n  a: 'ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff fffffffe',\n  b: 'b4050a85 0c04b3ab f5413256 5044b0b7 d7bfd8ba 270b3943 2355ffb4',\n  n: 'ffffffff ffffffff ffffffff ffff16a2 e0b8f03e 13dd2945 5c5c2a3d',\n  hash: hash.sha256,\n  gRed: false,\n  g: [\n    'b70e0cbd 6bb4bf7f 321390b9 4a03c1d3 56c21122 343280d6 115c1d21',\n    'bd376388 b5f723fb 4c22dfe6 cd4375a0 5a074764 44d58199 85007e34'\n  ]\n});\n\ndefineCurve('p256', {\n  type: 'short',\n  prime: null,\n  p: 'ffffffff 00000001 00000000 00000000 00000000 ffffffff ffffffff ffffffff',\n  a: 'ffffffff 00000001 00000000 00000000 00000000 ffffffff ffffffff fffffffc',\n  b: '5ac635d8 aa3a93e7 b3ebbd55 769886bc 651d06b0 cc53b0f6 3bce3c3e 27d2604b',\n  n: 'ffffffff 00000000 ffffffff ffffffff bce6faad a7179e84 f3b9cac2 fc632551',\n  hash: hash.sha256,\n  gRed: false,\n  g: [\n    '6b17d1f2 e12c4247 f8bce6e5 63a440f2 77037d81 2deb33a0 f4a13945 d898c296',\n    '4fe342e2 fe1a7f9b 8ee7eb4a 7c0f9e16 2bce3357 6b315ece cbb64068 37bf51f5'\n  ]\n});\n\ndefineCurve('p384', {\n  type: 'short',\n  prime: null,\n  p: 'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ' +\n     'fffffffe ffffffff 00000000 00000000 ffffffff',\n  a: 'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ' +\n     'fffffffe ffffffff 00000000 00000000 fffffffc',\n  b: 'b3312fa7 e23ee7e4 988e056b e3f82d19 181d9c6e fe814112 0314088f ' +\n     '5013875a c656398d 8a2ed19d 2a85c8ed d3ec2aef',\n  n: 'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff c7634d81 ' +\n     'f4372ddf 581a0db2 48b0a77a ecec196a ccc52973',\n  hash: hash.sha384,\n  gRed: false,\n  g: [\n    'aa87ca22 be8b0537 8eb1c71e f320ad74 6e1d3b62 8ba79b98 59f741e0 82542a38 ' +\n    '5502f25d bf55296c 3a545e38 72760ab7',\n    '3617de4a 96262c6f 5d9e98bf 9292dc29 f8f41dbd 289a147c e9da3113 b5f0b8c0 ' +\n    '0a60b1ce 1d7e819d 7a431d7c 90ea0e5f'\n  ]\n});\n\ndefineCurve('p521', {\n  type: 'short',\n  prime: null,\n  p: '000001ff ffffffff ffffffff ffffffff ffffffff ffffffff ' +\n     'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ' +\n     'ffffffff ffffffff ffffffff ffffffff ffffffff',\n  a: '000001ff ffffffff ffffffff ffffffff ffffffff ffffffff ' +\n     'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ' +\n     'ffffffff ffffffff ffffffff ffffffff fffffffc',\n  b: '00000051 953eb961 8e1c9a1f 929a21a0 b68540ee a2da725b ' +\n     '99b315f3 b8b48991 8ef109e1 56193951 ec7e937b 1652c0bd ' +\n     '3bb1bf07 3573df88 3d2c34f1 ef451fd4 6b503f00',\n  n: '000001ff ffffffff ffffffff ffffffff ffffffff ffffffff ' +\n     'ffffffff ffffffff fffffffa 51868783 bf2f966b 7fcc0148 ' +\n     'f709a5d0 3bb5c9b8 899c47ae bb6fb71e 91386409',\n  hash: hash.sha512,\n  gRed: false,\n  g: [\n    '000000c6 858e06b7 0404e9cd 9e3ecb66 2395b442 9c648139 ' +\n    '053fb521 f828af60 6b4d3dba a14b5e77 efe75928 fe1dc127 ' +\n    'a2ffa8de 3348b3c1 856a429b f97e7e31 c2e5bd66',\n    '00000118 39296a78 9a3bc004 5c8a5fb4 2c7d1bd9 98f54449 ' +\n    '579b4468 17afbd17 273e662c 97ee7299 5ef42640 c550b901 ' +\n    '3fad0761 353c7086 a272c240 88be9476 9fd16650'\n  ]\n});\n\ndefineCurve('curve25519', {\n  type: 'mont',\n  prime: 'p25519',\n  p: '7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed',\n  a: '76d06',\n  b: '1',\n  n: '1000000000000000 0000000000000000 14def9dea2f79cd6 5812631a5cf5d3ed',\n  hash: hash.sha256,\n  gRed: false,\n  g: [\n    '9'\n  ]\n});\n\ndefineCurve('ed25519', {\n  type: 'edwards',\n  prime: 'p25519',\n  p: '7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed',\n  a: '-1',\n  c: '1',\n  // -121665 * (121666^(-1)) (mod P)\n  d: '52036cee2b6ffe73 8cc740797779e898 00700a4d4141d8ab 75eb4dca135978a3',\n  n: '1000000000000000 0000000000000000 14def9dea2f79cd6 5812631a5cf5d3ed',\n  hash: hash.sha256,\n  gRed: false,\n  g: [\n    '216936d3cd6e53fec0a4e231fdd6dc5c692cc7609525a7b2c9562d608f25d51a',\n\n    // 4/5\n    '6666666666666666666666666666666666666666666666666666666666666658'\n  ]\n});\n\nvar pre;\ntry {\n  pre = require('./precomputed/secp256k1');\n} catch (e) {\n  pre = undefined;\n}\n\ndefineCurve('secp256k1', {\n  type: 'short',\n  prime: 'k256',\n  p: 'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffe fffffc2f',\n  a: '0',\n  b: '7',\n  n: 'ffffffff ffffffff ffffffff fffffffe baaedce6 af48a03b bfd25e8c d0364141',\n  h: '1',\n  hash: hash.sha256,\n\n  // Precomputed endomorphism\n  beta: '7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee',\n  lambda: '5363ad4cc05c30e0a5261c028812645a122e22ea20816678df02967c1b23bd72',\n  basis: [\n    {\n      a: '3086d221a7d46bcde86c90e49284eb15',\n      b: '-e4437ed6010e88286f547fa90abfe4c3'\n    },\n    {\n      a: '114ca50f7a8e2f3f657c1108d9d44cfd8',\n      b: '3086d221a7d46bcde86c90e49284eb15'\n    }\n  ],\n\n  gRed: false,\n  g: [\n    '79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798',\n    '483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8',\n    pre\n  ]\n});\n\n\n\n// WEBPACK FOOTER //\n// ./node_modules/elliptic/lib/elliptic/curves.js","'use strict';\n\nexports.sha1 = require('./sha/1');\nexports.sha224 = require('./sha/224');\nexports.sha256 = require('./sha/256');\nexports.sha384 = require('./sha/384');\nexports.sha512 = require('./sha/512');\n\n\n\n// WEBPACK FOOTER //\n// ./node_modules/hash.js/lib/hash/sha.js","'use strict';\n\nvar utils = require('../utils');\nvar common = require('../common');\nvar shaCommon = require('./common');\n\nvar rotl32 = utils.rotl32;\nvar sum32 = utils.sum32;\nvar sum32_5 = utils.sum32_5;\nvar ft_1 = shaCommon.ft_1;\nvar BlockHash = common.BlockHash;\n\nvar sha1_K = [\n  0x5A827999, 0x6ED9EBA1,\n  0x8F1BBCDC, 0xCA62C1D6\n];\n\nfunction SHA1() {\n  if (!(this instanceof SHA1))\n    return new SHA1();\n\n  BlockHash.call(this);\n  this.h = [\n    0x67452301, 0xefcdab89, 0x98badcfe,\n    0x10325476, 0xc3d2e1f0 ];\n  this.W = new Array(80);\n}\n\nutils.inherits(SHA1, BlockHash);\nmodule.exports = SHA1;\n\nSHA1.blockSize = 512;\nSHA1.outSize = 160;\nSHA1.hmacStrength = 80;\nSHA1.padLength = 64;\n\nSHA1.prototype._update = function _update(msg, start) {\n  var W = this.W;\n\n  for (var i = 0; i < 16; i++)\n    W[i] = msg[start + i];\n\n  for(; i < W.length; i++)\n    W[i] = rotl32(W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16], 1);\n\n  var a = this.h[0];\n  var b = this.h[1];\n  var c = this.h[2];\n  var d = this.h[3];\n  var e = this.h[4];\n\n  for (i = 0; i < W.length; i++) {\n    var s = ~~(i / 20);\n    var t = sum32_5(rotl32(a, 5), ft_1(s, b, c, d), e, W[i], sha1_K[s]);\n    e = d;\n    d = c;\n    c = rotl32(b, 30);\n    b = a;\n    a = t;\n  }\n\n  this.h[0] = sum32(this.h[0], a);\n  this.h[1] = sum32(this.h[1], b);\n  this.h[2] = sum32(this.h[2], c);\n  this.h[3] = sum32(this.h[3], d);\n  this.h[4] = sum32(this.h[4], e);\n};\n\nSHA1.prototype._digest = function digest(enc) {\n  if (enc === 'hex')\n    return utils.toHex32(this.h, 'big');\n  else\n    return utils.split32(this.h, 'big');\n};\n\n\n\n// WEBPACK FOOTER //\n// ./node_modules/hash.js/lib/hash/sha/1.js","'use strict';\n\nvar utils = require('../utils');\nvar SHA256 = require('./256');\n\nfunction SHA224() {\n  if (!(this instanceof SHA224))\n    return new SHA224();\n\n  SHA256.call(this);\n  this.h = [\n    0xc1059ed8, 0x367cd507, 0x3070dd17, 0xf70e5939,\n    0xffc00b31, 0x68581511, 0x64f98fa7, 0xbefa4fa4 ];\n}\nutils.inherits(SHA224, SHA256);\nmodule.exports = SHA224;\n\nSHA224.blockSize = 512;\nSHA224.outSize = 224;\nSHA224.hmacStrength = 192;\nSHA224.padLength = 64;\n\nSHA224.prototype._digest = function digest(enc) {\n  // Just truncate output\n  if (enc === 'hex')\n    return utils.toHex32(this.h.slice(0, 7), 'big');\n  else\n    return utils.split32(this.h.slice(0, 7), 'big');\n};\n\n\n\n\n// WEBPACK FOOTER //\n// ./node_modules/hash.js/lib/hash/sha/224.js","'use strict';\n\nvar utils = require('../utils');\n\nvar SHA512 = require('./512');\n\nfunction SHA384() {\n  if (!(this instanceof SHA384))\n    return new SHA384();\n\n  SHA512.call(this);\n  this.h = [\n    0xcbbb9d5d, 0xc1059ed8,\n    0x629a292a, 0x367cd507,\n    0x9159015a, 0x3070dd17,\n    0x152fecd8, 0xf70e5939,\n    0x67332667, 0xffc00b31,\n    0x8eb44a87, 0x68581511,\n    0xdb0c2e0d, 0x64f98fa7,\n    0x47b5481d, 0xbefa4fa4 ];\n}\nutils.inherits(SHA384, SHA512);\nmodule.exports = SHA384;\n\nSHA384.blockSize = 1024;\nSHA384.outSize = 384;\nSHA384.hmacStrength = 192;\nSHA384.padLength = 128;\n\nSHA384.prototype._digest = function digest(enc) {\n  if (enc === 'hex')\n    return utils.toHex32(this.h.slice(0, 12), 'big');\n  else\n    return utils.split32(this.h.slice(0, 12), 'big');\n};\n\n\n\n// WEBPACK FOOTER //\n// ./node_modules/hash.js/lib/hash/sha/384.js","'use strict';\n\nvar utils = require('./utils');\nvar common = require('./common');\n\nvar rotl32 = utils.rotl32;\nvar sum32 = utils.sum32;\nvar sum32_3 = utils.sum32_3;\nvar sum32_4 = utils.sum32_4;\nvar BlockHash = common.BlockHash;\n\nfunction RIPEMD160() {\n  if (!(this instanceof RIPEMD160))\n    return new RIPEMD160();\n\n  BlockHash.call(this);\n\n  this.h = [ 0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0 ];\n  this.endian = 'little';\n}\nutils.inherits(RIPEMD160, BlockHash);\nexports.ripemd160 = RIPEMD160;\n\nRIPEMD160.blockSize = 512;\nRIPEMD160.outSize = 160;\nRIPEMD160.hmacStrength = 192;\nRIPEMD160.padLength = 64;\n\nRIPEMD160.prototype._update = function update(msg, start) {\n  var A = this.h[0];\n  var B = this.h[1];\n  var C = this.h[2];\n  var D = this.h[3];\n  var E = this.h[4];\n  var Ah = A;\n  var Bh = B;\n  var Ch = C;\n  var Dh = D;\n  var Eh = E;\n  for (var j = 0; j < 80; j++) {\n    var T = sum32(\n      rotl32(\n        sum32_4(A, f(j, B, C, D), msg[r[j] + start], K(j)),\n        s[j]),\n      E);\n    A = E;\n    E = D;\n    D = rotl32(C, 10);\n    C = B;\n    B = T;\n    T = sum32(\n      rotl32(\n        sum32_4(Ah, f(79 - j, Bh, Ch, Dh), msg[rh[j] + start], Kh(j)),\n        sh[j]),\n      Eh);\n    Ah = Eh;\n    Eh = Dh;\n    Dh = rotl32(Ch, 10);\n    Ch = Bh;\n    Bh = T;\n  }\n  T = sum32_3(this.h[1], C, Dh);\n  this.h[1] = sum32_3(this.h[2], D, Eh);\n  this.h[2] = sum32_3(this.h[3], E, Ah);\n  this.h[3] = sum32_3(this.h[4], A, Bh);\n  this.h[4] = sum32_3(this.h[0], B, Ch);\n  this.h[0] = T;\n};\n\nRIPEMD160.prototype._digest = function digest(enc) {\n  if (enc === 'hex')\n    return utils.toHex32(this.h, 'little');\n  else\n    return utils.split32(this.h, 'little');\n};\n\nfunction f(j, x, y, z) {\n  if (j <= 15)\n    return x ^ y ^ z;\n  else if (j <= 31)\n    return (x & y) | ((~x) & z);\n  else if (j <= 47)\n    return (x | (~y)) ^ z;\n  else if (j <= 63)\n    return (x & z) | (y & (~z));\n  else\n    return x ^ (y | (~z));\n}\n\nfunction K(j) {\n  if (j <= 15)\n    return 0x00000000;\n  else if (j <= 31)\n    return 0x5a827999;\n  else if (j <= 47)\n    return 0x6ed9eba1;\n  else if (j <= 63)\n    return 0x8f1bbcdc;\n  else\n    return 0xa953fd4e;\n}\n\nfunction Kh(j) {\n  if (j <= 15)\n    return 0x50a28be6;\n  else if (j <= 31)\n    return 0x5c4dd124;\n  else if (j <= 47)\n    return 0x6d703ef3;\n  else if (j <= 63)\n    return 0x7a6d76e9;\n  else\n    return 0x00000000;\n}\n\nvar r = [\n  0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,\n  7, 4, 13, 1, 10, 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8,\n  3, 10, 14, 4, 9, 15, 8, 1, 2, 7, 0, 6, 13, 11, 5, 12,\n  1, 9, 11, 10, 0, 8, 12, 4, 13, 3, 7, 15, 14, 5, 6, 2,\n  4, 0, 5, 9, 7, 12, 2, 10, 14, 1, 3, 8, 11, 6, 15, 13\n];\n\nvar rh = [\n  5, 14, 7, 0, 9, 2, 11, 4, 13, 6, 15, 8, 1, 10, 3, 12,\n  6, 11, 3, 7, 0, 13, 5, 10, 14, 15, 8, 12, 4, 9, 1, 2,\n  15, 5, 1, 3, 7, 14, 6, 9, 11, 8, 12, 2, 10, 0, 4, 13,\n  8, 6, 4, 1, 3, 11, 15, 0, 5, 12, 2, 13, 9, 7, 10, 14,\n  12, 15, 10, 4, 1, 5, 8, 7, 6, 2, 13, 14, 0, 3, 9, 11\n];\n\nvar s = [\n  11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8,\n  7, 6, 8, 13, 11, 9, 7, 15, 7, 12, 15, 9, 11, 7, 13, 12,\n  11, 13, 6, 7, 14, 9, 13, 15, 14, 8, 13, 6, 5, 12, 7, 5,\n  11, 12, 14, 15, 14, 15, 9, 8, 9, 14, 5, 6, 8, 6, 5, 12,\n  9, 15, 5, 11, 6, 8, 13, 12, 5, 12, 13, 14, 11, 8, 5, 6\n];\n\nvar sh = [\n  8, 9, 9, 11, 13, 15, 15, 5, 7, 7, 8, 11, 14, 14, 12, 6,\n  9, 13, 15, 7, 12, 8, 9, 11, 7, 7, 12, 7, 6, 15, 13, 11,\n  9, 7, 15, 11, 8, 6, 6, 14, 12, 13, 5, 14, 13, 13, 7, 5,\n  15, 5, 8, 11, 14, 14, 6, 14, 6, 9, 12, 9, 12, 5, 15, 8,\n  8, 5, 12, 9, 12, 5, 14, 6, 8, 13, 6, 5, 15, 13, 11, 11\n];\n\n\n\n// WEBPACK FOOTER //\n// ./node_modules/hash.js/lib/hash/ripemd.js","'use strict';\n\nvar utils = require('./utils');\nvar assert = require('minimalistic-assert');\n\nfunction Hmac(hash, key, enc) {\n  if (!(this instanceof Hmac))\n    return new Hmac(hash, key, enc);\n  this.Hash = hash;\n  this.blockSize = hash.blockSize / 8;\n  this.outSize = hash.outSize / 8;\n  this.inner = null;\n  this.outer = null;\n\n  this._init(utils.toArray(key, enc));\n}\nmodule.exports = Hmac;\n\nHmac.prototype._init = function init(key) {\n  // Shorten key, if needed\n  if (key.length > this.blockSize)\n    key = new this.Hash().update(key).digest();\n  assert(key.length <= this.blockSize);\n\n  // Add padding to key\n  for (var i = key.length; i < this.blockSize; i++)\n    key.push(0);\n\n  for (i = 0; i < key.length; i++)\n    key[i] ^= 0x36;\n  this.inner = new this.Hash().update(key);\n\n  // 0x36 ^ 0x5c = 0x6a\n  for (i = 0; i < key.length; i++)\n    key[i] ^= 0x6a;\n  this.outer = new this.Hash().update(key);\n};\n\nHmac.prototype.update = function update(msg, enc) {\n  this.inner.update(msg, enc);\n  return this;\n};\n\nHmac.prototype.digest = function digest(enc) {\n  this.outer.update(this.inner.digest());\n  return this.outer.digest(enc);\n};\n\n\n\n// WEBPACK FOOTER //\n// ./node_modules/hash.js/lib/hash/hmac.js","module.exports = {\n  doubles: {\n    step: 4,\n    points: [\n      [\n        'e60fce93b59e9ec53011aabc21c23e97b2a31369b87a5ae9c44ee89e2a6dec0a',\n        'f7e3507399e595929db99f34f57937101296891e44d23f0be1f32cce69616821'\n      ],\n      [\n        '8282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508',\n        '11f8a8098557dfe45e8256e830b60ace62d613ac2f7b17bed31b6eaff6e26caf'\n      ],\n      [\n        '175e159f728b865a72f99cc6c6fc846de0b93833fd2222ed73fce5b551e5b739',\n        'd3506e0d9e3c79eba4ef97a51ff71f5eacb5955add24345c6efa6ffee9fed695'\n      ],\n      [\n        '363d90d447b00c9c99ceac05b6262ee053441c7e55552ffe526bad8f83ff4640',\n        '4e273adfc732221953b445397f3363145b9a89008199ecb62003c7f3bee9de9'\n      ],\n      [\n        '8b4b5f165df3c2be8c6244b5b745638843e4a781a15bcd1b69f79a55dffdf80c',\n        '4aad0a6f68d308b4b3fbd7813ab0da04f9e336546162ee56b3eff0c65fd4fd36'\n      ],\n      [\n        '723cbaa6e5db996d6bf771c00bd548c7b700dbffa6c0e77bcb6115925232fcda',\n        '96e867b5595cc498a921137488824d6e2660a0653779494801dc069d9eb39f5f'\n      ],\n      [\n        'eebfa4d493bebf98ba5feec812c2d3b50947961237a919839a533eca0e7dd7fa',\n        '5d9a8ca3970ef0f269ee7edaf178089d9ae4cdc3a711f712ddfd4fdae1de8999'\n      ],\n      [\n        '100f44da696e71672791d0a09b7bde459f1215a29b3c03bfefd7835b39a48db0',\n        'cdd9e13192a00b772ec8f3300c090666b7ff4a18ff5195ac0fbd5cd62bc65a09'\n      ],\n      [\n        'e1031be262c7ed1b1dc9227a4a04c017a77f8d4464f3b3852c8acde6e534fd2d',\n        '9d7061928940405e6bb6a4176597535af292dd419e1ced79a44f18f29456a00d'\n      ],\n      [\n        'feea6cae46d55b530ac2839f143bd7ec5cf8b266a41d6af52d5e688d9094696d',\n        'e57c6b6c97dce1bab06e4e12bf3ecd5c981c8957cc41442d3155debf18090088'\n      ],\n      [\n        'da67a91d91049cdcb367be4be6ffca3cfeed657d808583de33fa978bc1ec6cb1',\n        '9bacaa35481642bc41f463f7ec9780e5dec7adc508f740a17e9ea8e27a68be1d'\n      ],\n      [\n        '53904faa0b334cdda6e000935ef22151ec08d0f7bb11069f57545ccc1a37b7c0',\n        '5bc087d0bc80106d88c9eccac20d3c1c13999981e14434699dcb096b022771c8'\n      ],\n      [\n        '8e7bcd0bd35983a7719cca7764ca906779b53a043a9b8bcaeff959f43ad86047',\n        '10b7770b2a3da4b3940310420ca9514579e88e2e47fd68b3ea10047e8460372a'\n      ],\n      [\n        '385eed34c1cdff21e6d0818689b81bde71a7f4f18397e6690a841e1599c43862',\n        '283bebc3e8ea23f56701de19e9ebf4576b304eec2086dc8cc0458fe5542e5453'\n      ],\n      [\n        '6f9d9b803ecf191637c73a4413dfa180fddf84a5947fbc9c606ed86c3fac3a7',\n        '7c80c68e603059ba69b8e2a30e45c4d47ea4dd2f5c281002d86890603a842160'\n      ],\n      [\n        '3322d401243c4e2582a2147c104d6ecbf774d163db0f5e5313b7e0e742d0e6bd',\n        '56e70797e9664ef5bfb019bc4ddaf9b72805f63ea2873af624f3a2e96c28b2a0'\n      ],\n      [\n        '85672c7d2de0b7da2bd1770d89665868741b3f9af7643397721d74d28134ab83',\n        '7c481b9b5b43b2eb6374049bfa62c2e5e77f17fcc5298f44c8e3094f790313a6'\n      ],\n      [\n        '948bf809b1988a46b06c9f1919413b10f9226c60f668832ffd959af60c82a0a',\n        '53a562856dcb6646dc6b74c5d1c3418c6d4dff08c97cd2bed4cb7f88d8c8e589'\n      ],\n      [\n        '6260ce7f461801c34f067ce0f02873a8f1b0e44dfc69752accecd819f38fd8e8',\n        'bc2da82b6fa5b571a7f09049776a1ef7ecd292238051c198c1a84e95b2b4ae17'\n      ],\n      [\n        'e5037de0afc1d8d43d8348414bbf4103043ec8f575bfdc432953cc8d2037fa2d',\n        '4571534baa94d3b5f9f98d09fb990bddbd5f5b03ec481f10e0e5dc841d755bda'\n      ],\n      [\n        'e06372b0f4a207adf5ea905e8f1771b4e7e8dbd1c6a6c5b725866a0ae4fce725',\n        '7a908974bce18cfe12a27bb2ad5a488cd7484a7787104870b27034f94eee31dd'\n      ],\n      [\n        '213c7a715cd5d45358d0bbf9dc0ce02204b10bdde2a3f58540ad6908d0559754',\n        '4b6dad0b5ae462507013ad06245ba190bb4850f5f36a7eeddff2c27534b458f2'\n      ],\n      [\n        '4e7c272a7af4b34e8dbb9352a5419a87e2838c70adc62cddf0cc3a3b08fbd53c',\n        '17749c766c9d0b18e16fd09f6def681b530b9614bff7dd33e0b3941817dcaae6'\n      ],\n      [\n        'fea74e3dbe778b1b10f238ad61686aa5c76e3db2be43057632427e2840fb27b6',\n        '6e0568db9b0b13297cf674deccb6af93126b596b973f7b77701d3db7f23cb96f'\n      ],\n      [\n        '76e64113f677cf0e10a2570d599968d31544e179b760432952c02a4417bdde39',\n        'c90ddf8dee4e95cf577066d70681f0d35e2a33d2b56d2032b4b1752d1901ac01'\n      ],\n      [\n        'c738c56b03b2abe1e8281baa743f8f9a8f7cc643df26cbee3ab150242bcbb891',\n        '893fb578951ad2537f718f2eacbfbbbb82314eef7880cfe917e735d9699a84c3'\n      ],\n      [\n        'd895626548b65b81e264c7637c972877d1d72e5f3a925014372e9f6588f6c14b',\n        'febfaa38f2bc7eae728ec60818c340eb03428d632bb067e179363ed75d7d991f'\n      ],\n      [\n        'b8da94032a957518eb0f6433571e8761ceffc73693e84edd49150a564f676e03',\n        '2804dfa44805a1e4d7c99cc9762808b092cc584d95ff3b511488e4e74efdf6e7'\n      ],\n      [\n        'e80fea14441fb33a7d8adab9475d7fab2019effb5156a792f1a11778e3c0df5d',\n        'eed1de7f638e00771e89768ca3ca94472d155e80af322ea9fcb4291b6ac9ec78'\n      ],\n      [\n        'a301697bdfcd704313ba48e51d567543f2a182031efd6915ddc07bbcc4e16070',\n        '7370f91cfb67e4f5081809fa25d40f9b1735dbf7c0a11a130c0d1a041e177ea1'\n      ],\n      [\n        '90ad85b389d6b936463f9d0512678de208cc330b11307fffab7ac63e3fb04ed4',\n        'e507a3620a38261affdcbd9427222b839aefabe1582894d991d4d48cb6ef150'\n      ],\n      [\n        '8f68b9d2f63b5f339239c1ad981f162ee88c5678723ea3351b7b444c9ec4c0da',\n        '662a9f2dba063986de1d90c2b6be215dbbea2cfe95510bfdf23cbf79501fff82'\n      ],\n      [\n        'e4f3fb0176af85d65ff99ff9198c36091f48e86503681e3e6686fd5053231e11',\n        '1e63633ad0ef4f1c1661a6d0ea02b7286cc7e74ec951d1c9822c38576feb73bc'\n      ],\n      [\n        '8c00fa9b18ebf331eb961537a45a4266c7034f2f0d4e1d0716fb6eae20eae29e',\n        'efa47267fea521a1a9dc343a3736c974c2fadafa81e36c54e7d2a4c66702414b'\n      ],\n      [\n        'e7a26ce69dd4829f3e10cec0a9e98ed3143d084f308b92c0997fddfc60cb3e41',\n        '2a758e300fa7984b471b006a1aafbb18d0a6b2c0420e83e20e8a9421cf2cfd51'\n      ],\n      [\n        'b6459e0ee3662ec8d23540c223bcbdc571cbcb967d79424f3cf29eb3de6b80ef',\n        '67c876d06f3e06de1dadf16e5661db3c4b3ae6d48e35b2ff30bf0b61a71ba45'\n      ],\n      [\n        'd68a80c8280bb840793234aa118f06231d6f1fc67e73c5a5deda0f5b496943e8',\n        'db8ba9fff4b586d00c4b1f9177b0e28b5b0e7b8f7845295a294c84266b133120'\n      ],\n      [\n        '324aed7df65c804252dc0270907a30b09612aeb973449cea4095980fc28d3d5d',\n        '648a365774b61f2ff130c0c35aec1f4f19213b0c7e332843967224af96ab7c84'\n      ],\n      [\n        '4df9c14919cde61f6d51dfdbe5fee5dceec4143ba8d1ca888e8bd373fd054c96',\n        '35ec51092d8728050974c23a1d85d4b5d506cdc288490192ebac06cad10d5d'\n      ],\n      [\n        '9c3919a84a474870faed8a9c1cc66021523489054d7f0308cbfc99c8ac1f98cd',\n        'ddb84f0f4a4ddd57584f044bf260e641905326f76c64c8e6be7e5e03d4fc599d'\n      ],\n      [\n        '6057170b1dd12fdf8de05f281d8e06bb91e1493a8b91d4cc5a21382120a959e5',\n        '9a1af0b26a6a4807add9a2daf71df262465152bc3ee24c65e899be932385a2a8'\n      ],\n      [\n        'a576df8e23a08411421439a4518da31880cef0fba7d4df12b1a6973eecb94266',\n        '40a6bf20e76640b2c92b97afe58cd82c432e10a7f514d9f3ee8be11ae1b28ec8'\n      ],\n      [\n        '7778a78c28dec3e30a05fe9629de8c38bb30d1f5cf9a3a208f763889be58ad71',\n        '34626d9ab5a5b22ff7098e12f2ff580087b38411ff24ac563b513fc1fd9f43ac'\n      ],\n      [\n        '928955ee637a84463729fd30e7afd2ed5f96274e5ad7e5cb09eda9c06d903ac',\n        'c25621003d3f42a827b78a13093a95eeac3d26efa8a8d83fc5180e935bcd091f'\n      ],\n      [\n        '85d0fef3ec6db109399064f3a0e3b2855645b4a907ad354527aae75163d82751',\n        '1f03648413a38c0be29d496e582cf5663e8751e96877331582c237a24eb1f962'\n      ],\n      [\n        'ff2b0dce97eece97c1c9b6041798b85dfdfb6d8882da20308f5404824526087e',\n        '493d13fef524ba188af4c4dc54d07936c7b7ed6fb90e2ceb2c951e01f0c29907'\n      ],\n      [\n        '827fbbe4b1e880ea9ed2b2e6301b212b57f1ee148cd6dd28780e5e2cf856e241',\n        'c60f9c923c727b0b71bef2c67d1d12687ff7a63186903166d605b68baec293ec'\n      ],\n      [\n        'eaa649f21f51bdbae7be4ae34ce6e5217a58fdce7f47f9aa7f3b58fa2120e2b3',\n        'be3279ed5bbbb03ac69a80f89879aa5a01a6b965f13f7e59d47a5305ba5ad93d'\n      ],\n      [\n        'e4a42d43c5cf169d9391df6decf42ee541b6d8f0c9a137401e23632dda34d24f',\n        '4d9f92e716d1c73526fc99ccfb8ad34ce886eedfa8d8e4f13a7f7131deba9414'\n      ],\n      [\n        '1ec80fef360cbdd954160fadab352b6b92b53576a88fea4947173b9d4300bf19',\n        'aeefe93756b5340d2f3a4958a7abbf5e0146e77f6295a07b671cdc1cc107cefd'\n      ],\n      [\n        '146a778c04670c2f91b00af4680dfa8bce3490717d58ba889ddb5928366642be',\n        'b318e0ec3354028add669827f9d4b2870aaa971d2f7e5ed1d0b297483d83efd0'\n      ],\n      [\n        'fa50c0f61d22e5f07e3acebb1aa07b128d0012209a28b9776d76a8793180eef9',\n        '6b84c6922397eba9b72cd2872281a68a5e683293a57a213b38cd8d7d3f4f2811'\n      ],\n      [\n        'da1d61d0ca721a11b1a5bf6b7d88e8421a288ab5d5bba5220e53d32b5f067ec2',\n        '8157f55a7c99306c79c0766161c91e2966a73899d279b48a655fba0f1ad836f1'\n      ],\n      [\n        'a8e282ff0c9706907215ff98e8fd416615311de0446f1e062a73b0610d064e13',\n        '7f97355b8db81c09abfb7f3c5b2515888b679a3e50dd6bd6cef7c73111f4cc0c'\n      ],\n      [\n        '174a53b9c9a285872d39e56e6913cab15d59b1fa512508c022f382de8319497c',\n        'ccc9dc37abfc9c1657b4155f2c47f9e6646b3a1d8cb9854383da13ac079afa73'\n      ],\n      [\n        '959396981943785c3d3e57edf5018cdbe039e730e4918b3d884fdff09475b7ba',\n        '2e7e552888c331dd8ba0386a4b9cd6849c653f64c8709385e9b8abf87524f2fd'\n      ],\n      [\n        'd2a63a50ae401e56d645a1153b109a8fcca0a43d561fba2dbb51340c9d82b151',\n        'e82d86fb6443fcb7565aee58b2948220a70f750af484ca52d4142174dcf89405'\n      ],\n      [\n        '64587e2335471eb890ee7896d7cfdc866bacbdbd3839317b3436f9b45617e073',\n        'd99fcdd5bf6902e2ae96dd6447c299a185b90a39133aeab358299e5e9faf6589'\n      ],\n      [\n        '8481bde0e4e4d885b3a546d3e549de042f0aa6cea250e7fd358d6c86dd45e458',\n        '38ee7b8cba5404dd84a25bf39cecb2ca900a79c42b262e556d64b1b59779057e'\n      ],\n      [\n        '13464a57a78102aa62b6979ae817f4637ffcfed3c4b1ce30bcd6303f6caf666b',\n        '69be159004614580ef7e433453ccb0ca48f300a81d0942e13f495a907f6ecc27'\n      ],\n      [\n        'bc4a9df5b713fe2e9aef430bcc1dc97a0cd9ccede2f28588cada3a0d2d83f366',\n        'd3a81ca6e785c06383937adf4b798caa6e8a9fbfa547b16d758d666581f33c1'\n      ],\n      [\n        '8c28a97bf8298bc0d23d8c749452a32e694b65e30a9472a3954ab30fe5324caa',\n        '40a30463a3305193378fedf31f7cc0eb7ae784f0451cb9459e71dc73cbef9482'\n      ],\n      [\n        '8ea9666139527a8c1dd94ce4f071fd23c8b350c5a4bb33748c4ba111faccae0',\n        '620efabbc8ee2782e24e7c0cfb95c5d735b783be9cf0f8e955af34a30e62b945'\n      ],\n      [\n        'dd3625faef5ba06074669716bbd3788d89bdde815959968092f76cc4eb9a9787',\n        '7a188fa3520e30d461da2501045731ca941461982883395937f68d00c644a573'\n      ],\n      [\n        'f710d79d9eb962297e4f6232b40e8f7feb2bc63814614d692c12de752408221e',\n        'ea98e67232d3b3295d3b535532115ccac8612c721851617526ae47a9c77bfc82'\n      ]\n    ]\n  },\n  naf: {\n    wnd: 7,\n    points: [\n      [\n        'f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9',\n        '388f7b0f632de8140fe337e62a37f3566500a99934c2231b6cb9fd7584b8e672'\n      ],\n      [\n        '2f8bde4d1a07209355b4a7250a5c5128e88b84bddc619ab7cba8d569b240efe4',\n        'd8ac222636e5e3d6d4dba9dda6c9c426f788271bab0d6840dca87d3aa6ac62d6'\n      ],\n      [\n        '5cbdf0646e5db4eaa398f365f2ea7a0e3d419b7e0330e39ce92bddedcac4f9bc',\n        '6aebca40ba255960a3178d6d861a54dba813d0b813fde7b5a5082628087264da'\n      ],\n      [\n        'acd484e2f0c7f65309ad178a9f559abde09796974c57e714c35f110dfc27ccbe',\n        'cc338921b0a7d9fd64380971763b61e9add888a4375f8e0f05cc262ac64f9c37'\n      ],\n      [\n        '774ae7f858a9411e5ef4246b70c65aac5649980be5c17891bbec17895da008cb',\n        'd984a032eb6b5e190243dd56d7b7b365372db1e2dff9d6a8301d74c9c953c61b'\n      ],\n      [\n        'f28773c2d975288bc7d1d205c3748651b075fbc6610e58cddeeddf8f19405aa8',\n        'ab0902e8d880a89758212eb65cdaf473a1a06da521fa91f29b5cb52db03ed81'\n      ],\n      [\n        'd7924d4f7d43ea965a465ae3095ff41131e5946f3c85f79e44adbcf8e27e080e',\n        '581e2872a86c72a683842ec228cc6defea40af2bd896d3a5c504dc9ff6a26b58'\n      ],\n      [\n        'defdea4cdb677750a420fee807eacf21eb9898ae79b9768766e4faa04a2d4a34',\n        '4211ab0694635168e997b0ead2a93daeced1f4a04a95c0f6cfb199f69e56eb77'\n      ],\n      [\n        '2b4ea0a797a443d293ef5cff444f4979f06acfebd7e86d277475656138385b6c',\n        '85e89bc037945d93b343083b5a1c86131a01f60c50269763b570c854e5c09b7a'\n      ],\n      [\n        '352bbf4a4cdd12564f93fa332ce333301d9ad40271f8107181340aef25be59d5',\n        '321eb4075348f534d59c18259dda3e1f4a1b3b2e71b1039c67bd3d8bcf81998c'\n      ],\n      [\n        '2fa2104d6b38d11b0230010559879124e42ab8dfeff5ff29dc9cdadd4ecacc3f',\n        '2de1068295dd865b64569335bd5dd80181d70ecfc882648423ba76b532b7d67'\n      ],\n      [\n        '9248279b09b4d68dab21a9b066edda83263c3d84e09572e269ca0cd7f5453714',\n        '73016f7bf234aade5d1aa71bdea2b1ff3fc0de2a887912ffe54a32ce97cb3402'\n      ],\n      [\n        'daed4f2be3a8bf278e70132fb0beb7522f570e144bf615c07e996d443dee8729',\n        'a69dce4a7d6c98e8d4a1aca87ef8d7003f83c230f3afa726ab40e52290be1c55'\n      ],\n      [\n        'c44d12c7065d812e8acf28d7cbb19f9011ecd9e9fdf281b0e6a3b5e87d22e7db',\n        '2119a460ce326cdc76c45926c982fdac0e106e861edf61c5a039063f0e0e6482'\n      ],\n      [\n        '6a245bf6dc698504c89a20cfded60853152b695336c28063b61c65cbd269e6b4',\n        'e022cf42c2bd4a708b3f5126f16a24ad8b33ba48d0423b6efd5e6348100d8a82'\n      ],\n      [\n        '1697ffa6fd9de627c077e3d2fe541084ce13300b0bec1146f95ae57f0d0bd6a5',\n        'b9c398f186806f5d27561506e4557433a2cf15009e498ae7adee9d63d01b2396'\n      ],\n      [\n        '605bdb019981718b986d0f07e834cb0d9deb8360ffb7f61df982345ef27a7479',\n        '2972d2de4f8d20681a78d93ec96fe23c26bfae84fb14db43b01e1e9056b8c49'\n      ],\n      [\n        '62d14dab4150bf497402fdc45a215e10dcb01c354959b10cfe31c7e9d87ff33d',\n        '80fc06bd8cc5b01098088a1950eed0db01aa132967ab472235f5642483b25eaf'\n      ],\n      [\n        '80c60ad0040f27dade5b4b06c408e56b2c50e9f56b9b8b425e555c2f86308b6f',\n        '1c38303f1cc5c30f26e66bad7fe72f70a65eed4cbe7024eb1aa01f56430bd57a'\n      ],\n      [\n        '7a9375ad6167ad54aa74c6348cc54d344cc5dc9487d847049d5eabb0fa03c8fb',\n        'd0e3fa9eca8726909559e0d79269046bdc59ea10c70ce2b02d499ec224dc7f7'\n      ],\n      [\n        'd528ecd9b696b54c907a9ed045447a79bb408ec39b68df504bb51f459bc3ffc9',\n        'eecf41253136e5f99966f21881fd656ebc4345405c520dbc063465b521409933'\n      ],\n      [\n        '49370a4b5f43412ea25f514e8ecdad05266115e4a7ecb1387231808f8b45963',\n        '758f3f41afd6ed428b3081b0512fd62a54c3f3afbb5b6764b653052a12949c9a'\n      ],\n      [\n        '77f230936ee88cbbd73df930d64702ef881d811e0e1498e2f1c13eb1fc345d74',\n        '958ef42a7886b6400a08266e9ba1b37896c95330d97077cbbe8eb3c7671c60d6'\n      ],\n      [\n        'f2dac991cc4ce4b9ea44887e5c7c0bce58c80074ab9d4dbaeb28531b7739f530',\n        'e0dedc9b3b2f8dad4da1f32dec2531df9eb5fbeb0598e4fd1a117dba703a3c37'\n      ],\n      [\n        '463b3d9f662621fb1b4be8fbbe2520125a216cdfc9dae3debcba4850c690d45b',\n        '5ed430d78c296c3543114306dd8622d7c622e27c970a1de31cb377b01af7307e'\n      ],\n      [\n        'f16f804244e46e2a09232d4aff3b59976b98fac14328a2d1a32496b49998f247',\n        'cedabd9b82203f7e13d206fcdf4e33d92a6c53c26e5cce26d6579962c4e31df6'\n      ],\n      [\n        'caf754272dc84563b0352b7a14311af55d245315ace27c65369e15f7151d41d1',\n        'cb474660ef35f5f2a41b643fa5e460575f4fa9b7962232a5c32f908318a04476'\n      ],\n      [\n        '2600ca4b282cb986f85d0f1709979d8b44a09c07cb86d7c124497bc86f082120',\n        '4119b88753c15bd6a693b03fcddbb45d5ac6be74ab5f0ef44b0be9475a7e4b40'\n      ],\n      [\n        '7635ca72d7e8432c338ec53cd12220bc01c48685e24f7dc8c602a7746998e435',\n        '91b649609489d613d1d5e590f78e6d74ecfc061d57048bad9e76f302c5b9c61'\n      ],\n      [\n        '754e3239f325570cdbbf4a87deee8a66b7f2b33479d468fbc1a50743bf56cc18',\n        '673fb86e5bda30fb3cd0ed304ea49a023ee33d0197a695d0c5d98093c536683'\n      ],\n      [\n        'e3e6bd1071a1e96aff57859c82d570f0330800661d1c952f9fe2694691d9b9e8',\n        '59c9e0bba394e76f40c0aa58379a3cb6a5a2283993e90c4167002af4920e37f5'\n      ],\n      [\n        '186b483d056a033826ae73d88f732985c4ccb1f32ba35f4b4cc47fdcf04aa6eb',\n        '3b952d32c67cf77e2e17446e204180ab21fb8090895138b4a4a797f86e80888b'\n      ],\n      [\n        'df9d70a6b9876ce544c98561f4be4f725442e6d2b737d9c91a8321724ce0963f',\n        '55eb2dafd84d6ccd5f862b785dc39d4ab157222720ef9da217b8c45cf2ba2417'\n      ],\n      [\n        '5edd5cc23c51e87a497ca815d5dce0f8ab52554f849ed8995de64c5f34ce7143',\n        'efae9c8dbc14130661e8cec030c89ad0c13c66c0d17a2905cdc706ab7399a868'\n      ],\n      [\n        '290798c2b6476830da12fe02287e9e777aa3fba1c355b17a722d362f84614fba',\n        'e38da76dcd440621988d00bcf79af25d5b29c094db2a23146d003afd41943e7a'\n      ],\n      [\n        'af3c423a95d9f5b3054754efa150ac39cd29552fe360257362dfdecef4053b45',\n        'f98a3fd831eb2b749a93b0e6f35cfb40c8cd5aa667a15581bc2feded498fd9c6'\n      ],\n      [\n        '766dbb24d134e745cccaa28c99bf274906bb66b26dcf98df8d2fed50d884249a',\n        '744b1152eacbe5e38dcc887980da38b897584a65fa06cedd2c924f97cbac5996'\n      ],\n      [\n        '59dbf46f8c94759ba21277c33784f41645f7b44f6c596a58ce92e666191abe3e',\n        'c534ad44175fbc300f4ea6ce648309a042ce739a7919798cd85e216c4a307f6e'\n      ],\n      [\n        'f13ada95103c4537305e691e74e9a4a8dd647e711a95e73cb62dc6018cfd87b8',\n        'e13817b44ee14de663bf4bc808341f326949e21a6a75c2570778419bdaf5733d'\n      ],\n      [\n        '7754b4fa0e8aced06d4167a2c59cca4cda1869c06ebadfb6488550015a88522c',\n        '30e93e864e669d82224b967c3020b8fa8d1e4e350b6cbcc537a48b57841163a2'\n      ],\n      [\n        '948dcadf5990e048aa3874d46abef9d701858f95de8041d2a6828c99e2262519',\n        'e491a42537f6e597d5d28a3224b1bc25df9154efbd2ef1d2cbba2cae5347d57e'\n      ],\n      [\n        '7962414450c76c1689c7b48f8202ec37fb224cf5ac0bfa1570328a8a3d7c77ab',\n        '100b610ec4ffb4760d5c1fc133ef6f6b12507a051f04ac5760afa5b29db83437'\n      ],\n      [\n        '3514087834964b54b15b160644d915485a16977225b8847bb0dd085137ec47ca',\n        'ef0afbb2056205448e1652c48e8127fc6039e77c15c2378b7e7d15a0de293311'\n      ],\n      [\n        'd3cc30ad6b483e4bc79ce2c9dd8bc54993e947eb8df787b442943d3f7b527eaf',\n        '8b378a22d827278d89c5e9be8f9508ae3c2ad46290358630afb34db04eede0a4'\n      ],\n      [\n        '1624d84780732860ce1c78fcbfefe08b2b29823db913f6493975ba0ff4847610',\n        '68651cf9b6da903e0914448c6cd9d4ca896878f5282be4c8cc06e2a404078575'\n      ],\n      [\n        '733ce80da955a8a26902c95633e62a985192474b5af207da6df7b4fd5fc61cd4',\n        'f5435a2bd2badf7d485a4d8b8db9fcce3e1ef8e0201e4578c54673bc1dc5ea1d'\n      ],\n      [\n        '15d9441254945064cf1a1c33bbd3b49f8966c5092171e699ef258dfab81c045c',\n        'd56eb30b69463e7234f5137b73b84177434800bacebfc685fc37bbe9efe4070d'\n      ],\n      [\n        'a1d0fcf2ec9de675b612136e5ce70d271c21417c9d2b8aaaac138599d0717940',\n        'edd77f50bcb5a3cab2e90737309667f2641462a54070f3d519212d39c197a629'\n      ],\n      [\n        'e22fbe15c0af8ccc5780c0735f84dbe9a790badee8245c06c7ca37331cb36980',\n        'a855babad5cd60c88b430a69f53a1a7a38289154964799be43d06d77d31da06'\n      ],\n      [\n        '311091dd9860e8e20ee13473c1155f5f69635e394704eaa74009452246cfa9b3',\n        '66db656f87d1f04fffd1f04788c06830871ec5a64feee685bd80f0b1286d8374'\n      ],\n      [\n        '34c1fd04d301be89b31c0442d3e6ac24883928b45a9340781867d4232ec2dbdf',\n        '9414685e97b1b5954bd46f730174136d57f1ceeb487443dc5321857ba73abee'\n      ],\n      [\n        'f219ea5d6b54701c1c14de5b557eb42a8d13f3abbcd08affcc2a5e6b049b8d63',\n        '4cb95957e83d40b0f73af4544cccf6b1f4b08d3c07b27fb8d8c2962a400766d1'\n      ],\n      [\n        'd7b8740f74a8fbaab1f683db8f45de26543a5490bca627087236912469a0b448',\n        'fa77968128d9c92ee1010f337ad4717eff15db5ed3c049b3411e0315eaa4593b'\n      ],\n      [\n        '32d31c222f8f6f0ef86f7c98d3a3335ead5bcd32abdd94289fe4d3091aa824bf',\n        '5f3032f5892156e39ccd3d7915b9e1da2e6dac9e6f26e961118d14b8462e1661'\n      ],\n      [\n        '7461f371914ab32671045a155d9831ea8793d77cd59592c4340f86cbc18347b5',\n        '8ec0ba238b96bec0cbdddcae0aa442542eee1ff50c986ea6b39847b3cc092ff6'\n      ],\n      [\n        'ee079adb1df1860074356a25aa38206a6d716b2c3e67453d287698bad7b2b2d6',\n        '8dc2412aafe3be5c4c5f37e0ecc5f9f6a446989af04c4e25ebaac479ec1c8c1e'\n      ],\n      [\n        '16ec93e447ec83f0467b18302ee620f7e65de331874c9dc72bfd8616ba9da6b5',\n        '5e4631150e62fb40d0e8c2a7ca5804a39d58186a50e497139626778e25b0674d'\n      ],\n      [\n        'eaa5f980c245f6f038978290afa70b6bd8855897f98b6aa485b96065d537bd99',\n        'f65f5d3e292c2e0819a528391c994624d784869d7e6ea67fb18041024edc07dc'\n      ],\n      [\n        '78c9407544ac132692ee1910a02439958ae04877151342ea96c4b6b35a49f51',\n        'f3e0319169eb9b85d5404795539a5e68fa1fbd583c064d2462b675f194a3ddb4'\n      ],\n      [\n        '494f4be219a1a77016dcd838431aea0001cdc8ae7a6fc688726578d9702857a5',\n        '42242a969283a5f339ba7f075e36ba2af925ce30d767ed6e55f4b031880d562c'\n      ],\n      [\n        'a598a8030da6d86c6bc7f2f5144ea549d28211ea58faa70ebf4c1e665c1fe9b5',\n        '204b5d6f84822c307e4b4a7140737aec23fc63b65b35f86a10026dbd2d864e6b'\n      ],\n      [\n        'c41916365abb2b5d09192f5f2dbeafec208f020f12570a184dbadc3e58595997',\n        '4f14351d0087efa49d245b328984989d5caf9450f34bfc0ed16e96b58fa9913'\n      ],\n      [\n        '841d6063a586fa475a724604da03bc5b92a2e0d2e0a36acfe4c73a5514742881',\n        '73867f59c0659e81904f9a1c7543698e62562d6744c169ce7a36de01a8d6154'\n      ],\n      [\n        '5e95bb399a6971d376026947f89bde2f282b33810928be4ded112ac4d70e20d5',\n        '39f23f366809085beebfc71181313775a99c9aed7d8ba38b161384c746012865'\n      ],\n      [\n        '36e4641a53948fd476c39f8a99fd974e5ec07564b5315d8bf99471bca0ef2f66',\n        'd2424b1b1abe4eb8164227b085c9aa9456ea13493fd563e06fd51cf5694c78fc'\n      ],\n      [\n        '336581ea7bfbbb290c191a2f507a41cf5643842170e914faeab27c2c579f726',\n        'ead12168595fe1be99252129b6e56b3391f7ab1410cd1e0ef3dcdcabd2fda224'\n      ],\n      [\n        '8ab89816dadfd6b6a1f2634fcf00ec8403781025ed6890c4849742706bd43ede',\n        '6fdcef09f2f6d0a044e654aef624136f503d459c3e89845858a47a9129cdd24e'\n      ],\n      [\n        '1e33f1a746c9c5778133344d9299fcaa20b0938e8acff2544bb40284b8c5fb94',\n        '60660257dd11b3aa9c8ed618d24edff2306d320f1d03010e33a7d2057f3b3b6'\n      ],\n      [\n        '85b7c1dcb3cec1b7ee7f30ded79dd20a0ed1f4cc18cbcfcfa410361fd8f08f31',\n        '3d98a9cdd026dd43f39048f25a8847f4fcafad1895d7a633c6fed3c35e999511'\n      ],\n      [\n        '29df9fbd8d9e46509275f4b125d6d45d7fbe9a3b878a7af872a2800661ac5f51',\n        'b4c4fe99c775a606e2d8862179139ffda61dc861c019e55cd2876eb2a27d84b'\n      ],\n      [\n        'a0b1cae06b0a847a3fea6e671aaf8adfdfe58ca2f768105c8082b2e449fce252',\n        'ae434102edde0958ec4b19d917a6a28e6b72da1834aff0e650f049503a296cf2'\n      ],\n      [\n        '4e8ceafb9b3e9a136dc7ff67e840295b499dfb3b2133e4ba113f2e4c0e121e5',\n        'cf2174118c8b6d7a4b48f6d534ce5c79422c086a63460502b827ce62a326683c'\n      ],\n      [\n        'd24a44e047e19b6f5afb81c7ca2f69080a5076689a010919f42725c2b789a33b',\n        '6fb8d5591b466f8fc63db50f1c0f1c69013f996887b8244d2cdec417afea8fa3'\n      ],\n      [\n        'ea01606a7a6c9cdd249fdfcfacb99584001edd28abbab77b5104e98e8e3b35d4',\n        '322af4908c7312b0cfbfe369f7a7b3cdb7d4494bc2823700cfd652188a3ea98d'\n      ],\n      [\n        'af8addbf2b661c8a6c6328655eb96651252007d8c5ea31be4ad196de8ce2131f',\n        '6749e67c029b85f52a034eafd096836b2520818680e26ac8f3dfbcdb71749700'\n      ],\n      [\n        'e3ae1974566ca06cc516d47e0fb165a674a3dabcfca15e722f0e3450f45889',\n        '2aeabe7e4531510116217f07bf4d07300de97e4874f81f533420a72eeb0bd6a4'\n      ],\n      [\n        '591ee355313d99721cf6993ffed1e3e301993ff3ed258802075ea8ced397e246',\n        'b0ea558a113c30bea60fc4775460c7901ff0b053d25ca2bdeee98f1a4be5d196'\n      ],\n      [\n        '11396d55fda54c49f19aa97318d8da61fa8584e47b084945077cf03255b52984',\n        '998c74a8cd45ac01289d5833a7beb4744ff536b01b257be4c5767bea93ea57a4'\n      ],\n      [\n        '3c5d2a1ba39c5a1790000738c9e0c40b8dcdfd5468754b6405540157e017aa7a',\n        'b2284279995a34e2f9d4de7396fc18b80f9b8b9fdd270f6661f79ca4c81bd257'\n      ],\n      [\n        'cc8704b8a60a0defa3a99a7299f2e9c3fbc395afb04ac078425ef8a1793cc030',\n        'bdd46039feed17881d1e0862db347f8cf395b74fc4bcdc4e940b74e3ac1f1b13'\n      ],\n      [\n        'c533e4f7ea8555aacd9777ac5cad29b97dd4defccc53ee7ea204119b2889b197',\n        '6f0a256bc5efdf429a2fb6242f1a43a2d9b925bb4a4b3a26bb8e0f45eb596096'\n      ],\n      [\n        'c14f8f2ccb27d6f109f6d08d03cc96a69ba8c34eec07bbcf566d48e33da6593',\n        'c359d6923bb398f7fd4473e16fe1c28475b740dd098075e6c0e8649113dc3a38'\n      ],\n      [\n        'a6cbc3046bc6a450bac24789fa17115a4c9739ed75f8f21ce441f72e0b90e6ef',\n        '21ae7f4680e889bb130619e2c0f95a360ceb573c70603139862afd617fa9b9f'\n      ],\n      [\n        '347d6d9a02c48927ebfb86c1359b1caf130a3c0267d11ce6344b39f99d43cc38',\n        '60ea7f61a353524d1c987f6ecec92f086d565ab687870cb12689ff1e31c74448'\n      ],\n      [\n        'da6545d2181db8d983f7dcb375ef5866d47c67b1bf31c8cf855ef7437b72656a',\n        '49b96715ab6878a79e78f07ce5680c5d6673051b4935bd897fea824b77dc208a'\n      ],\n      [\n        'c40747cc9d012cb1a13b8148309c6de7ec25d6945d657146b9d5994b8feb1111',\n        '5ca560753be2a12fc6de6caf2cb489565db936156b9514e1bb5e83037e0fa2d4'\n      ],\n      [\n        '4e42c8ec82c99798ccf3a610be870e78338c7f713348bd34c8203ef4037f3502',\n        '7571d74ee5e0fb92a7a8b33a07783341a5492144cc54bcc40a94473693606437'\n      ],\n      [\n        '3775ab7089bc6af823aba2e1af70b236d251cadb0c86743287522a1b3b0dedea',\n        'be52d107bcfa09d8bcb9736a828cfa7fac8db17bf7a76a2c42ad961409018cf7'\n      ],\n      [\n        'cee31cbf7e34ec379d94fb814d3d775ad954595d1314ba8846959e3e82f74e26',\n        '8fd64a14c06b589c26b947ae2bcf6bfa0149ef0be14ed4d80f448a01c43b1c6d'\n      ],\n      [\n        'b4f9eaea09b6917619f6ea6a4eb5464efddb58fd45b1ebefcdc1a01d08b47986',\n        '39e5c9925b5a54b07433a4f18c61726f8bb131c012ca542eb24a8ac07200682a'\n      ],\n      [\n        'd4263dfc3d2df923a0179a48966d30ce84e2515afc3dccc1b77907792ebcc60e',\n        '62dfaf07a0f78feb30e30d6295853ce189e127760ad6cf7fae164e122a208d54'\n      ],\n      [\n        '48457524820fa65a4f8d35eb6930857c0032acc0a4a2de422233eeda897612c4',\n        '25a748ab367979d98733c38a1fa1c2e7dc6cc07db2d60a9ae7a76aaa49bd0f77'\n      ],\n      [\n        'dfeeef1881101f2cb11644f3a2afdfc2045e19919152923f367a1767c11cceda',\n        'ecfb7056cf1de042f9420bab396793c0c390bde74b4bbdff16a83ae09a9a7517'\n      ],\n      [\n        '6d7ef6b17543f8373c573f44e1f389835d89bcbc6062ced36c82df83b8fae859',\n        'cd450ec335438986dfefa10c57fea9bcc521a0959b2d80bbf74b190dca712d10'\n      ],\n      [\n        'e75605d59102a5a2684500d3b991f2e3f3c88b93225547035af25af66e04541f',\n        'f5c54754a8f71ee540b9b48728473e314f729ac5308b06938360990e2bfad125'\n      ],\n      [\n        'eb98660f4c4dfaa06a2be453d5020bc99a0c2e60abe388457dd43fefb1ed620c',\n        '6cb9a8876d9cb8520609af3add26cd20a0a7cd8a9411131ce85f44100099223e'\n      ],\n      [\n        '13e87b027d8514d35939f2e6892b19922154596941888336dc3563e3b8dba942',\n        'fef5a3c68059a6dec5d624114bf1e91aac2b9da568d6abeb2570d55646b8adf1'\n      ],\n      [\n        'ee163026e9fd6fe017c38f06a5be6fc125424b371ce2708e7bf4491691e5764a',\n        '1acb250f255dd61c43d94ccc670d0f58f49ae3fa15b96623e5430da0ad6c62b2'\n      ],\n      [\n        'b268f5ef9ad51e4d78de3a750c2dc89b1e626d43505867999932e5db33af3d80',\n        '5f310d4b3c99b9ebb19f77d41c1dee018cf0d34fd4191614003e945a1216e423'\n      ],\n      [\n        'ff07f3118a9df035e9fad85eb6c7bfe42b02f01ca99ceea3bf7ffdba93c4750d',\n        '438136d603e858a3a5c440c38eccbaddc1d2942114e2eddd4740d098ced1f0d8'\n      ],\n      [\n        '8d8b9855c7c052a34146fd20ffb658bea4b9f69e0d825ebec16e8c3ce2b526a1',\n        'cdb559eedc2d79f926baf44fb84ea4d44bcf50fee51d7ceb30e2e7f463036758'\n      ],\n      [\n        '52db0b5384dfbf05bfa9d472d7ae26dfe4b851ceca91b1eba54263180da32b63',\n        'c3b997d050ee5d423ebaf66a6db9f57b3180c902875679de924b69d84a7b375'\n      ],\n      [\n        'e62f9490d3d51da6395efd24e80919cc7d0f29c3f3fa48c6fff543becbd43352',\n        '6d89ad7ba4876b0b22c2ca280c682862f342c8591f1daf5170e07bfd9ccafa7d'\n      ],\n      [\n        '7f30ea2476b399b4957509c88f77d0191afa2ff5cb7b14fd6d8e7d65aaab1193',\n        'ca5ef7d4b231c94c3b15389a5f6311e9daff7bb67b103e9880ef4bff637acaec'\n      ],\n      [\n        '5098ff1e1d9f14fb46a210fada6c903fef0fb7b4a1dd1d9ac60a0361800b7a00',\n        '9731141d81fc8f8084d37c6e7542006b3ee1b40d60dfe5362a5b132fd17ddc0'\n      ],\n      [\n        '32b78c7de9ee512a72895be6b9cbefa6e2f3c4ccce445c96b9f2c81e2778ad58',\n        'ee1849f513df71e32efc3896ee28260c73bb80547ae2275ba497237794c8753c'\n      ],\n      [\n        'e2cb74fddc8e9fbcd076eef2a7c72b0ce37d50f08269dfc074b581550547a4f7',\n        'd3aa2ed71c9dd2247a62df062736eb0baddea9e36122d2be8641abcb005cc4a4'\n      ],\n      [\n        '8438447566d4d7bedadc299496ab357426009a35f235cb141be0d99cd10ae3a8',\n        'c4e1020916980a4da5d01ac5e6ad330734ef0d7906631c4f2390426b2edd791f'\n      ],\n      [\n        '4162d488b89402039b584c6fc6c308870587d9c46f660b878ab65c82c711d67e',\n        '67163e903236289f776f22c25fb8a3afc1732f2b84b4e95dbda47ae5a0852649'\n      ],\n      [\n        '3fad3fa84caf0f34f0f89bfd2dcf54fc175d767aec3e50684f3ba4a4bf5f683d',\n        'cd1bc7cb6cc407bb2f0ca647c718a730cf71872e7d0d2a53fa20efcdfe61826'\n      ],\n      [\n        '674f2600a3007a00568c1a7ce05d0816c1fb84bf1370798f1c69532faeb1a86b',\n        '299d21f9413f33b3edf43b257004580b70db57da0b182259e09eecc69e0d38a5'\n      ],\n      [\n        'd32f4da54ade74abb81b815ad1fb3b263d82d6c692714bcff87d29bd5ee9f08f',\n        'f9429e738b8e53b968e99016c059707782e14f4535359d582fc416910b3eea87'\n      ],\n      [\n        '30e4e670435385556e593657135845d36fbb6931f72b08cb1ed954f1e3ce3ff6',\n        '462f9bce619898638499350113bbc9b10a878d35da70740dc695a559eb88db7b'\n      ],\n      [\n        'be2062003c51cc3004682904330e4dee7f3dcd10b01e580bf1971b04d4cad297',\n        '62188bc49d61e5428573d48a74e1c655b1c61090905682a0d5558ed72dccb9bc'\n      ],\n      [\n        '93144423ace3451ed29e0fb9ac2af211cb6e84a601df5993c419859fff5df04a',\n        '7c10dfb164c3425f5c71a3f9d7992038f1065224f72bb9d1d902a6d13037b47c'\n      ],\n      [\n        'b015f8044f5fcbdcf21ca26d6c34fb8197829205c7b7d2a7cb66418c157b112c',\n        'ab8c1e086d04e813744a655b2df8d5f83b3cdc6faa3088c1d3aea1454e3a1d5f'\n      ],\n      [\n        'd5e9e1da649d97d89e4868117a465a3a4f8a18de57a140d36b3f2af341a21b52',\n        '4cb04437f391ed73111a13cc1d4dd0db1693465c2240480d8955e8592f27447a'\n      ],\n      [\n        'd3ae41047dd7ca065dbf8ed77b992439983005cd72e16d6f996a5316d36966bb',\n        'bd1aeb21ad22ebb22a10f0303417c6d964f8cdd7df0aca614b10dc14d125ac46'\n      ],\n      [\n        '463e2763d885f958fc66cdd22800f0a487197d0a82e377b49f80af87c897b065',\n        'bfefacdb0e5d0fd7df3a311a94de062b26b80c61fbc97508b79992671ef7ca7f'\n      ],\n      [\n        '7985fdfd127c0567c6f53ec1bb63ec3158e597c40bfe747c83cddfc910641917',\n        '603c12daf3d9862ef2b25fe1de289aed24ed291e0ec6708703a5bd567f32ed03'\n      ],\n      [\n        '74a1ad6b5f76e39db2dd249410eac7f99e74c59cb83d2d0ed5ff1543da7703e9',\n        'cc6157ef18c9c63cd6193d83631bbea0093e0968942e8c33d5737fd790e0db08'\n      ],\n      [\n        '30682a50703375f602d416664ba19b7fc9bab42c72747463a71d0896b22f6da3',\n        '553e04f6b018b4fa6c8f39e7f311d3176290d0e0f19ca73f17714d9977a22ff8'\n      ],\n      [\n        '9e2158f0d7c0d5f26c3791efefa79597654e7a2b2464f52b1ee6c1347769ef57',\n        '712fcdd1b9053f09003a3481fa7762e9ffd7c8ef35a38509e2fbf2629008373'\n      ],\n      [\n        '176e26989a43c9cfeba4029c202538c28172e566e3c4fce7322857f3be327d66',\n        'ed8cc9d04b29eb877d270b4878dc43c19aefd31f4eee09ee7b47834c1fa4b1c3'\n      ],\n      [\n        '75d46efea3771e6e68abb89a13ad747ecf1892393dfc4f1b7004788c50374da8',\n        '9852390a99507679fd0b86fd2b39a868d7efc22151346e1a3ca4726586a6bed8'\n      ],\n      [\n        '809a20c67d64900ffb698c4c825f6d5f2310fb0451c869345b7319f645605721',\n        '9e994980d9917e22b76b061927fa04143d096ccc54963e6a5ebfa5f3f8e286c1'\n      ],\n      [\n        '1b38903a43f7f114ed4500b4eac7083fdefece1cf29c63528d563446f972c180',\n        '4036edc931a60ae889353f77fd53de4a2708b26b6f5da72ad3394119daf408f9'\n      ]\n    ]\n  }\n};\n\n\n\n// WEBPACK FOOTER //\n// ./node_modules/elliptic/lib/elliptic/precomputed/secp256k1.js","'use strict';\n\nvar BN = require('bn.js');\nvar HmacDRBG = require('hmac-drbg');\nvar elliptic = require('../../elliptic');\nvar utils = elliptic.utils;\nvar assert = utils.assert;\n\nvar KeyPair = require('./key');\nvar Signature = require('./signature');\n\nfunction EC(options) {\n  if (!(this instanceof EC))\n    return new EC(options);\n\n  // Shortcut `elliptic.ec(curve-name)`\n  if (typeof options === 'string') {\n    assert(elliptic.curves.hasOwnProperty(options), 'Unknown curve ' + options);\n\n    options = elliptic.curves[options];\n  }\n\n  // Shortcut for `elliptic.ec(elliptic.curves.curveName)`\n  if (options instanceof elliptic.curves.PresetCurve)\n    options = { curve: options };\n\n  this.curve = options.curve.curve;\n  this.n = this.curve.n;\n  this.nh = this.n.ushrn(1);\n  this.g = this.curve.g;\n\n  // Point on curve\n  this.g = options.curve.g;\n  this.g.precompute(options.curve.n.bitLength() + 1);\n\n  // Hash for function for DRBG\n  this.hash = options.hash || options.curve.hash;\n}\nmodule.exports = EC;\n\nEC.prototype.keyPair = function keyPair(options) {\n  return new KeyPair(this, options);\n};\n\nEC.prototype.keyFromPrivate = function keyFromPrivate(priv, enc) {\n  return KeyPair.fromPrivate(this, priv, enc);\n};\n\nEC.prototype.keyFromPublic = function keyFromPublic(pub, enc) {\n  return KeyPair.fromPublic(this, pub, enc);\n};\n\nEC.prototype.genKeyPair = function genKeyPair(options) {\n  if (!options)\n    options = {};\n\n  // Instantiate Hmac_DRBG\n  var drbg = new HmacDRBG({\n    hash: this.hash,\n    pers: options.pers,\n    persEnc: options.persEnc || 'utf8',\n    entropy: options.entropy || elliptic.rand(this.hash.hmacStrength),\n    entropyEnc: options.entropy && options.entropyEnc || 'utf8',\n    nonce: this.n.toArray()\n  });\n\n  var bytes = this.n.byteLength();\n  var ns2 = this.n.sub(new BN(2));\n  do {\n    var priv = new BN(drbg.generate(bytes));\n    if (priv.cmp(ns2) > 0)\n      continue;\n\n    priv.iaddn(1);\n    return this.keyFromPrivate(priv);\n  } while (true);\n};\n\nEC.prototype._truncateToN = function truncateToN(msg, truncOnly) {\n  var delta = msg.byteLength() * 8 - this.n.bitLength();\n  if (delta > 0)\n    msg = msg.ushrn(delta);\n  if (!truncOnly && msg.cmp(this.n) >= 0)\n    return msg.sub(this.n);\n  else\n    return msg;\n};\n\nEC.prototype.sign = function sign(msg, key, enc, options) {\n  if (typeof enc === 'object') {\n    options = enc;\n    enc = null;\n  }\n  if (!options)\n    options = {};\n\n  key = this.keyFromPrivate(key, enc);\n  msg = this._truncateToN(new BN(msg, 16));\n\n  // Zero-extend key to provide enough entropy\n  var bytes = this.n.byteLength();\n  var bkey = key.getPrivate().toArray('be', bytes);\n\n  // Zero-extend nonce to have the same byte size as N\n  var nonce = msg.toArray('be', bytes);\n\n  // Instantiate Hmac_DRBG\n  var drbg = new HmacDRBG({\n    hash: this.hash,\n    entropy: bkey,\n    nonce: nonce,\n    pers: options.pers,\n    persEnc: options.persEnc || 'utf8'\n  });\n\n  // Number of bytes to generate\n  var ns1 = this.n.sub(new BN(1));\n\n  for (var iter = 0; true; iter++) {\n    var k = options.k ?\n        options.k(iter) :\n        new BN(drbg.generate(this.n.byteLength()));\n    k = this._truncateToN(k, true);\n    if (k.cmpn(1) <= 0 || k.cmp(ns1) >= 0)\n      continue;\n\n    var kp = this.g.mul(k);\n    if (kp.isInfinity())\n      continue;\n\n    var kpX = kp.getX();\n    var r = kpX.umod(this.n);\n    if (r.cmpn(0) === 0)\n      continue;\n\n    var s = k.invm(this.n).mul(r.mul(key.getPrivate()).iadd(msg));\n    s = s.umod(this.n);\n    if (s.cmpn(0) === 0)\n      continue;\n\n    var recoveryParam = (kp.getY().isOdd() ? 1 : 0) |\n                        (kpX.cmp(r) !== 0 ? 2 : 0);\n\n    // Use complement of `s`, if it is > `n / 2`\n    if (options.canonical && s.cmp(this.nh) > 0) {\n      s = this.n.sub(s);\n      recoveryParam ^= 1;\n    }\n\n    return new Signature({ r: r, s: s, recoveryParam: recoveryParam });\n  }\n};\n\nEC.prototype.verify = function verify(msg, signature, key, enc) {\n  msg = this._truncateToN(new BN(msg, 16));\n  key = this.keyFromPublic(key, enc);\n  signature = new Signature(signature, 'hex');\n\n  // Perform primitive values validation\n  var r = signature.r;\n  var s = signature.s;\n  if (r.cmpn(1) < 0 || r.cmp(this.n) >= 0)\n    return false;\n  if (s.cmpn(1) < 0 || s.cmp(this.n) >= 0)\n    return false;\n\n  // Validate signature\n  var sinv = s.invm(this.n);\n  var u1 = sinv.mul(msg).umod(this.n);\n  var u2 = sinv.mul(r).umod(this.n);\n\n  if (!this.curve._maxwellTrick) {\n    var p = this.g.mulAdd(u1, key.getPublic(), u2);\n    if (p.isInfinity())\n      return false;\n\n    return p.getX().umod(this.n).cmp(r) === 0;\n  }\n\n  // NOTE: Greg Maxwell's trick, inspired by:\n  // https://git.io/vad3K\n\n  var p = this.g.jmulAdd(u1, key.getPublic(), u2);\n  if (p.isInfinity())\n    return false;\n\n  // Compare `p.x` of Jacobian point with `r`,\n  // this will do `p.x == r * p.z^2` instead of multiplying `p.x` by the\n  // inverse of `p.z^2`\n  return p.eqXToP(r);\n};\n\nEC.prototype.recoverPubKey = function(msg, signature, j, enc) {\n  assert((3 & j) === j, 'The recovery param is more than two bits');\n  signature = new Signature(signature, enc);\n\n  var n = this.n;\n  var e = new BN(msg);\n  var r = signature.r;\n  var s = signature.s;\n\n  // A set LSB signifies that the y-coordinate is odd\n  var isYOdd = j & 1;\n  var isSecondKey = j >> 1;\n  if (r.cmp(this.curve.p.umod(this.curve.n)) >= 0 && isSecondKey)\n    throw new Error('Unable to find sencond key candinate');\n\n  // 1.1. Let x = r + jn.\n  if (isSecondKey)\n    r = this.curve.pointFromX(r.add(this.curve.n), isYOdd);\n  else\n    r = this.curve.pointFromX(r, isYOdd);\n\n  var rInv = signature.r.invm(n);\n  var s1 = n.sub(e).mul(rInv).umod(n);\n  var s2 = s.mul(rInv).umod(n);\n\n  // 1.6.1 Compute Q = r^-1 (sR -  eG)\n  //               Q = r^-1 (sR + -eG)\n  return this.g.mulAdd(s1, r, s2);\n};\n\nEC.prototype.getKeyRecoveryParam = function(e, signature, Q, enc) {\n  signature = new Signature(signature, enc);\n  if (signature.recoveryParam !== null)\n    return signature.recoveryParam;\n\n  for (var i = 0; i < 4; i++) {\n    var Qprime;\n    try {\n      Qprime = this.recoverPubKey(e, signature, i);\n    } catch (e) {\n      continue;\n    }\n\n    if (Qprime.eq(Q))\n      return i;\n  }\n  throw new Error('Unable to find valid recovery factor');\n};\n\n\n\n// WEBPACK FOOTER //\n// ./node_modules/elliptic/lib/elliptic/ec/index.js","'use strict';\n\nvar hash = require('hash.js');\nvar utils = require('minimalistic-crypto-utils');\nvar assert = require('minimalistic-assert');\n\nfunction HmacDRBG(options) {\n  if (!(this instanceof HmacDRBG))\n    return new HmacDRBG(options);\n  this.hash = options.hash;\n  this.predResist = !!options.predResist;\n\n  this.outLen = this.hash.outSize;\n  this.minEntropy = options.minEntropy || this.hash.hmacStrength;\n\n  this._reseed = null;\n  this.reseedInterval = null;\n  this.K = null;\n  this.V = null;\n\n  var entropy = utils.toArray(options.entropy, options.entropyEnc || 'hex');\n  var nonce = utils.toArray(options.nonce, options.nonceEnc || 'hex');\n  var pers = utils.toArray(options.pers, options.persEnc || 'hex');\n  assert(entropy.length >= (this.minEntropy / 8),\n         'Not enough entropy. Minimum is: ' + this.minEntropy + ' bits');\n  this._init(entropy, nonce, pers);\n}\nmodule.exports = HmacDRBG;\n\nHmacDRBG.prototype._init = function init(entropy, nonce, pers) {\n  var seed = entropy.concat(nonce).concat(pers);\n\n  this.K = new Array(this.outLen / 8);\n  this.V = new Array(this.outLen / 8);\n  for (var i = 0; i < this.V.length; i++) {\n    this.K[i] = 0x00;\n    this.V[i] = 0x01;\n  }\n\n  this._update(seed);\n  this._reseed = 1;\n  this.reseedInterval = 0x1000000000000;  // 2^48\n};\n\nHmacDRBG.prototype._hmac = function hmac() {\n  return new hash.hmac(this.hash, this.K);\n};\n\nHmacDRBG.prototype._update = function update(seed) {\n  var kmac = this._hmac()\n                 .update(this.V)\n                 .update([ 0x00 ]);\n  if (seed)\n    kmac = kmac.update(seed);\n  this.K = kmac.digest();\n  this.V = this._hmac().update(this.V).digest();\n  if (!seed)\n    return;\n\n  this.K = this._hmac()\n               .update(this.V)\n               .update([ 0x01 ])\n               .update(seed)\n               .digest();\n  this.V = this._hmac().update(this.V).digest();\n};\n\nHmacDRBG.prototype.reseed = function reseed(entropy, entropyEnc, add, addEnc) {\n  // Optional entropy enc\n  if (typeof entropyEnc !== 'string') {\n    addEnc = add;\n    add = entropyEnc;\n    entropyEnc = null;\n  }\n\n  entropy = utils.toArray(entropy, entropyEnc);\n  add = utils.toArray(add, addEnc);\n\n  assert(entropy.length >= (this.minEntropy / 8),\n         'Not enough entropy. Minimum is: ' + this.minEntropy + ' bits');\n\n  this._update(entropy.concat(add || []));\n  this._reseed = 1;\n};\n\nHmacDRBG.prototype.generate = function generate(len, enc, add, addEnc) {\n  if (this._reseed > this.reseedInterval)\n    throw new Error('Reseed is required');\n\n  // Optional encoding\n  if (typeof enc !== 'string') {\n    addEnc = add;\n    add = enc;\n    enc = null;\n  }\n\n  // Optional additional data\n  if (add) {\n    add = utils.toArray(add, addEnc || 'hex');\n    this._update(add);\n  }\n\n  var temp = [];\n  while (temp.length < len) {\n    this.V = this._hmac().update(this.V).digest();\n    temp = temp.concat(this.V);\n  }\n\n  var res = temp.slice(0, len);\n  this._update(add);\n  this._reseed++;\n  return utils.encode(res, enc);\n};\n\n\n\n// WEBPACK FOOTER //\n// ./node_modules/hmac-drbg/lib/hmac-drbg.js","'use strict';\n\nvar BN = require('bn.js');\nvar elliptic = require('../../elliptic');\nvar utils = elliptic.utils;\nvar assert = utils.assert;\n\nfunction KeyPair(ec, options) {\n  this.ec = ec;\n  this.priv = null;\n  this.pub = null;\n\n  // KeyPair(ec, { priv: ..., pub: ... })\n  if (options.priv)\n    this._importPrivate(options.priv, options.privEnc);\n  if (options.pub)\n    this._importPublic(options.pub, options.pubEnc);\n}\nmodule.exports = KeyPair;\n\nKeyPair.fromPublic = function fromPublic(ec, pub, enc) {\n  if (pub instanceof KeyPair)\n    return pub;\n\n  return new KeyPair(ec, {\n    pub: pub,\n    pubEnc: enc\n  });\n};\n\nKeyPair.fromPrivate = function fromPrivate(ec, priv, enc) {\n  if (priv instanceof KeyPair)\n    return priv;\n\n  return new KeyPair(ec, {\n    priv: priv,\n    privEnc: enc\n  });\n};\n\nKeyPair.prototype.validate = function validate() {\n  var pub = this.getPublic();\n\n  if (pub.isInfinity())\n    return { result: false, reason: 'Invalid public key' };\n  if (!pub.validate())\n    return { result: false, reason: 'Public key is not a point' };\n  if (!pub.mul(this.ec.curve.n).isInfinity())\n    return { result: false, reason: 'Public key * N != O' };\n\n  return { result: true, reason: null };\n};\n\nKeyPair.prototype.getPublic = function getPublic(compact, enc) {\n  // compact is optional argument\n  if (typeof compact === 'string') {\n    enc = compact;\n    compact = null;\n  }\n\n  if (!this.pub)\n    this.pub = this.ec.g.mul(this.priv);\n\n  if (!enc)\n    return this.pub;\n\n  return this.pub.encode(enc, compact);\n};\n\nKeyPair.prototype.getPrivate = function getPrivate(enc) {\n  if (enc === 'hex')\n    return this.priv.toString(16, 2);\n  else\n    return this.priv;\n};\n\nKeyPair.prototype._importPrivate = function _importPrivate(key, enc) {\n  this.priv = new BN(key, enc || 16);\n\n  // Ensure that the priv won't be bigger than n, otherwise we may fail\n  // in fixed multiplication method\n  this.priv = this.priv.umod(this.ec.curve.n);\n};\n\nKeyPair.prototype._importPublic = function _importPublic(key, enc) {\n  if (key.x || key.y) {\n    // Montgomery points only have an `x` coordinate.\n    // Weierstrass/Edwards points on the other hand have both `x` and\n    // `y` coordinates.\n    if (this.ec.curve.type === 'mont') {\n      assert(key.x, 'Need x coordinate');\n    } else if (this.ec.curve.type === 'short' ||\n               this.ec.curve.type === 'edwards') {\n      assert(key.x && key.y, 'Need both x and y coordinate');\n    }\n    this.pub = this.ec.curve.point(key.x, key.y);\n    return;\n  }\n  this.pub = this.ec.curve.decodePoint(key, enc);\n};\n\n// ECDH\nKeyPair.prototype.derive = function derive(pub) {\n  return pub.mul(this.priv).getX();\n};\n\n// ECDSA\nKeyPair.prototype.sign = function sign(msg, enc, options) {\n  return this.ec.sign(msg, this, enc, options);\n};\n\nKeyPair.prototype.verify = function verify(msg, signature) {\n  return this.ec.verify(msg, signature, this);\n};\n\nKeyPair.prototype.inspect = function inspect() {\n  return '<Key priv: ' + (this.priv && this.priv.toString(16, 2)) +\n         ' pub: ' + (this.pub && this.pub.inspect()) + ' >';\n};\n\n\n\n// WEBPACK FOOTER //\n// ./node_modules/elliptic/lib/elliptic/ec/key.js","'use strict';\n\nvar BN = require('bn.js');\n\nvar elliptic = require('../../elliptic');\nvar utils = elliptic.utils;\nvar assert = utils.assert;\n\nfunction Signature(options, enc) {\n  if (options instanceof Signature)\n    return options;\n\n  if (this._importDER(options, enc))\n    return;\n\n  assert(options.r && options.s, 'Signature without r or s');\n  this.r = new BN(options.r, 16);\n  this.s = new BN(options.s, 16);\n  if (options.recoveryParam === undefined)\n    this.recoveryParam = null;\n  else\n    this.recoveryParam = options.recoveryParam;\n}\nmodule.exports = Signature;\n\nfunction Position() {\n  this.place = 0;\n}\n\nfunction getLength(buf, p) {\n  var initial = buf[p.place++];\n  if (!(initial & 0x80)) {\n    return initial;\n  }\n  var octetLen = initial & 0xf;\n  var val = 0;\n  for (var i = 0, off = p.place; i < octetLen; i++, off++) {\n    val <<= 8;\n    val |= buf[off];\n  }\n  p.place = off;\n  return val;\n}\n\nfunction rmPadding(buf) {\n  var i = 0;\n  var len = buf.length - 1;\n  while (!buf[i] && !(buf[i + 1] & 0x80) && i < len) {\n    i++;\n  }\n  if (i === 0) {\n    return buf;\n  }\n  return buf.slice(i);\n}\n\nSignature.prototype._importDER = function _importDER(data, enc) {\n  data = utils.toArray(data, enc);\n  var p = new Position();\n  if (data[p.place++] !== 0x30) {\n    return false;\n  }\n  var len = getLength(data, p);\n  if ((len + p.place) !== data.length) {\n    return false;\n  }\n  if (data[p.place++] !== 0x02) {\n    return false;\n  }\n  var rlen = getLength(data, p);\n  var r = data.slice(p.place, rlen + p.place);\n  p.place += rlen;\n  if (data[p.place++] !== 0x02) {\n    return false;\n  }\n  var slen = getLength(data, p);\n  if (data.length !== slen + p.place) {\n    return false;\n  }\n  var s = data.slice(p.place, slen + p.place);\n  if (r[0] === 0 && (r[1] & 0x80)) {\n    r = r.slice(1);\n  }\n  if (s[0] === 0 && (s[1] & 0x80)) {\n    s = s.slice(1);\n  }\n\n  this.r = new BN(r);\n  this.s = new BN(s);\n  this.recoveryParam = null;\n\n  return true;\n};\n\nfunction constructLength(arr, len) {\n  if (len < 0x80) {\n    arr.push(len);\n    return;\n  }\n  var octets = 1 + (Math.log(len) / Math.LN2 >>> 3);\n  arr.push(octets | 0x80);\n  while (--octets) {\n    arr.push((len >>> (octets << 3)) & 0xff);\n  }\n  arr.push(len);\n}\n\nSignature.prototype.toDER = function toDER(enc) {\n  var r = this.r.toArray();\n  var s = this.s.toArray();\n\n  // Pad values\n  if (r[0] & 0x80)\n    r = [ 0 ].concat(r);\n  // Pad values\n  if (s[0] & 0x80)\n    s = [ 0 ].concat(s);\n\n  r = rmPadding(r);\n  s = rmPadding(s);\n\n  while (!s[0] && !(s[1] & 0x80)) {\n    s = s.slice(1);\n  }\n  var arr = [ 0x02 ];\n  constructLength(arr, r.length);\n  arr = arr.concat(r);\n  arr.push(0x02);\n  constructLength(arr, s.length);\n  var backHalf = arr.concat(s);\n  var res = [ 0x30 ];\n  constructLength(res, backHalf.length);\n  res = res.concat(backHalf);\n  return utils.encode(res, enc);\n};\n\n\n\n// WEBPACK FOOTER //\n// ./node_modules/elliptic/lib/elliptic/ec/signature.js","'use strict';\n\nvar hash = require('hash.js');\nvar elliptic = require('../../elliptic');\nvar utils = elliptic.utils;\nvar assert = utils.assert;\nvar parseBytes = utils.parseBytes;\nvar KeyPair = require('./key');\nvar Signature = require('./signature');\n\nfunction EDDSA(curve) {\n  assert(curve === 'ed25519', 'only tested with ed25519 so far');\n\n  if (!(this instanceof EDDSA))\n    return new EDDSA(curve);\n\n  var curve = elliptic.curves[curve].curve;\n  this.curve = curve;\n  this.g = curve.g;\n  this.g.precompute(curve.n.bitLength() + 1);\n\n  this.pointClass = curve.point().constructor;\n  this.encodingLength = Math.ceil(curve.n.bitLength() / 8);\n  this.hash = hash.sha512;\n}\n\nmodule.exports = EDDSA;\n\n/**\n* @param {Array|String} message - message bytes\n* @param {Array|String|KeyPair} secret - secret bytes or a keypair\n* @returns {Signature} - signature\n*/\nEDDSA.prototype.sign = function sign(message, secret) {\n  message = parseBytes(message);\n  var key = this.keyFromSecret(secret);\n  var r = this.hashInt(key.messagePrefix(), message);\n  var R = this.g.mul(r);\n  var Rencoded = this.encodePoint(R);\n  var s_ = this.hashInt(Rencoded, key.pubBytes(), message)\n               .mul(key.priv());\n  var S = r.add(s_).umod(this.curve.n);\n  return this.makeSignature({ R: R, S: S, Rencoded: Rencoded });\n};\n\n/**\n* @param {Array} message - message bytes\n* @param {Array|String|Signature} sig - sig bytes\n* @param {Array|String|Point|KeyPair} pub - public key\n* @returns {Boolean} - true if public key matches sig of message\n*/\nEDDSA.prototype.verify = function verify(message, sig, pub) {\n  message = parseBytes(message);\n  sig = this.makeSignature(sig);\n  var key = this.keyFromPublic(pub);\n  var h = this.hashInt(sig.Rencoded(), key.pubBytes(), message);\n  var SG = this.g.mul(sig.S());\n  var RplusAh = sig.R().add(key.pub().mul(h));\n  return RplusAh.eq(SG);\n};\n\nEDDSA.prototype.hashInt = function hashInt() {\n  var hash = this.hash();\n  for (var i = 0; i < arguments.length; i++)\n    hash.update(arguments[i]);\n  return utils.intFromLE(hash.digest()).umod(this.curve.n);\n};\n\nEDDSA.prototype.keyFromPublic = function keyFromPublic(pub) {\n  return KeyPair.fromPublic(this, pub);\n};\n\nEDDSA.prototype.keyFromSecret = function keyFromSecret(secret) {\n  return KeyPair.fromSecret(this, secret);\n};\n\nEDDSA.prototype.makeSignature = function makeSignature(sig) {\n  if (sig instanceof Signature)\n    return sig;\n  return new Signature(this, sig);\n};\n\n/**\n* * https://tools.ietf.org/html/draft-josefsson-eddsa-ed25519-03#section-5.2\n*\n* EDDSA defines methods for encoding and decoding points and integers. These are\n* helper convenience methods, that pass along to utility functions implied\n* parameters.\n*\n*/\nEDDSA.prototype.encodePoint = function encodePoint(point) {\n  var enc = point.getY().toArray('le', this.encodingLength);\n  enc[this.encodingLength - 1] |= point.getX().isOdd() ? 0x80 : 0;\n  return enc;\n};\n\nEDDSA.prototype.decodePoint = function decodePoint(bytes) {\n  bytes = utils.parseBytes(bytes);\n\n  var lastIx = bytes.length - 1;\n  var normed = bytes.slice(0, lastIx).concat(bytes[lastIx] & ~0x80);\n  var xIsOdd = (bytes[lastIx] & 0x80) !== 0;\n\n  var y = utils.intFromLE(normed);\n  return this.curve.pointFromY(y, xIsOdd);\n};\n\nEDDSA.prototype.encodeInt = function encodeInt(num) {\n  return num.toArray('le', this.encodingLength);\n};\n\nEDDSA.prototype.decodeInt = function decodeInt(bytes) {\n  return utils.intFromLE(bytes);\n};\n\nEDDSA.prototype.isPoint = function isPoint(val) {\n  return val instanceof this.pointClass;\n};\n\n\n\n// WEBPACK FOOTER //\n// ./node_modules/elliptic/lib/elliptic/eddsa/index.js","'use strict';\n\nvar elliptic = require('../../elliptic');\nvar utils = elliptic.utils;\nvar assert = utils.assert;\nvar parseBytes = utils.parseBytes;\nvar cachedProperty = utils.cachedProperty;\n\n/**\n* @param {EDDSA} eddsa - instance\n* @param {Object} params - public/private key parameters\n*\n* @param {Array<Byte>} [params.secret] - secret seed bytes\n* @param {Point} [params.pub] - public key point (aka `A` in eddsa terms)\n* @param {Array<Byte>} [params.pub] - public key point encoded as bytes\n*\n*/\nfunction KeyPair(eddsa, params) {\n  this.eddsa = eddsa;\n  this._secret = parseBytes(params.secret);\n  if (eddsa.isPoint(params.pub))\n    this._pub = params.pub;\n  else\n    this._pubBytes = parseBytes(params.pub);\n}\n\nKeyPair.fromPublic = function fromPublic(eddsa, pub) {\n  if (pub instanceof KeyPair)\n    return pub;\n  return new KeyPair(eddsa, { pub: pub });\n};\n\nKeyPair.fromSecret = function fromSecret(eddsa, secret) {\n  if (secret instanceof KeyPair)\n    return secret;\n  return new KeyPair(eddsa, { secret: secret });\n};\n\nKeyPair.prototype.secret = function secret() {\n  return this._secret;\n};\n\ncachedProperty(KeyPair, 'pubBytes', function pubBytes() {\n  return this.eddsa.encodePoint(this.pub());\n});\n\ncachedProperty(KeyPair, 'pub', function pub() {\n  if (this._pubBytes)\n    return this.eddsa.decodePoint(this._pubBytes);\n  return this.eddsa.g.mul(this.priv());\n});\n\ncachedProperty(KeyPair, 'privBytes', function privBytes() {\n  var eddsa = this.eddsa;\n  var hash = this.hash();\n  var lastIx = eddsa.encodingLength - 1;\n\n  var a = hash.slice(0, eddsa.encodingLength);\n  a[0] &= 248;\n  a[lastIx] &= 127;\n  a[lastIx] |= 64;\n\n  return a;\n});\n\ncachedProperty(KeyPair, 'priv', function priv() {\n  return this.eddsa.decodeInt(this.privBytes());\n});\n\ncachedProperty(KeyPair, 'hash', function hash() {\n  return this.eddsa.hash().update(this.secret()).digest();\n});\n\ncachedProperty(KeyPair, 'messagePrefix', function messagePrefix() {\n  return this.hash().slice(this.eddsa.encodingLength);\n});\n\nKeyPair.prototype.sign = function sign(message) {\n  assert(this._secret, 'KeyPair can only verify');\n  return this.eddsa.sign(message, this);\n};\n\nKeyPair.prototype.verify = function verify(message, sig) {\n  return this.eddsa.verify(message, sig, this);\n};\n\nKeyPair.prototype.getSecret = function getSecret(enc) {\n  assert(this._secret, 'KeyPair is public only');\n  return utils.encode(this.secret(), enc);\n};\n\nKeyPair.prototype.getPublic = function getPublic(enc) {\n  return utils.encode(this.pubBytes(), enc);\n};\n\nmodule.exports = KeyPair;\n\n\n\n// WEBPACK FOOTER //\n// ./node_modules/elliptic/lib/elliptic/eddsa/key.js","'use strict';\n\nvar BN = require('bn.js');\nvar elliptic = require('../../elliptic');\nvar utils = elliptic.utils;\nvar assert = utils.assert;\nvar cachedProperty = utils.cachedProperty;\nvar parseBytes = utils.parseBytes;\n\n/**\n* @param {EDDSA} eddsa - eddsa instance\n* @param {Array<Bytes>|Object} sig -\n* @param {Array<Bytes>|Point} [sig.R] - R point as Point or bytes\n* @param {Array<Bytes>|bn} [sig.S] - S scalar as bn or bytes\n* @param {Array<Bytes>} [sig.Rencoded] - R point encoded\n* @param {Array<Bytes>} [sig.Sencoded] - S scalar encoded\n*/\nfunction Signature(eddsa, sig) {\n  this.eddsa = eddsa;\n\n  if (typeof sig !== 'object')\n    sig = parseBytes(sig);\n\n  if (Array.isArray(sig)) {\n    sig = {\n      R: sig.slice(0, eddsa.encodingLength),\n      S: sig.slice(eddsa.encodingLength)\n    };\n  }\n\n  assert(sig.R && sig.S, 'Signature without R or S');\n\n  if (eddsa.isPoint(sig.R))\n    this._R = sig.R;\n  if (sig.S instanceof BN)\n    this._S = sig.S;\n\n  this._Rencoded = Array.isArray(sig.R) ? sig.R : sig.Rencoded;\n  this._Sencoded = Array.isArray(sig.S) ? sig.S : sig.Sencoded;\n}\n\ncachedProperty(Signature, 'S', function S() {\n  return this.eddsa.decodeInt(this.Sencoded());\n});\n\ncachedProperty(Signature, 'R', function R() {\n  return this.eddsa.decodePoint(this.Rencoded());\n});\n\ncachedProperty(Signature, 'Rencoded', function Rencoded() {\n  return this.eddsa.encodePoint(this.R());\n});\n\ncachedProperty(Signature, 'Sencoded', function Sencoded() {\n  return this.eddsa.encodeInt(this.S());\n});\n\nSignature.prototype.toBytes = function toBytes() {\n  return this.Rencoded().concat(this.Sencoded());\n};\n\nSignature.prototype.toHex = function toHex() {\n  return utils.encode(this.toBytes(), 'hex').toUpperCase();\n};\n\nmodule.exports = Signature;\n\n\n\n// WEBPACK FOOTER //\n// ./node_modules/elliptic/lib/elliptic/eddsa/signature.js","'use strict'\n\nconst rlp = require('./lib/rlp')  // {decode, toBuffer, isHexPrefixed, stripHexPrefix, padToEven, intToBuffer, safeParseInt, bufferToHex}\n\nconst field_sets = {\n  params:    [\"nonce\",\"gasPrice\",\"gasLimit\",\"to\",\"value\",\"data\"],\n  signature: [\"v\",\"r\",\"s\"]\n}\n\nconst format_fields = function(fields, rawData, to_hex, add_prefix) {\n  let txData = {}\n\n  fields.forEach((field, index) => {\n    if (rawData[index] && rawData[index].length) {\n      txData[field] = to_hex ? rlp.bufferToHex(rawData[index], add_prefix) : rawData[index]\n    }\n  })\n\n  return txData\n}\n\n// ===\n// API\n// ===\nconst unsign = function(rawTx, to_hex=true, add_prefix_txData=true, add_prefix_signature=false) {\n  let rawData\n  if (typeof rawTx === 'string') {\n    rawTx = Buffer.from(rlp.stripHexPrefix(rawTx), 'hex')\n  }\n  if (Buffer.isBuffer(rawTx)) {\n    rawData = rlp.decode(rawTx)\n  }\n\n  if (rawData === undefined)\n    throw new Error('TypeError: raw transaction must be either a Buffer or hex-encoded String value')\n  if (! Array.isArray(rawData))\n    throw new Error('TypeError: raw transaction is not RLP encoded')\n  if (rawData.length < (field_sets.params.length + field_sets.signature.length))\n    throw new Error('FormatError: RLP encoded raw transaction contains too few data fields')\n\n  for (let i=0; i<rawData.length; i++) {\n    rawData[i] = rlp.toBuffer(rawData[i])\n  }\n\n  let txData    = format_fields(field_sets.params,    rawData.slice(0, field_sets.params.length), to_hex, add_prefix_txData)\n  let signature = format_fields(field_sets.signature, rawData.slice(field_sets.params.length),    to_hex, add_prefix_signature)\n\n  let v_hex   = to_hex ? (add_prefix_signature ? rlp.stripHexPrefix(signature.v) : signature.v) : rlp.bufferToHex(signature.v, false)\n  let v_int   = parseInt(v_hex, 16)\n  let chainId = Math.floor((v_int - 35) / 2)\n  if (chainId < 0) chainId = 0\n  txData['chainId'] = chainId\n\n  return {txData, signature}\n}\n\nmodule.exports = unsign\n\n\n\n// WEBPACK FOOTER //\n// ./../node_modules/@warren-bank/ethereumjs-tx-unsign/index.js","// based on:\n//   https://github.com/ethereumjs/rlp/raw/3122e47f7c2ff2c7efa67acfeabe02a5f3a3670a/index.js\n\nconst assert = require('assert')\n\n/**\n * RLP Decoding based on: {@link https://github.com/ethereum/wiki/wiki/%5BEnglish%5D-RLP|RLP}\n * @param {Buffer,String,Integer,Array} data - will be converted to buffer\n * @returns {Array} - returns decode Array of Buffers containg the original message\n **/\nfunction decode (input, stream) {\n  if (!input || input.length === 0) {\n    return new Buffer([])\n  }\n\n  input = toBuffer(input)\n  var decoded = _decode(input)\n\n  if (stream) {\n    return decoded\n  }\n\n  assert.equal(decoded.remainder.length, 0, 'invalid remainder')\n  return decoded.data\n}\n\nfunction toBuffer (v) {\n  if (!Buffer.isBuffer(v)) {\n    if (Array.isArray(v)) {\n      v = Buffer.from(v)\n    } else if (typeof v === 'string') {\n      if (isHexPrefixed(v)) {\n        v = Buffer.from(padToEven(stripHexPrefix(v)), 'hex')\n      } else {\n        v = Buffer.from(v)\n      }\n    } else if (typeof v === 'number') {\n      v = intToBuffer(v)\n    } else if (v === null || v === undefined) {\n      v = Buffer.allocUnsafe(0)\n    } else if (v.toArray) {\n      // converts a BN to a Buffer\n      v = Buffer.from(v.toArray())\n    } else {\n      throw new Error('invalid type')\n    }\n  }\n  return v\n}\n\nfunction isHexPrefixed (str) {\n  return str.slice(0, 2) === '0x'\n}\n\n// Removes 0x from a given String\nfunction stripHexPrefix (str) {\n  if (typeof str !== 'string') {\n    return str\n  }\n  return isHexPrefixed(str) ? str.slice(2) : str\n}\n\nfunction padToEven (a) {\n  if (a.length % 2) a = '0' + a\n  return a\n}\n\nfunction intToBuffer (i) {\n  var hex = intToHex(i)\n  return new Buffer(hex, 'hex')\n}\n\nfunction _decode (input) {\n  var length, llength, data, innerRemainder, d\n  var decoded = []\n  var firstByte = input[0]\n\n  if (firstByte <= 0x7f) {\n    // a single byte whose value is in the [0x00, 0x7f] range, that byte is its own RLP encoding.\n    return {\n      data: input.slice(0, 1),\n      remainder: input.slice(1)\n    }\n  } else if (firstByte <= 0xb7) {\n    // string is 0-55 bytes long. A single byte with value 0x80 plus the length of the string followed by the string\n    // The range of the first byte is [0x80, 0xb7]\n    length = firstByte - 0x7f\n\n    // set 0x80 null to 0\n    if (firstByte === 0x80) {\n      data = new Buffer([])\n    } else {\n      data = input.slice(1, length)\n    }\n\n    if (length === 2 && data[0] < 0x80) {\n      throw new Error('invalid rlp encoding: byte must be less 0x80')\n    }\n\n    return {\n      data: data,\n      remainder: input.slice(length)\n    }\n  } else if (firstByte <= 0xbf) {\n    llength = firstByte - 0xb6\n    length = safeParseInt(input.slice(1, llength).toString('hex'), 16)\n    data = input.slice(llength, length + llength)\n    if (data.length < length) {\n      throw (new Error('invalid RLP'))\n    }\n\n    return {\n      data: data,\n      remainder: input.slice(length + llength)\n    }\n  } else if (firstByte <= 0xf7) {\n    // a list between  0-55 bytes long\n    length = firstByte - 0xbf\n    innerRemainder = input.slice(1, length)\n    while (innerRemainder.length) {\n      d = _decode(innerRemainder)\n      decoded.push(d.data)\n      innerRemainder = d.remainder\n    }\n\n    return {\n      data: decoded,\n      remainder: input.slice(length)\n    }\n  } else {\n    // a list  over 55 bytes long\n    llength = firstByte - 0xf6\n    length = safeParseInt(input.slice(1, llength).toString('hex'), 16)\n    var totalLength = llength + length\n    if (totalLength > input.length) {\n      throw new Error('invalid rlp: total length is larger than the data')\n    }\n\n    innerRemainder = input.slice(llength, totalLength)\n    if (innerRemainder.length === 0) {\n      throw new Error('invalid rlp, List has a invalid length')\n    }\n\n    while (innerRemainder.length) {\n      d = _decode(innerRemainder)\n      decoded.push(d.data)\n      innerRemainder = d.remainder\n    }\n    return {\n      data: decoded,\n      remainder: input.slice(totalLength)\n    }\n  }\n}\n\nfunction safeParseInt (v, base) {\n  if (v.slice(0, 2) === '00') {\n    throw (new Error('invalid RLP: extra zeros'))\n  }\n\n  return parseInt(v, base)\n}\n\nfunction bufferToHex (buf, add_prefix=true) {\n  buf = toBuffer(buf)\n  if ((! buf) || (buf.length === 0))\n    return ''\n  else\n    return (add_prefix ? '0x' : '') + buf.toString('hex')\n}\n\nmodule.exports = {decode, toBuffer, isHexPrefixed, stripHexPrefix, padToEven, intToBuffer, safeParseInt, bufferToHex}\n\n\n\n// WEBPACK FOOTER //\n// ./../node_modules/@warren-bank/ethereumjs-tx-unsign/lib/rlp.js","module.exports = function isBuffer(arg) {\n  return arg && typeof arg === 'object'\n    && typeof arg.copy === 'function'\n    && typeof arg.fill === 'function'\n    && typeof arg.readUInt8 === 'function';\n}\n\n\n// WEBPACK FOOTER //\n// ./node_modules/util/support/isBufferBrowser.js","'use strict'\r\n\r\nvar createKeccak = require('./keccak')\r\nvar createShake = require('./shake')\r\n\r\nmodule.exports = function (KeccakState) {\r\n  var Keccak = createKeccak(KeccakState)\r\n  var Shake = createShake(KeccakState)\r\n\r\n  return function (algorithm, options) {\r\n    var hash = typeof algorithm === 'string' ? algorithm.toLowerCase() : algorithm\r\n    switch (hash) {\r\n      case 'keccak224': return new Keccak(1152, 448, null, 224, options)\r\n      case 'keccak256': return new Keccak(1088, 512, null, 256, options)\r\n      case 'keccak384': return new Keccak(832, 768, null, 384, options)\r\n      case 'keccak512': return new Keccak(576, 1024, null, 512, options)\r\n\r\n      case 'sha3-224': return new Keccak(1152, 448, 0x06, 224, options)\r\n      case 'sha3-256': return new Keccak(1088, 512, 0x06, 256, options)\r\n      case 'sha3-384': return new Keccak(832, 768, 0x06, 384, options)\r\n      case 'sha3-512': return new Keccak(576, 1024, 0x06, 512, options)\r\n\r\n      case 'shake128': return new Shake(1344, 256, 0x1f, options)\r\n      case 'shake256': return new Shake(1088, 512, 0x1f, options)\r\n\r\n      default: throw new Error('Invald algorithm: ' + algorithm)\r\n    }\r\n  }\r\n}\r\n\n\n\n// WEBPACK FOOTER //\n// ./../lib/keccak/api/index.js","'use strict'\r\n\r\nvar Transform = require('stream').Transform\r\nvar inherits  = require('util').inherits\r\n\r\nmodule.exports = function (KeccakState) {\r\n  function Keccak (rate, capacity, delimitedSuffix, hashBitLength, options) {\r\n    Transform.call(this, options)\r\n\r\n    this._rate = rate\r\n    this._capacity = capacity\r\n    this._delimitedSuffix = delimitedSuffix\r\n    this._hashBitLength = hashBitLength\r\n    this._options = options\r\n\r\n    this._state = new KeccakState()\r\n    this._state.initialize(rate, capacity)\r\n    this._finalized = false\r\n  }\r\n\r\n  inherits(Keccak, Transform)\r\n\r\n  Keccak.prototype._transform = function (chunk, encoding, callback) {\r\n    var error = null\r\n    try {\r\n      this.update(chunk, encoding)\r\n    } catch (err) {\r\n      error = err\r\n    }\r\n\r\n    callback(error)\r\n  }\r\n\r\n  Keccak.prototype._flush = function (callback) {\r\n    var error = null\r\n    try {\r\n      this.push(this.digest())\r\n    } catch (err) {\r\n      error = err\r\n    }\r\n\r\n    callback(error)\r\n  }\r\n\r\n  Keccak.prototype.update = function (data, encoding) {\r\n    if (!Buffer.isBuffer(data) && typeof data !== 'string') throw new TypeError('Data must be a string or a buffer')\r\n    if (this._finalized) throw new Error('Digest already called')\r\n    if (!Buffer.isBuffer(data)) data = Buffer.from(data, encoding)\r\n\r\n    this._state.absorb(data)\r\n\r\n    return this\r\n  }\r\n\r\n  Keccak.prototype.digest = function (encoding) {\r\n    if (this._finalized) throw new Error('Digest already called')\r\n    this._finalized = true\r\n\r\n    if (this._delimitedSuffix) this._state.absorbLastFewBits(this._delimitedSuffix)\r\n    var digest = this._state.squeeze(this._hashBitLength / 8)\r\n    if (encoding !== undefined) digest = digest.toString(encoding)\r\n\r\n    this._resetState()\r\n\r\n    return digest\r\n  }\r\n\r\n  // remove result from memory\r\n  Keccak.prototype._resetState = function () {\r\n    this._state.initialize(this._rate, this._capacity)\r\n    return this\r\n  }\r\n\r\n  // because sometimes we need hash right now and little later\r\n  Keccak.prototype._clone = function () {\r\n    var clone = new Keccak(this._rate, this._capacity, this._delimitedSuffix, this._hashBitLength, this._options)\r\n    this._state.copy(clone._state)\r\n    clone._finalized = this._finalized\r\n\r\n    return clone\r\n  }\r\n\r\n  return Keccak\r\n}\r\n\n\n\n// WEBPACK FOOTER //\n// ./../lib/keccak/api/keccak.js","'use strict';\n\n/*<replacement>*/\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar Buffer = require('safe-buffer').Buffer;\n/*</replacement>*/\n\nfunction copyBuffer(src, target, offset) {\n  src.copy(target, offset);\n}\n\nmodule.exports = function () {\n  function BufferList() {\n    _classCallCheck(this, BufferList);\n\n    this.head = null;\n    this.tail = null;\n    this.length = 0;\n  }\n\n  BufferList.prototype.push = function push(v) {\n    var entry = { data: v, next: null };\n    if (this.length > 0) this.tail.next = entry;else this.head = entry;\n    this.tail = entry;\n    ++this.length;\n  };\n\n  BufferList.prototype.unshift = function unshift(v) {\n    var entry = { data: v, next: this.head };\n    if (this.length === 0) this.tail = entry;\n    this.head = entry;\n    ++this.length;\n  };\n\n  BufferList.prototype.shift = function shift() {\n    if (this.length === 0) return;\n    var ret = this.head.data;\n    if (this.length === 1) this.head = this.tail = null;else this.head = this.head.next;\n    --this.length;\n    return ret;\n  };\n\n  BufferList.prototype.clear = function clear() {\n    this.head = this.tail = null;\n    this.length = 0;\n  };\n\n  BufferList.prototype.join = function join(s) {\n    if (this.length === 0) return '';\n    var p = this.head;\n    var ret = '' + p.data;\n    while (p = p.next) {\n      ret += s + p.data;\n    }return ret;\n  };\n\n  BufferList.prototype.concat = function concat(n) {\n    if (this.length === 0) return Buffer.alloc(0);\n    if (this.length === 1) return this.head.data;\n    var ret = Buffer.allocUnsafe(n >>> 0);\n    var p = this.head;\n    var i = 0;\n    while (p) {\n      copyBuffer(p.data, ret, i);\n      i += p.data.length;\n      p = p.next;\n    }\n    return ret;\n  };\n\n  return BufferList;\n}();\n\n\n// WEBPACK FOOTER //\n// ./node_modules/readable-stream/lib/internal/streams/BufferList.js","var apply = Function.prototype.apply;\n\n// DOM APIs, for completeness\n\nexports.setTimeout = function() {\n  return new Timeout(apply.call(setTimeout, window, arguments), clearTimeout);\n};\nexports.setInterval = function() {\n  return new Timeout(apply.call(setInterval, window, arguments), clearInterval);\n};\nexports.clearTimeout =\nexports.clearInterval = function(timeout) {\n  if (timeout) {\n    timeout.close();\n  }\n};\n\nfunction Timeout(id, clearFn) {\n  this._id = id;\n  this._clearFn = clearFn;\n}\nTimeout.prototype.unref = Timeout.prototype.ref = function() {};\nTimeout.prototype.close = function() {\n  this._clearFn.call(window, this._id);\n};\n\n// Does not start the time, just sets up the members needed.\nexports.enroll = function(item, msecs) {\n  clearTimeout(item._idleTimeoutId);\n  item._idleTimeout = msecs;\n};\n\nexports.unenroll = function(item) {\n  clearTimeout(item._idleTimeoutId);\n  item._idleTimeout = -1;\n};\n\nexports._unrefActive = exports.active = function(item) {\n  clearTimeout(item._idleTimeoutId);\n\n  var msecs = item._idleTimeout;\n  if (msecs >= 0) {\n    item._idleTimeoutId = setTimeout(function onTimeout() {\n      if (item._onTimeout)\n        item._onTimeout();\n    }, msecs);\n  }\n};\n\n// setimmediate attaches itself to the global object\nrequire(\"setimmediate\");\nexports.setImmediate = setImmediate;\nexports.clearImmediate = clearImmediate;\n\n\n\n// WEBPACK FOOTER //\n// ./node_modules/timers-browserify/main.js","(function (global, undefined) {\n    \"use strict\";\n\n    if (global.setImmediate) {\n        return;\n    }\n\n    var nextHandle = 1; // Spec says greater than zero\n    var tasksByHandle = {};\n    var currentlyRunningATask = false;\n    var doc = global.document;\n    var registerImmediate;\n\n    function setImmediate(callback) {\n      // Callback can either be a function or a string\n      if (typeof callback !== \"function\") {\n        callback = new Function(\"\" + callback);\n      }\n      // Copy function arguments\n      var args = new Array(arguments.length - 1);\n      for (var i = 0; i < args.length; i++) {\n          args[i] = arguments[i + 1];\n      }\n      // Store and register the task\n      var task = { callback: callback, args: args };\n      tasksByHandle[nextHandle] = task;\n      registerImmediate(nextHandle);\n      return nextHandle++;\n    }\n\n    function clearImmediate(handle) {\n        delete tasksByHandle[handle];\n    }\n\n    function run(task) {\n        var callback = task.callback;\n        var args = task.args;\n        switch (args.length) {\n        case 0:\n            callback();\n            break;\n        case 1:\n            callback(args[0]);\n            break;\n        case 2:\n            callback(args[0], args[1]);\n            break;\n        case 3:\n            callback(args[0], args[1], args[2]);\n            break;\n        default:\n            callback.apply(undefined, args);\n            break;\n        }\n    }\n\n    function runIfPresent(handle) {\n        // From the spec: \"Wait until any invocations of this algorithm started before this one have completed.\"\n        // So if we're currently running a task, we'll need to delay this invocation.\n        if (currentlyRunningATask) {\n            // Delay by doing a setTimeout. setImmediate was tried instead, but in Firefox 7 it generated a\n            // \"too much recursion\" error.\n            setTimeout(runIfPresent, 0, handle);\n        } else {\n            var task = tasksByHandle[handle];\n            if (task) {\n                currentlyRunningATask = true;\n                try {\n                    run(task);\n                } finally {\n                    clearImmediate(handle);\n                    currentlyRunningATask = false;\n                }\n            }\n        }\n    }\n\n    function installNextTickImplementation() {\n        registerImmediate = function(handle) {\n            process.nextTick(function () { runIfPresent(handle); });\n        };\n    }\n\n    function canUsePostMessage() {\n        // The test against `importScripts` prevents this implementation from being installed inside a web worker,\n        // where `global.postMessage` means something completely different and can't be used for this purpose.\n        if (global.postMessage && !global.importScripts) {\n            var postMessageIsAsynchronous = true;\n            var oldOnMessage = global.onmessage;\n            global.onmessage = function() {\n                postMessageIsAsynchronous = false;\n            };\n            global.postMessage(\"\", \"*\");\n            global.onmessage = oldOnMessage;\n            return postMessageIsAsynchronous;\n        }\n    }\n\n    function installPostMessageImplementation() {\n        // Installs an event handler on `global` for the `message` event: see\n        // * https://developer.mozilla.org/en/DOM/window.postMessage\n        // * http://www.whatwg.org/specs/web-apps/current-work/multipage/comms.html#crossDocumentMessages\n\n        var messagePrefix = \"setImmediate$\" + Math.random() + \"$\";\n        var onGlobalMessage = function(event) {\n            if (event.source === global &&\n                typeof event.data === \"string\" &&\n                event.data.indexOf(messagePrefix) === 0) {\n                runIfPresent(+event.data.slice(messagePrefix.length));\n            }\n        };\n\n        if (global.addEventListener) {\n            global.addEventListener(\"message\", onGlobalMessage, false);\n        } else {\n            global.attachEvent(\"onmessage\", onGlobalMessage);\n        }\n\n        registerImmediate = function(handle) {\n            global.postMessage(messagePrefix + handle, \"*\");\n        };\n    }\n\n    function installMessageChannelImplementation() {\n        var channel = new MessageChannel();\n        channel.port1.onmessage = function(event) {\n            var handle = event.data;\n            runIfPresent(handle);\n        };\n\n        registerImmediate = function(handle) {\n            channel.port2.postMessage(handle);\n        };\n    }\n\n    function installReadyStateChangeImplementation() {\n        var html = doc.documentElement;\n        registerImmediate = function(handle) {\n            // Create a <script> element; its readystatechange event will be fired asynchronously once it is inserted\n            // into the document. Do so, thus queuing up the task. Remember to clean up once it's been called.\n            var script = doc.createElement(\"script\");\n            script.onreadystatechange = function () {\n                runIfPresent(handle);\n                script.onreadystatechange = null;\n                html.removeChild(script);\n                script = null;\n            };\n            html.appendChild(script);\n        };\n    }\n\n    function installSetTimeoutImplementation() {\n        registerImmediate = function(handle) {\n            setTimeout(runIfPresent, 0, handle);\n        };\n    }\n\n    // If supported, we should attach to the prototype of global, since that is where setTimeout et al. live.\n    var attachTo = Object.getPrototypeOf && Object.getPrototypeOf(global);\n    attachTo = attachTo && attachTo.setTimeout ? attachTo : global;\n\n    // Don't get fooled by e.g. browserify environments.\n    if ({}.toString.call(global.process) === \"[object process]\") {\n        // For Node.js before 0.9\n        installNextTickImplementation();\n\n    } else if (canUsePostMessage()) {\n        // For non-IE10 modern browsers\n        installPostMessageImplementation();\n\n    } else if (global.MessageChannel) {\n        // For web workers, where supported\n        installMessageChannelImplementation();\n\n    } else if (doc && \"onreadystatechange\" in doc.createElement(\"script\")) {\n        // For IE 6–8\n        installReadyStateChangeImplementation();\n\n    } else {\n        // For older browsers\n        installSetTimeoutImplementation();\n    }\n\n    attachTo.setImmediate = setImmediate;\n    attachTo.clearImmediate = clearImmediate;\n}(typeof self === \"undefined\" ? typeof global === \"undefined\" ? this : global : self));\n\n\n\n// WEBPACK FOOTER //\n// ./node_modules/setimmediate/setImmediate.js","\n/**\n * Module exports.\n */\n\nmodule.exports = deprecate;\n\n/**\n * Mark that a method should not be used.\n * Returns a modified function which warns once by default.\n *\n * If `localStorage.noDeprecation = true` is set, then it is a no-op.\n *\n * If `localStorage.throwDeprecation = true` is set, then deprecated functions\n * will throw an Error when invoked.\n *\n * If `localStorage.traceDeprecation = true` is set, then deprecated functions\n * will invoke `console.trace()` instead of `console.error()`.\n *\n * @param {Function} fn - the function to deprecate\n * @param {String} msg - the string to print to the console when `fn` is invoked\n * @returns {Function} a new \"deprecated\" version of `fn`\n * @api public\n */\n\nfunction deprecate (fn, msg) {\n  if (config('noDeprecation')) {\n    return fn;\n  }\n\n  var warned = false;\n  function deprecated() {\n    if (!warned) {\n      if (config('throwDeprecation')) {\n        throw new Error(msg);\n      } else if (config('traceDeprecation')) {\n        console.trace(msg);\n      } else {\n        console.warn(msg);\n      }\n      warned = true;\n    }\n    return fn.apply(this, arguments);\n  }\n\n  return deprecated;\n}\n\n/**\n * Checks `localStorage` for boolean values for the given `name`.\n *\n * @param {String} name\n * @returns {Boolean}\n * @api private\n */\n\nfunction config (name) {\n  // accessing global.localStorage can trigger a DOMException in sandboxed iframes\n  try {\n    if (!global.localStorage) return false;\n  } catch (_) {\n    return false;\n  }\n  var val = global.localStorage[name];\n  if (null == val) return false;\n  return String(val).toLowerCase() === 'true';\n}\n\n\n\n// WEBPACK FOOTER //\n// ./node_modules/util-deprecate/browser.js","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// a passthrough stream.\n// basically just the most minimal sort of Transform stream.\n// Every written chunk gets output as-is.\n\n'use strict';\n\nmodule.exports = PassThrough;\n\nvar Transform = require('./_stream_transform');\n\n/*<replacement>*/\nvar util = require('core-util-is');\nutil.inherits = require('inherits');\n/*</replacement>*/\n\nutil.inherits(PassThrough, Transform);\n\nfunction PassThrough(options) {\n  if (!(this instanceof PassThrough)) return new PassThrough(options);\n\n  Transform.call(this, options);\n}\n\nPassThrough.prototype._transform = function (chunk, encoding, cb) {\n  cb(null, chunk);\n};\n\n\n// WEBPACK FOOTER //\n// ./node_modules/readable-stream/lib/_stream_passthrough.js","module.exports = require('./lib/_stream_writable.js');\n\n\n\n// WEBPACK FOOTER //\n// ./node_modules/readable-stream/writable-browser.js","module.exports = require('./lib/_stream_duplex.js');\n\n\n\n// WEBPACK FOOTER //\n// ./node_modules/readable-stream/duplex-browser.js","module.exports = require('./readable').Transform\n\n\n\n// WEBPACK FOOTER //\n// ./node_modules/readable-stream/transform.js","module.exports = require('./readable').PassThrough\n\n\n\n// WEBPACK FOOTER //\n// ./node_modules/readable-stream/passthrough.js","'use strict'\r\n\r\nvar Transform = require('stream').Transform\r\nvar inherits  = require('util').inherits\r\n\r\nmodule.exports = function (KeccakState) {\r\n  function Shake (rate, capacity, delimitedSuffix, options) {\r\n    Transform.call(this, options)\r\n\r\n    this._rate = rate\r\n    this._capacity = capacity\r\n    this._delimitedSuffix = delimitedSuffix\r\n    this._options = options\r\n\r\n    this._state = new KeccakState()\r\n    this._state.initialize(rate, capacity)\r\n    this._finalized = false\r\n  }\r\n\r\n  inherits(Shake, Transform)\r\n\r\n  Shake.prototype._transform = function (chunk, encoding, callback) {\r\n    var error = null\r\n    try {\r\n      this.update(chunk, encoding)\r\n    } catch (err) {\r\n      error = err\r\n    }\r\n\r\n    callback(error)\r\n  }\r\n\r\n  Shake.prototype._flush = function () {}\r\n\r\n  Shake.prototype._read = function (size) {\r\n    this.push(this.squeeze(size))\r\n  }\r\n\r\n  Shake.prototype.update = function (data, encoding) {\r\n    if (!Buffer.isBuffer(data) && typeof data !== 'string') throw new TypeError('Data must be a string or a buffer')\r\n    if (this._finalized) throw new Error('Squeeze already called')\r\n    if (!Buffer.isBuffer(data)) data = Buffer.from(data, encoding)\r\n\r\n    this._state.absorb(data)\r\n\r\n    return this\r\n  }\r\n\r\n  Shake.prototype.squeeze = function (dataByteLength, encoding) {\r\n    if (!this._finalized) {\r\n      this._finalized = true\r\n      this._state.absorbLastFewBits(this._delimitedSuffix)\r\n    }\r\n\r\n    var data = this._state.squeeze(dataByteLength)\r\n    if (encoding !== undefined) data = data.toString(encoding)\r\n\r\n    return data\r\n  }\r\n\r\n  Shake.prototype._resetState = function () {\r\n    this._state.initialize(this._rate, this._capacity)\r\n    return this\r\n  }\r\n\r\n  Shake.prototype._clone = function () {\r\n    var clone = new Shake(this._rate, this._capacity, this._delimitedSuffix, this._options)\r\n    this._state.copy(clone._state)\r\n    clone._finalized = this._finalized\r\n\r\n    return clone\r\n  }\r\n\r\n  return Shake\r\n}\r\n\n\n\n// WEBPACK FOOTER //\n// ./../lib/keccak/api/shake.js","'use strict'\r\n\r\nvar keccakState = require('./keccak-state-unroll')\r\n\r\nfunction Keccak () {\r\n  // much faster than `new Array(50)`\r\n  this.state = [\r\n    0, 0, 0, 0, 0,\r\n    0, 0, 0, 0, 0,\r\n    0, 0, 0, 0, 0,\r\n    0, 0, 0, 0, 0,\r\n    0, 0, 0, 0, 0\r\n  ]\r\n\r\n  this.blockSize = null\r\n  this.count = 0\r\n  this.squeezing = false\r\n}\r\n\r\nKeccak.prototype.initialize = function (rate, capacity) {\r\n  for (var i = 0; i < 50; ++i) this.state[i] = 0\r\n  this.blockSize = rate / 8\r\n  this.count = 0\r\n  this.squeezing = false\r\n}\r\n\r\nKeccak.prototype.absorb = function (data) {\r\n  for (var i = 0; i < data.length; ++i) {\r\n    this.state[~~(this.count / 4)] ^= data[i] << (8 * (this.count % 4))\r\n    this.count += 1\r\n    if (this.count === this.blockSize) {\r\n      keccakState.p1600(this.state)\r\n      this.count = 0\r\n    }\r\n  }\r\n}\r\n\r\nKeccak.prototype.absorbLastFewBits = function (bits) {\r\n  this.state[~~(this.count / 4)] ^= bits << (8 * (this.count % 4))\r\n  if ((bits & 0x80) !== 0 && this.count === (this.blockSize - 1)) keccakState.p1600(this.state)\r\n  this.state[~~((this.blockSize - 1) / 4)] ^= 0x80 << (8 * ((this.blockSize - 1) % 4))\r\n  keccakState.p1600(this.state)\r\n  this.count = 0\r\n  this.squeezing = true\r\n}\r\n\r\nKeccak.prototype.squeeze = function (length) {\r\n  if (!this.squeezing) this.absorbLastFewBits(0x01)\r\n\r\n  var output = Buffer.alloc(length)\r\n  for (var i = 0; i < length; ++i) {\r\n    output[i] = (this.state[~~(this.count / 4)] >>> (8 * (this.count % 4))) & 0xff\r\n    this.count += 1\r\n    if (this.count === this.blockSize) {\r\n      keccakState.p1600(this.state)\r\n      this.count = 0\r\n    }\r\n  }\r\n\r\n  return output\r\n}\r\n\r\nKeccak.prototype.copy = function (dest) {\r\n  for (var i = 0; i < 50; ++i) dest.state[i] = this.state[i]\r\n  dest.blockSize = this.blockSize\r\n  dest.count = this.count\r\n  dest.squeezing = this.squeezing\r\n}\r\n\r\nmodule.exports = Keccak\r\n\n\n\n// WEBPACK FOOTER //\n// ./../lib/keccak/keccak.js","'use strict'\r\n\r\nvar P1600_ROUND_CONSTANTS = [1, 0, 32898, 0, 32906, 2147483648, 2147516416, 2147483648, 32907, 0, 2147483649, 0, 2147516545, 2147483648, 32777, 2147483648, 138, 0, 136, 0, 2147516425, 0, 2147483658, 0, 2147516555, 0, 139, 2147483648, 32905, 2147483648, 32771, 2147483648, 32770, 2147483648, 128, 2147483648, 32778, 0, 2147483658, 2147483648, 2147516545, 2147483648, 32896, 2147483648, 2147483649, 0, 2147516424, 2147483648]\r\n\r\nexports.p1600 = function (s) {\r\n  for (var round = 0; round < 24; ++round) {\r\n    // theta\r\n    var lo0 = s[0] ^ s[10] ^ s[20] ^ s[30] ^ s[40]\r\n    var hi0 = s[1] ^ s[11] ^ s[21] ^ s[31] ^ s[41]\r\n    var lo1 = s[2] ^ s[12] ^ s[22] ^ s[32] ^ s[42]\r\n    var hi1 = s[3] ^ s[13] ^ s[23] ^ s[33] ^ s[43]\r\n    var lo2 = s[4] ^ s[14] ^ s[24] ^ s[34] ^ s[44]\r\n    var hi2 = s[5] ^ s[15] ^ s[25] ^ s[35] ^ s[45]\r\n    var lo3 = s[6] ^ s[16] ^ s[26] ^ s[36] ^ s[46]\r\n    var hi3 = s[7] ^ s[17] ^ s[27] ^ s[37] ^ s[47]\r\n    var lo4 = s[8] ^ s[18] ^ s[28] ^ s[38] ^ s[48]\r\n    var hi4 = s[9] ^ s[19] ^ s[29] ^ s[39] ^ s[49]\r\n\r\n    var lo = lo4 ^ (lo1 << 1 | hi1 >>> 31)\r\n    var hi = hi4 ^ (hi1 << 1 | lo1 >>> 31)\r\n    var t1slo0 = s[0] ^ lo\r\n    var t1shi0 = s[1] ^ hi\r\n    var t1slo5 = s[10] ^ lo\r\n    var t1shi5 = s[11] ^ hi\r\n    var t1slo10 = s[20] ^ lo\r\n    var t1shi10 = s[21] ^ hi\r\n    var t1slo15 = s[30] ^ lo\r\n    var t1shi15 = s[31] ^ hi\r\n    var t1slo20 = s[40] ^ lo\r\n    var t1shi20 = s[41] ^ hi\r\n    lo = lo0 ^ (lo2 << 1 | hi2 >>> 31)\r\n    hi = hi0 ^ (hi2 << 1 | lo2 >>> 31)\r\n    var t1slo1 = s[2] ^ lo\r\n    var t1shi1 = s[3] ^ hi\r\n    var t1slo6 = s[12] ^ lo\r\n    var t1shi6 = s[13] ^ hi\r\n    var t1slo11 = s[22] ^ lo\r\n    var t1shi11 = s[23] ^ hi\r\n    var t1slo16 = s[32] ^ lo\r\n    var t1shi16 = s[33] ^ hi\r\n    var t1slo21 = s[42] ^ lo\r\n    var t1shi21 = s[43] ^ hi\r\n    lo = lo1 ^ (lo3 << 1 | hi3 >>> 31)\r\n    hi = hi1 ^ (hi3 << 1 | lo3 >>> 31)\r\n    var t1slo2 = s[4] ^ lo\r\n    var t1shi2 = s[5] ^ hi\r\n    var t1slo7 = s[14] ^ lo\r\n    var t1shi7 = s[15] ^ hi\r\n    var t1slo12 = s[24] ^ lo\r\n    var t1shi12 = s[25] ^ hi\r\n    var t1slo17 = s[34] ^ lo\r\n    var t1shi17 = s[35] ^ hi\r\n    var t1slo22 = s[44] ^ lo\r\n    var t1shi22 = s[45] ^ hi\r\n    lo = lo2 ^ (lo4 << 1 | hi4 >>> 31)\r\n    hi = hi2 ^ (hi4 << 1 | lo4 >>> 31)\r\n    var t1slo3 = s[6] ^ lo\r\n    var t1shi3 = s[7] ^ hi\r\n    var t1slo8 = s[16] ^ lo\r\n    var t1shi8 = s[17] ^ hi\r\n    var t1slo13 = s[26] ^ lo\r\n    var t1shi13 = s[27] ^ hi\r\n    var t1slo18 = s[36] ^ lo\r\n    var t1shi18 = s[37] ^ hi\r\n    var t1slo23 = s[46] ^ lo\r\n    var t1shi23 = s[47] ^ hi\r\n    lo = lo3 ^ (lo0 << 1 | hi0 >>> 31)\r\n    hi = hi3 ^ (hi0 << 1 | lo0 >>> 31)\r\n    var t1slo4 = s[8] ^ lo\r\n    var t1shi4 = s[9] ^ hi\r\n    var t1slo9 = s[18] ^ lo\r\n    var t1shi9 = s[19] ^ hi\r\n    var t1slo14 = s[28] ^ lo\r\n    var t1shi14 = s[29] ^ hi\r\n    var t1slo19 = s[38] ^ lo\r\n    var t1shi19 = s[39] ^ hi\r\n    var t1slo24 = s[48] ^ lo\r\n    var t1shi24 = s[49] ^ hi\r\n\r\n    // rho & pi\r\n    var t2slo0 = t1slo0\r\n    var t2shi0 = t1shi0\r\n    var t2slo16 = (t1shi5 << 4 | t1slo5 >>> 28)\r\n    var t2shi16 = (t1slo5 << 4 | t1shi5 >>> 28)\r\n    var t2slo7 = (t1slo10 << 3 | t1shi10 >>> 29)\r\n    var t2shi7 = (t1shi10 << 3 | t1slo10 >>> 29)\r\n    var t2slo23 = (t1shi15 << 9 | t1slo15 >>> 23)\r\n    var t2shi23 = (t1slo15 << 9 | t1shi15 >>> 23)\r\n    var t2slo14 = (t1slo20 << 18 | t1shi20 >>> 14)\r\n    var t2shi14 = (t1shi20 << 18 | t1slo20 >>> 14)\r\n    var t2slo10 = (t1slo1 << 1 | t1shi1 >>> 31)\r\n    var t2shi10 = (t1shi1 << 1 | t1slo1 >>> 31)\r\n    var t2slo1 = (t1shi6 << 12 | t1slo6 >>> 20)\r\n    var t2shi1 = (t1slo6 << 12 | t1shi6 >>> 20)\r\n    var t2slo17 = (t1slo11 << 10 | t1shi11 >>> 22)\r\n    var t2shi17 = (t1shi11 << 10 | t1slo11 >>> 22)\r\n    var t2slo8 = (t1shi16 << 13 | t1slo16 >>> 19)\r\n    var t2shi8 = (t1slo16 << 13 | t1shi16 >>> 19)\r\n    var t2slo24 = (t1slo21 << 2 | t1shi21 >>> 30)\r\n    var t2shi24 = (t1shi21 << 2 | t1slo21 >>> 30)\r\n    var t2slo20 = (t1shi2 << 30 | t1slo2 >>> 2)\r\n    var t2shi20 = (t1slo2 << 30 | t1shi2 >>> 2)\r\n    var t2slo11 = (t1slo7 << 6 | t1shi7 >>> 26)\r\n    var t2shi11 = (t1shi7 << 6 | t1slo7 >>> 26)\r\n    var t2slo2 = (t1shi12 << 11 | t1slo12 >>> 21)\r\n    var t2shi2 = (t1slo12 << 11 | t1shi12 >>> 21)\r\n    var t2slo18 = (t1slo17 << 15 | t1shi17 >>> 17)\r\n    var t2shi18 = (t1shi17 << 15 | t1slo17 >>> 17)\r\n    var t2slo9 = (t1shi22 << 29 | t1slo22 >>> 3)\r\n    var t2shi9 = (t1slo22 << 29 | t1shi22 >>> 3)\r\n    var t2slo5 = (t1slo3 << 28 | t1shi3 >>> 4)\r\n    var t2shi5 = (t1shi3 << 28 | t1slo3 >>> 4)\r\n    var t2slo21 = (t1shi8 << 23 | t1slo8 >>> 9)\r\n    var t2shi21 = (t1slo8 << 23 | t1shi8 >>> 9)\r\n    var t2slo12 = (t1slo13 << 25 | t1shi13 >>> 7)\r\n    var t2shi12 = (t1shi13 << 25 | t1slo13 >>> 7)\r\n    var t2slo3 = (t1slo18 << 21 | t1shi18 >>> 11)\r\n    var t2shi3 = (t1shi18 << 21 | t1slo18 >>> 11)\r\n    var t2slo19 = (t1shi23 << 24 | t1slo23 >>> 8)\r\n    var t2shi19 = (t1slo23 << 24 | t1shi23 >>> 8)\r\n    var t2slo15 = (t1slo4 << 27 | t1shi4 >>> 5)\r\n    var t2shi15 = (t1shi4 << 27 | t1slo4 >>> 5)\r\n    var t2slo6 = (t1slo9 << 20 | t1shi9 >>> 12)\r\n    var t2shi6 = (t1shi9 << 20 | t1slo9 >>> 12)\r\n    var t2slo22 = (t1shi14 << 7 | t1slo14 >>> 25)\r\n    var t2shi22 = (t1slo14 << 7 | t1shi14 >>> 25)\r\n    var t2slo13 = (t1slo19 << 8 | t1shi19 >>> 24)\r\n    var t2shi13 = (t1shi19 << 8 | t1slo19 >>> 24)\r\n    var t2slo4 = (t1slo24 << 14 | t1shi24 >>> 18)\r\n    var t2shi4 = (t1shi24 << 14 | t1slo24 >>> 18)\r\n\r\n    // chi\r\n    s[0] = t2slo0 ^ (~t2slo1 & t2slo2)\r\n    s[1] = t2shi0 ^ (~t2shi1 & t2shi2)\r\n    s[10] = t2slo5 ^ (~t2slo6 & t2slo7)\r\n    s[11] = t2shi5 ^ (~t2shi6 & t2shi7)\r\n    s[20] = t2slo10 ^ (~t2slo11 & t2slo12)\r\n    s[21] = t2shi10 ^ (~t2shi11 & t2shi12)\r\n    s[30] = t2slo15 ^ (~t2slo16 & t2slo17)\r\n    s[31] = t2shi15 ^ (~t2shi16 & t2shi17)\r\n    s[40] = t2slo20 ^ (~t2slo21 & t2slo22)\r\n    s[41] = t2shi20 ^ (~t2shi21 & t2shi22)\r\n    s[2] = t2slo1 ^ (~t2slo2 & t2slo3)\r\n    s[3] = t2shi1 ^ (~t2shi2 & t2shi3)\r\n    s[12] = t2slo6 ^ (~t2slo7 & t2slo8)\r\n    s[13] = t2shi6 ^ (~t2shi7 & t2shi8)\r\n    s[22] = t2slo11 ^ (~t2slo12 & t2slo13)\r\n    s[23] = t2shi11 ^ (~t2shi12 & t2shi13)\r\n    s[32] = t2slo16 ^ (~t2slo17 & t2slo18)\r\n    s[33] = t2shi16 ^ (~t2shi17 & t2shi18)\r\n    s[42] = t2slo21 ^ (~t2slo22 & t2slo23)\r\n    s[43] = t2shi21 ^ (~t2shi22 & t2shi23)\r\n    s[4] = t2slo2 ^ (~t2slo3 & t2slo4)\r\n    s[5] = t2shi2 ^ (~t2shi3 & t2shi4)\r\n    s[14] = t2slo7 ^ (~t2slo8 & t2slo9)\r\n    s[15] = t2shi7 ^ (~t2shi8 & t2shi9)\r\n    s[24] = t2slo12 ^ (~t2slo13 & t2slo14)\r\n    s[25] = t2shi12 ^ (~t2shi13 & t2shi14)\r\n    s[34] = t2slo17 ^ (~t2slo18 & t2slo19)\r\n    s[35] = t2shi17 ^ (~t2shi18 & t2shi19)\r\n    s[44] = t2slo22 ^ (~t2slo23 & t2slo24)\r\n    s[45] = t2shi22 ^ (~t2shi23 & t2shi24)\r\n    s[6] = t2slo3 ^ (~t2slo4 & t2slo0)\r\n    s[7] = t2shi3 ^ (~t2shi4 & t2shi0)\r\n    s[16] = t2slo8 ^ (~t2slo9 & t2slo5)\r\n    s[17] = t2shi8 ^ (~t2shi9 & t2shi5)\r\n    s[26] = t2slo13 ^ (~t2slo14 & t2slo10)\r\n    s[27] = t2shi13 ^ (~t2shi14 & t2shi10)\r\n    s[36] = t2slo18 ^ (~t2slo19 & t2slo15)\r\n    s[37] = t2shi18 ^ (~t2shi19 & t2shi15)\r\n    s[46] = t2slo23 ^ (~t2slo24 & t2slo20)\r\n    s[47] = t2shi23 ^ (~t2shi24 & t2shi20)\r\n    s[8] = t2slo4 ^ (~t2slo0 & t2slo1)\r\n    s[9] = t2shi4 ^ (~t2shi0 & t2shi1)\r\n    s[18] = t2slo9 ^ (~t2slo5 & t2slo6)\r\n    s[19] = t2shi9 ^ (~t2shi5 & t2shi6)\r\n    s[28] = t2slo14 ^ (~t2slo10 & t2slo11)\r\n    s[29] = t2shi14 ^ (~t2shi10 & t2shi11)\r\n    s[38] = t2slo19 ^ (~t2slo15 & t2slo16)\r\n    s[39] = t2shi19 ^ (~t2shi15 & t2shi16)\r\n    s[48] = t2slo24 ^ (~t2slo20 & t2slo21)\r\n    s[49] = t2shi24 ^ (~t2shi20 & t2shi21)\r\n\r\n    // iota\r\n    s[0] ^= P1600_ROUND_CONSTANTS[round * 2]\r\n    s[1] ^= P1600_ROUND_CONSTANTS[round * 2 + 1]\r\n  }\r\n}\r\n\n\n\n// WEBPACK FOOTER //\n// ./../lib/keccak/keccak-state-unroll.js"],"sourceRoot":""}