{"version":3,"sources":["webpack:///./node_modules/multiformats/cjs/src/bases/base16.js","webpack:///./node_modules/mutationobserver-shim/dist/mutationobserver.min.js","webpack:///./node_modules/multiformats/cjs/src/bases/base8.js","webpack:///./node_modules/multicodec/src/print.js","webpack:///./node_modules/multiformats/cjs/src/bases/base32.js","webpack:///./node_modules/node-libs-browser/node_modules/punycode/punycode.js","webpack:///./node_modules/multiformats/cjs/src/bases/base64.js","webpack:///./node_modules/multicodec/src/util.js","webpack:///./node_modules/node-libs-browser/node_modules/buffer/index.js","webpack:///./node_modules/multiformats/cjs/src/hashes/identity.js","webpack:///./node_modules/multiformats/cjs/src/hashes/digest.js","webpack:///./node_modules/multihashes/src/index.js","webpack:///./node_modules/node-libs-browser/mock/process.js","webpack:///./node_modules/multihashes/src/constants.js","webpack:///./node_modules/multiformats/cjs/src/bases/base36.js","webpack:///./node_modules/multicodec/src/int-table.js","webpack:///./node_modules/multicodec/src/index.js","webpack:///./node_modules/multibase/src/index.js","webpack:///./node_modules/multiformats/cjs/vendor/varint.js","webpack:///./node_modules/multiformats/cjs/vendor/base-x.js","webpack:///./node_modules/multiformats/cjs/src/bases/base256emoji.js","webpack:///./node_modules/multicodec/src/constants.js","webpack:///./node_modules/multiformats/cjs/src/codecs/json.js","webpack:///./node_modules/multiformats/cjs/src/hashes/sha2-browser.js","webpack:///./node_modules/multiformats/cjs/src/bases/identity.js","webpack:///./node_modules/multiformats/cjs/src/codecs/raw.js","webpack:///./node_modules/multiformats/cjs/src/hashes/hasher.js","webpack:///./node_modules/multibase/src/base.js","webpack:///./node_modules/number-to-bn/src/index.js","webpack:///./node_modules/multibase/src/constants.js","webpack:///./node_modules/multiformats/cjs/src/varint.js","webpack:///./node_modules/multiformats/cjs/src/basics.js","webpack:///./node_modules/multibase/src/base32.js","webpack:///./node_modules/multiformats/cjs/src/bases/base10.js","webpack:///./node_modules/multicodec/src/varint-table.js","webpack:///./node_modules/multiformats/cjs/src/bases/base2.js","webpack:///./node_modules/multiformats/cjs/src/index.js","webpack:///./node_modules/multiformats/cjs/src/bases/base.js","webpack:///./node_modules/multiformats/cjs/src/bytes.js","webpack:///./node_modules/multibase/src/base16.js","webpack:///./node_modules/multiformats/cjs/src/bases/base58.js","webpack:///./node_modules/multibase/src/base64.js","webpack:///./node_modules/number-to-bn/node_modules/bn.js/lib/bn.js","webpack:///./node_modules/multiformats/cjs/src/cid.js"],"names":["Object","defineProperty","exports","value","base","base16","rfc4648","prefix","name","alphabet","bitsPerChar","base16upper","window","MutationObserver","y","z","a","this","i","m","K","c","d","takeRecords","length","h","setTimeout","_period","r","b","type","target","addedNodes","removedNodes","previousSibling","nextSibling","attributeName","attributeNamespace","oldValue","L","E","f","nodeType","nodeValue","push","C","g","M","k","attributes","p","F","namespaceURI","t","q","x","l","e","A","pop","j","Math","abs","n","v","childNodes","B","w","u","node","G","H","I","P","id","mo_id","J","prototype","observe","attributeFilter","attributeOldValue","childList","subtree","characterData","characterDataOldValue","s","splice","o","disconnect","clearTimeout","D","document","createElement","style","top","cssText","base8","table","tableByCode","code","entries","module","freeze","base32","base32upper","base32pad","base32padupper","base32hex","base32hexupper","base32hexpad","base32hexpadupper","base32z","root","freeGlobal","global","self","punycode","maxInt","regexPunycode","regexNonASCII","regexSeparators","errors","floor","stringFromCharCode","String","fromCharCode","error","RangeError","map","array","fn","result","mapDomain","string","parts","split","replace","join","ucs2decode","extra","output","counter","charCodeAt","ucs2encode","basicToDigit","codePoint","digitToBasic","digit","flag","adapt","delta","numPoints","firstTime","baseMinusTMin","decode","input","out","basic","index","oldi","baseMinusT","inputLength","bias","lastIndexOf","encode","handledCPCount","basicLength","currentValue","handledCPCountPlusOne","qMinusT","test","slice","toLowerCase","base64","base64pad","base64url","base64urlpad","varint","bufferToNumber","buf","parseInt","toString","numberToBuffer","num","hexString","Buffer","from","varintBufferEncode","varintBufferDecode","varintEncode","ieee754","isArray","kMaxLength","TYPED_ARRAY_SUPPORT","createBuffer","that","Uint8Array","__proto__","arg","encodingOrOffset","Error","allocUnsafe","TypeError","ArrayBuffer","byteOffset","byteLength","fromArrayLike","fromArrayBuffer","encoding","isEncoding","actual","write","fromString","obj","isBuffer","len","checked","copy","buffer","val","isnan","data","fromObject","assertSize","size","isView","loweredCase","utf8ToBytes","base64ToBytes","slowToString","start","end","hexSlice","utf8Slice","asciiSlice","latin1Slice","base64Slice","utf16leSlice","swap","bidirectionalIndexOf","dir","isNaN","arrayIndexOf","indexOf","call","arr","indexSize","arrLength","valLength","read","readUInt16BE","foundIndex","found","hexWrite","offset","Number","remaining","strLen","parsed","substr","utf8Write","blitBuffer","asciiWrite","str","byteArray","asciiToBytes","latin1Write","base64Write","ucs2Write","units","hi","lo","utf16leToBytes","fromByteArray","min","res","secondByte","thirdByte","fourthByte","tempCodePoint","firstByte","bytesPerSequence","codePoints","MAX_ARGUMENTS_LENGTH","apply","decodeCodePointsArray","SlowBuffer","alloc","INSPECT_MAX_BYTES","foo","subarray","typedArraySupport","poolSize","_augment","Symbol","species","configurable","fill","allocUnsafeSlow","_isBuffer","compare","concat","list","pos","swap16","swap32","swap64","arguments","equals","inspect","max","match","thisStart","thisEnd","thisCopy","targetCopy","includes","isFinite","toJSON","Array","_arr","ret","toHex","bytes","checkOffset","ext","checkInt","objectWriteUInt16","littleEndian","objectWriteUInt32","checkIEEE754","writeFloat","noAssert","writeDouble","newBuf","sliceLen","readUIntLE","mul","readUIntBE","readUInt8","readUInt16LE","readUInt32LE","readUInt32BE","readIntLE","pow","readIntBE","readInt8","readInt16LE","readInt16BE","readInt32LE","readInt32BE","readFloatLE","readFloatBE","readDoubleLE","readDoubleBE","writeUIntLE","writeUIntBE","writeUInt8","writeUInt16LE","writeUInt16BE","writeUInt32LE","writeUInt32BE","writeIntLE","limit","sub","writeIntBE","writeInt8","writeInt16LE","writeInt16BE","writeInt32LE","writeInt32BE","writeFloatLE","writeFloatBE","writeDoubleLE","writeDoubleBE","targetStart","set","INVALID_BASE64_RE","Infinity","leadSurrogate","toByteArray","trim","stringtrim","base64clean","src","dst","digest$1","coerce","identity","digest","create","Digest","constructor","sizeOffset","encodingLength","digestOffset","encodeTo","multihash","bytes$1","multibase","cs","validate","names","codes","defaultLengths","toHexString","hash","fromHexString","toB58String","fromB58String","encoded","isValidCode","hashfn","coerceCode","isAppCode","nextTick","args","shift","platform","arch","execPath","title","pid","browser","env","argv","binding","path","cwd","chdir","resolve","exit","kill","umask","dlopen","uptime","memoryUsage","uvCounters","features","0","base36","baseX","base36upper","baseTable","nameTable","Map","encodingName","intTable","codecNameToCodeVarint","util","addPrefix","multicodecStrOrCode","rmPrefix","getCodec","prefixedData","codecName","get","getName","codec","getNumber","getCode","getCodeVarint","getVarint","constants","assign","print","nameOrCode","getBase","codeBuf","validEncode","isImplemented","bufOrString","substring","isEncoded","err","keys","encode_1","oldOffset","INT","MSBALL","N1","N2","N3","N4","N5","N6","N7","N8","N9","varint$1","ALPHABET","BASE_MAP","charAt","xc","BASE","LEADER","FACTOR","log","iFACTOR","decodeUnsafe","source","psz","zeroes","b256","carry","it3","it4","vch","pbegin","pend","b58","it1","it2","repeat","_brrp__multiformats_scope_baseX","alphabetBytesToChars","reduce","alphabetCharsToBytes","codePointAt","base256emoji","byts","char","byt","toUpperCase","textEncoder","TextEncoder","textDecoder","TextDecoder","JSON","parse","stringify","hasher","sha","async","crypto","subtle","sha256","sha512","Hasher","then","implementation","engine","stringOrBuffer","BN","stripHexPrefix","multiplier","formattedString","isHexPrefixed","stringArg","dividedToIntegerBy","Base","prev","tupple","int","base2","base10","base58","sha2","identity$1","raw","json","cid","bases","hashes","codecs","CID","view","padding","bits","RegExp","varintTable","baseX$1","Encoder","baseEncode","Decoder","baseDecode","prefixCodePoint","text","or","decoder","ComposedDecoder","decoders","left","right","Codec","encoder","pad","mask","written","SyntaxError","empty","aa","bb","ii","fromHex","hex","hexes","isBinary","byte","padStart","base58btc","base58flickr","url","assert","msg","inherits","ctor","superCtor","super_","TempCtor","number","endian","isBN","negative","words","red","_init","wordSize","parseHex","parseBase","cmp","_initNumber","_initArray","_parseHex","_parseBase","strip","toArray","ceil","off","limbLen","limbPow","total","mod","word","imuln","_iaddn","dest","clone","_expand","_normSign","zeros","groupSizes","groupBases","smallMulTo","ncarry","rword","maxJ","groupSize","groupBase","isZero","modn","idivn","toNumber","toBuffer","toArrayLike","ArrayType","reqLength","andln","iushrn","clz32","_countBits","_zeroBits","bitLength","zeroBits","toTwos","width","inotn","iaddn","fromTwos","testn","notn","ineg","isNeg","neg","iuor","ior","uor","iuand","iand","and","uand","iuxor","ixor","xor","uxor","bytesNeeded","bitsLeft","setn","bit","wbit","iadd","isub","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","w0","imul","w1","w2","w3","w4","w5","w6","w7","w8","w9","w10","w11","w12","w13","w14","w15","w16","w17","w18","jumboMulTo","FFTM","mulp","mulTo","hncarry","bigMulTo","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","sqr","isqr","toBitArray","iushln","carryMask","newCarry","ishln","hint","extended","maskedWords","ishrn","shln","ushln","shrn","ushrn","imaskn","maskn","isubn","addn","subn","iabs","_ishlnsubmul","_wordDiv","mode","bhi","diff","qj","div","divmod","positive","divn","umod","divRound","dm","half","r2","acc","egcd","isEven","yp","xp","im","isOdd","jm","gcd","_invmp","x1","x2","cmpn","invm","bincn","ucmp","gtn","gt","gten","gte","ltn","lt","lten","lte","eqn","eq","Red","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","MPrime","tmp","_tmp","K256","P224","P192","P25519","prime","_prime","Mont","imod","rinv","minv","ireduce","rlen","imulK","outLen","next","mod3","one","nOne","lpow","inv","wnd","current","currentLen","mont","version","asCID","_baseCache","defineProperties","hidden","readonly","toV0","DAG_PB_CODE","SHA_256_CODE","createV0","toV1","createV1","other","toStringV0","toStringV1","toStringTag","for","static","deprecate","IS_CID_DEPRECATION","cidSymbol","toBaseEncodedString","multibaseName","encodeCID","remainder","decodeFirst","specs","inspectBytes","prefixSize","multihashSize","multihashBytes","digestBytes","digestSize","multihashCode","initialBytes","parseCIDtoBytes","cache","codeOffset","hashOffset","writable","enumerable","range","message","console","warn"],"mappings":"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ACf,cAAe,MACf,cAAe,MACf,cAAe,MACf,cAAe,MACf,cAAe,MACf,cAAe,MACf,cAAe,MACf,cAAe,MACf,cAAe,MACf,cAAe,MACf,cAAe,MACf,cAAe,MACf,cAAe,MACf,cAAe,MACf,cAAe,MACf,cAAe,MACf,cAAe,MACf,cAAe,MACf,cAAe,MACf,cAAe,MACf,cAAe,MACf,cAAe,MACf,cAAe,MACf,cAAe,MACf,cAAe,MACf,cAAe,MACf,cAAe,MACf,cAAe,MACf,cAAe,MACf,cAAe,MACf,cAAe,MACf,cAAe,MACf,cAAe,MACf,cAAe,MACf,cAAe,MACf,cAAe,MACf,cAAe,MACf,cAAe,MACf,cAAe,MACf,cAAe,MACf,cAAe,MACf,cAAe,MACf,cAAe,MACf,cAAe,MACf,cAAe,MACf,cAAe,MACf,cAAe,MACf,YAAe,MACf,aAAe,MACf,aAAe,MACf,aAAe,MACf,aAAe,MACf,aAAe,MACf,aAAe,MACf,aAAe,MACf,aAAe,MACf,aAAe,MACf,aAAe,MACf,aAAe,MACf,cAAe,MACf,cAAe,MACf,cAAe,MACf,cAAe,MACf,cAAe,MACf,cAAe,MACf,cAAe,MACf,cAAe,MACf,cAAe,MACf,cAAe,MACf,cAAe,MACf,cAAe,MACf,cAAe,MACf,cAAe,MACf,cAAe,MACf,cAAe,MACf,cAAe,MACf,cAAe,MACf,cAAe,MACf,cAAe,MACf,aAAc,MACd,cAAe,MACf,cAAe,MACf,cAAe,MACf,cAAe,MACf,cAAe,MACf,cAAe,MACf,cAAe,MACf,cAAe,MACf,cAAe,MACf,cAAe,MACf,cAAe,MACf,eAAgB,MAChB,eAAgB,MAChB,eAAgB,MAChB,eAAgB,MAChB,eAAgB,MAChB,eAAgB,MAChB,eAAgB,MAChB,eAAgB,MAChB,eAAgB,MAChB,eAAgB,MAChB,eAAgB,MAChB,eAAgB,MAChB,eAAgB,MAChB,eAAgB,MAChB,eAAgB,MAChB,eAAgB,MAChB,eAAgB,MAChB,eAAgB,MAChB,eAAgB,MAChB,eAAgB,MAChB,aAAc,MACd,cAAe,MACf,cAAe,MACf,cAAe,MACf,cAAe,MACf,cAAe,MACf,cAAe,MACf,cAAe,MACf,cAAe,MACf,cAAe,MACf,cAAe,MACf,cAAe,MACf,eAAgB,MAChB,eAAgB,MAChB,eAAgB,MAChB,eAAgB,MAChB,eAAgB,MAChB,eAAgB,MAChB,eAAgB,MAChB,eAAgB,MAChB,eAAgB,MAChB,eAAgB,MAChB,eAAgB,MAChB,eAAgB,MAChB,eAAgB,MAChB,eAAgB,MAChB,eAAgB,MAChB,eAAgB,MAChB,eAAgB,MAChB,eAAgB,MAChB,eAAgB,MAChB,eAAgB,MAChB,eAAgB,MAChB,eAAgB,MAChB,eAAgB,MAChB,eAAgB,MAChB,eAAgB,MAChB,eAAgB,MAChB,eAAgB,MAChB,eAAgB,MAChB,eAAgB,MAChB,eAAgB,MAChB,eAAgB,MAChB,eAAgB,MAChB,eAAgB,MAChB,eAAgB,MAChB,eAAgB,MAChB,eAAgB,MAChB,eAAgB,MAChB,eAAgB,MAChB,eAAgB,MAChB,eAAgB,MAChB,eAAgB,MAChB,eAAgB,MAChB,eAAgB,MAChB,eAAgB,MAChB,eAAgB,MAChB,eAAgB,MAChB,eAAgB,MAChB,eAAgB,MAChB,eAAgB,MAChB,eAAgB,MAChB,eAAgB,MAChB,eAAgB,MAChB,cAAe,MACf,eAAgB,MAChB,eAAgB,MAChB,eAAgB,MAChB,eAAgB,MAChB,eAAgB,MAChB,eAAgB,MAChB,eAAgB,MAChB,eAAgB,MAChB,eAAgB,MAChB,eAAgB,MAChB,eAAgB,MAChB,gBAAiB,MACjB,gBAAiB,MACjB,gBAAiB,MACjB,gBAAiB,MACjB,gBAAiB,MACjB,gBAAiB,MACjB,gBAAiB,MACjB,gBAAiB,MACjB,gBAAiB,MACjB,gBAAiB,MACjB,gBAAiB,MACjB,gBAAiB,MACjB,gBAAiB,MACjB,gBAAiB,MACjB,gBAAiB,MACjB,gBAAiB,MACjB,gBAAiB,MACjB,gBAAiB,MACjB,gBAAiB,MACjB,gBAAiB,MACjB,gBAAiB,MACjB,gBAAiB,MACjB,gBAAiB,MACjB,gBAAiB,MACjB,gBAAiB,MACjB,gBAAiB,MACjB,gBAAiB,MACjB,gBAAiB,MA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ACR,MAAQ,cACR,MAAQ,cACR,MAAQ,cACR,MAAQ,cACR,MAAQ,cACR,MAAQ,eACR,MAAQ,eACR,MAAQ,eACR,MAAQ,eACR,MAAQ,eACR,MAAQ,eACR,MAAQ,eACR,MAAQ,eACR,MAAQ,eACR,MAAQ,eACR,MAAQ,eACR,MAAQ,eACR,MAAQ,eACR,MAAQ,eACR,MAAQ,eACR,MAAQ,eACR,MAAQ,eACR,MAAQ,eACR,MAAQ,eACR,MAAQ,eACR,MAAQ,aACR,MAAQ,cACR,MAAQ,cACR,MAAQ,cACR,MAAQ,cACR,MAAQ,cACR,MAAQ,cACR,MAAQ,cACR,MAAQ,cACR,MAAQ,cACR,MAAQ,cACR,MAAQ,cACR,MAAQ,eACR,MAAQ,eACR,MAAQ,eACR,MAAQ,eACR,MAAQ,eACR,MAAQ,eACR,MAAQ,eACR,MAAQ,eACR,MAAQ,eACR,MAAQ,eACR,MAAQ,eACR,MAAQ,eACR,MAAQ,eACR,MAAQ,eACR,MAAQ,eACR,MAAQ,eACR,MAAQ,eACR,MAAQ,eACR,MAAQ,eACR,MAAQ,eACR,MAAQ,eACR,MAAQ,eACR,MAAQ,eACR,MAAQ,eACR,MAAQ,eACR,MAAQ,eACR,MAAQ,eACR,MAAQ,eACR,MAAQ,eACR,MAAQ,eACR,MAAQ,eACR,MAAQ,eACR,MAAQ,eACR,MAAQ,eACR,MAAQ,eACR,MAAQ,eACR,MAAQ,eACR,MAAQ,eACR,MAAQ,eACR,MAAQ,eACR,MAAQ,eACR,MAAQ,eACR,MAAQ,eACR,MAAQ,eACR,MAAQ,eACR,MAAQ,eACR,MAAQ,eACR,MAAQ,eACR,MAAQ,eACR,MAAQ,eACR,MAAQ,eACR,MAAQ,eACR,MAAQ,cACR,MAAQ,eACR,MAAQ,eACR,MAAQ,eACR,MAAQ,eACR,MAAQ,eACR,MAAQ,eACR,MAAQ,eACR,MAAQ,eACR,MAAQ,eACR,MAAQ,eACR,MAAQ,eACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,KAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,gBACR,MAAQ,iBACR,MAAQ,iBACR,MAAQ,iBACR,MAAQ,mBAGVrb,EAAQkZ,eAAiBpZ,OAAOsG,OAAO,CACrC,GAAM,GACN,GAAM,GACN,GAAM,GACN,GAAM,GACN,GAAM,GACN,GAAM,GACN,GAAM,GACN,GAAM,GACN,GAAM,GACN,GAAM,GACN,GAAM,GACN,GAAM,GACN,GAAM,GACN,GAAM,GACN,GAAM,GAEN,MAAQ,EACR,MAAQ,EACR,MAAQ,EACR,MAAQ,EACR,MAAQ,EACR,MAAQ,EACR,MAAQ,EACR,MAAQ,EACR,MAAQ,EACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,EACR,MAAQ,EACR,MAAQ,EACR,MAAQ,EACR,MAAQ,EACR,MAAQ,EACR,MAAQ,EACR,MAAQ,EACR,MAAQ,EACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,EACR,MAAQ,EACR,MAAQ,EACR,MAAQ,EACR,MAAQ,EACR,MAAQ,EACR,MAAQ,EACR,MAAQ,EACR,MAAQ,EACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,EACR,MAAQ,EACR,MAAQ,EACR,MAAQ,EACR,MAAQ,EACR,MAAQ,EACR,MAAQ,EACR,MAAQ,EACR,MAAQ,EACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,EACR,MAAQ,EACR,MAAQ,EACR,MAAQ,EACR,MAAQ,EACR,MAAQ,EACR,MAAQ,EACR,MAAQ,EACR,MAAQ,EACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,GACR,MAAQ,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","file":"js/chunk-vendors~9c5b28f6.cdaa9c8d.js","sourcesContent":["'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\nvar base = require('./base.js');\n\nconst base16 = base.rfc4648({\n  prefix: 'f',\n  name: 'base16',\n  alphabet: '0123456789abcdef',\n  bitsPerChar: 4\n});\nconst base16upper = base.rfc4648({\n  prefix: 'F',\n  name: 'base16upper',\n  alphabet: '0123456789ABCDEF',\n  bitsPerChar: 4\n});\n\nexports.base16 = base16;\nexports.base16upper = base16upper;\n","// mutationobserver-shim v0.3.3 (github.com/megawac/MutationObserver.js)\n// Authors: Graeme Yeates (github.com/megawac) \n/*\n Shim for MutationObserver interface\n Author: Graeme Yeates (github.com/megawac)\n Repository: https://github.com/megawac/MutationObserver.js\n License: WTFPL V2, 2004 (wtfpl.net).\n Though credit and staring the repo will make me feel pretty, you can modify and redistribute as you please.\n Attempts to follow spec (https://www.w3.org/TR/dom/#mutation-observers) as closely as possible for native javascript\n See https://github.com/WebKit/webkit/blob/master/Source/WebCore/dom/MutationObserver.cpp for current webkit source c++ implementation\n*/\nwindow.MutationObserver||(window.MutationObserver=function(y){function z(a){this.i=[];this.m=a}function K(a){(function c(){var d=a.takeRecords();d.length&&a.m(d,a);a.h=setTimeout(c,z._period)})()}function r(a){var b={type:null,target:null,addedNodes:[],removedNodes:[],previousSibling:null,nextSibling:null,attributeName:null,attributeNamespace:null,oldValue:null},c;for(c in a)b[c]!==y&&a[c]!==y&&(b[c]=a[c]);return b}function L(a,b){var c=E(a,b);return function(d){var f=d.length;b.a&&3===a.nodeType&&\na.nodeValue!==c.a&&d.push(new r({type:\"characterData\",target:a,oldValue:c.a}));b.b&&c.b&&C(d,a,c.b,b.f);if(b.c||b.g)var m=M(d,a,c,b);if(m||d.length!==f)c=E(a,b)}}function N(a,b){return b.value}function O(a,b){return\"style\"!==b.name?b.value:a.style.cssText}function C(a,b,c,d){for(var f={},m=b.attributes,k,g,p=m.length;p--;)k=m[p],g=k.name,d&&d[g]===y||(F(b,k)!==c[g]&&a.push(r({type:\"attributes\",target:b,attributeName:g,oldValue:c[g],attributeNamespace:k.namespaceURI})),f[g]=!0);for(g in c)f[g]||a.push(r({target:b,\ntype:\"attributes\",attributeName:g,oldValue:c[g]}))}function M(a,b,c,d){function f(g,p,t,q,x){var A=g.length-1;x=-~((A-x)/2);for(var h,l,e;e=g.pop();)h=t[e.j],l=q[e.l],d.c&&x&&Math.abs(e.j-e.l)>=A&&(a.push(r({type:\"childList\",target:p,addedNodes:[h],removedNodes:[h],nextSibling:h.nextSibling,previousSibling:h.previousSibling})),x--),d.b&&l.b&&C(a,h,l.b,d.f),d.a&&3===h.nodeType&&h.nodeValue!==l.a&&a.push(r({type:\"characterData\",target:h,oldValue:l.a})),d.g&&m(h,l)}function m(g,p){for(var t=g.childNodes,\nq=p.c,x=t.length,A=q?q.length:0,h,l,e,n,v,B=0,w=0,u=0;w<x||u<A;)n=t[w],v=(e=q[u])&&e.node,n===v?(d.b&&e.b&&C(a,n,e.b,d.f),d.a&&e.a!==y&&n.nodeValue!==e.a&&a.push(r({type:\"characterData\",target:n,oldValue:e.a})),l&&f(l,g,t,q,B),d.g&&(n.childNodes.length||e.c&&e.c.length)&&m(n,e),w++,u++):(k=!0,h||(h={},l=[]),n&&(h[e=G(n)]||(h[e]=!0,-1===(e=H(q,n,u,\"node\"))?d.c&&(a.push(r({type:\"childList\",target:g,addedNodes:[n],nextSibling:n.nextSibling,previousSibling:n.previousSibling})),B++):l.push({j:w,l:e})),\nw++),v&&v!==t[w]&&(h[e=G(v)]||(h[e]=!0,-1===(e=H(t,v,w))?d.c&&(a.push(r({type:\"childList\",target:p.node,removedNodes:[v],nextSibling:q[u+1],previousSibling:q[u-1]})),B--):l.push({j:e,l:u})),u++));l&&f(l,g,t,q,B)}var k;m(b,c);return k}function E(a,b){var c=!0;return function m(f){var k={node:f};!b.a||3!==f.nodeType&&8!==f.nodeType?(b.b&&c&&1===f.nodeType&&(k.b=I(f.attributes,function(g,p){if(!b.f||b.f[p.name])g[p.name]=F(f,p);return g},{})),c&&(b.c||b.a||b.b&&b.g)&&(k.c=P(f.childNodes,m)),c=b.g):k.a=\nf.nodeValue;return k}(a)}function G(a){try{return a.id||(a.mo_id=a.mo_id||J++)}catch(b){try{return a.nodeValue}catch(c){return J++}}}function P(a,b){for(var c=[],d=0;d<a.length;d++)c[d]=b(a[d],d,a);return c}function I(a,b,c){for(var d=0;d<a.length;d++)c=b(c,a[d],d,a);return c}function H(a,b,c,d){for(;c<a.length;c++)if((d?a[c][d]:a[c])===b)return c;return-1}z._period=30;z.prototype={observe:function(a,b){for(var c={b:!!(b.attributes||b.attributeFilter||b.attributeOldValue),c:!!b.childList,g:!!b.subtree,\na:!(!b.characterData&&!b.characterDataOldValue)},d=this.i,f=0;f<d.length;f++)d[f].s===a&&d.splice(f,1);b.attributeFilter&&(c.f=I(b.attributeFilter,function(m,k){m[k]=!0;return m},{}));d.push({s:a,o:L(a,c)});this.h||K(this)},takeRecords:function(){for(var a=[],b=this.i,c=0;c<b.length;c++)b[c].o(a);return a},disconnect:function(){this.i=[];clearTimeout(this.h);this.h=null}};var D=document.createElement(\"i\");D.style.top=0;var F=(D=\"null\"!=D.attributes.style.value)?N:O,J=1;return z}(void 0));\n//# sourceMappingURL=mutationobserver.map\n","'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\nvar base = require('./base.js');\n\nconst base8 = base.rfc4648({\n  prefix: '7',\n  name: 'base8',\n  alphabet: '01234567',\n  bitsPerChar: 3\n});\n\nexports.base8 = base8;\n","'use strict'\n\nconst table = require('./base-table.json')\n\n// map for code -> print friendly name\nconst tableByCode = {}\n\nfor (const [name, code] of Object.entries(table)) {\n  if (tableByCode[code] === undefined) tableByCode[code] = name\n}\n\nmodule.exports = Object.freeze(tableByCode)\n","'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\nvar base = require('./base.js');\n\nconst base32 = base.rfc4648({\n  prefix: 'b',\n  name: 'base32',\n  alphabet: 'abcdefghijklmnopqrstuvwxyz234567',\n  bitsPerChar: 5\n});\nconst base32upper = base.rfc4648({\n  prefix: 'B',\n  name: 'base32upper',\n  alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567',\n  bitsPerChar: 5\n});\nconst base32pad = base.rfc4648({\n  prefix: 'c',\n  name: 'base32pad',\n  alphabet: 'abcdefghijklmnopqrstuvwxyz234567=',\n  bitsPerChar: 5\n});\nconst base32padupper = base.rfc4648({\n  prefix: 'C',\n  name: 'base32padupper',\n  alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567=',\n  bitsPerChar: 5\n});\nconst base32hex = base.rfc4648({\n  prefix: 'v',\n  name: 'base32hex',\n  alphabet: '0123456789abcdefghijklmnopqrstuv',\n  bitsPerChar: 5\n});\nconst base32hexupper = base.rfc4648({\n  prefix: 'V',\n  name: 'base32hexupper',\n  alphabet: '0123456789ABCDEFGHIJKLMNOPQRSTUV',\n  bitsPerChar: 5\n});\nconst base32hexpad = base.rfc4648({\n  prefix: 't',\n  name: 'base32hexpad',\n  alphabet: '0123456789abcdefghijklmnopqrstuv=',\n  bitsPerChar: 5\n});\nconst base32hexpadupper = base.rfc4648({\n  prefix: 'T',\n  name: 'base32hexpadupper',\n  alphabet: '0123456789ABCDEFGHIJKLMNOPQRSTUV=',\n  bitsPerChar: 5\n});\nconst base32z = base.rfc4648({\n  prefix: 'h',\n  name: 'base32z',\n  alphabet: 'ybndrfg8ejkmcpqxot1uwisza345h769',\n  bitsPerChar: 5\n});\n\nexports.base32 = base32;\nexports.base32hex = base32hex;\nexports.base32hexpad = base32hexpad;\nexports.base32hexpadupper = base32hexpadupper;\nexports.base32hexupper = base32hexupper;\nexports.base32pad = base32pad;\nexports.base32padupper = base32padupper;\nexports.base32upper = base32upper;\nexports.base32z = base32z;\n","/*! https://mths.be/punycode v1.4.1 by @mathias */\n;(function(root) {\n\n\t/** Detect free variables */\n\tvar freeExports = typeof exports == 'object' && exports &&\n\t\t!exports.nodeType && exports;\n\tvar freeModule = typeof module == 'object' && module &&\n\t\t!module.nodeType && module;\n\tvar freeGlobal = typeof global == 'object' && global;\n\tif (\n\t\tfreeGlobal.global === freeGlobal ||\n\t\tfreeGlobal.window === freeGlobal ||\n\t\tfreeGlobal.self === freeGlobal\n\t) {\n\t\troot = freeGlobal;\n\t}\n\n\t/**\n\t * The `punycode` object.\n\t * @name punycode\n\t * @type Object\n\t */\n\tvar punycode,\n\n\t/** Highest positive signed 32-bit float value */\n\tmaxInt = 2147483647, // aka. 0x7FFFFFFF or 2^31-1\n\n\t/** Bootstring parameters */\n\tbase = 36,\n\ttMin = 1,\n\ttMax = 26,\n\tskew = 38,\n\tdamp = 700,\n\tinitialBias = 72,\n\tinitialN = 128, // 0x80\n\tdelimiter = '-', // '\\x2D'\n\n\t/** Regular expressions */\n\tregexPunycode = /^xn--/,\n\tregexNonASCII = /[^\\x20-\\x7E]/, // unprintable ASCII chars + non-ASCII chars\n\tregexSeparators = /[\\x2E\\u3002\\uFF0E\\uFF61]/g, // RFC 3490 separators\n\n\t/** Error messages */\n\terrors = {\n\t\t'overflow': 'Overflow: input needs wider integers to process',\n\t\t'not-basic': 'Illegal input >= 0x80 (not a basic code point)',\n\t\t'invalid-input': 'Invalid input'\n\t},\n\n\t/** Convenience shortcuts */\n\tbaseMinusTMin = base - tMin,\n\tfloor = Math.floor,\n\tstringFromCharCode = String.fromCharCode,\n\n\t/** Temporary variable */\n\tkey;\n\n\t/*--------------------------------------------------------------------------*/\n\n\t/**\n\t * A generic error utility function.\n\t * @private\n\t * @param {String} type The error type.\n\t * @returns {Error} Throws a `RangeError` with the applicable error message.\n\t */\n\tfunction error(type) {\n\t\tthrow new RangeError(errors[type]);\n\t}\n\n\t/**\n\t * A generic `Array#map` utility function.\n\t * @private\n\t * @param {Array} array The array to iterate over.\n\t * @param {Function} callback The function that gets called for every array\n\t * item.\n\t * @returns {Array} A new array of values returned by the callback function.\n\t */\n\tfunction map(array, fn) {\n\t\tvar length = array.length;\n\t\tvar result = [];\n\t\twhile (length--) {\n\t\t\tresult[length] = fn(array[length]);\n\t\t}\n\t\treturn result;\n\t}\n\n\t/**\n\t * A simple `Array#map`-like wrapper to work with domain name strings or email\n\t * addresses.\n\t * @private\n\t * @param {String} domain The domain name or email address.\n\t * @param {Function} callback The function that gets called for every\n\t * character.\n\t * @returns {Array} A new string of characters returned by the callback\n\t * function.\n\t */\n\tfunction mapDomain(string, fn) {\n\t\tvar parts = string.split('@');\n\t\tvar result = '';\n\t\tif (parts.length > 1) {\n\t\t\t// In email addresses, only the domain name should be punycoded. Leave\n\t\t\t// the local part (i.e. everything up to `@`) intact.\n\t\t\tresult = parts[0] + '@';\n\t\t\tstring = parts[1];\n\t\t}\n\t\t// Avoid `split(regex)` for IE8 compatibility. See #17.\n\t\tstring = string.replace(regexSeparators, '\\x2E');\n\t\tvar labels = string.split('.');\n\t\tvar encoded = map(labels, fn).join('.');\n\t\treturn result + encoded;\n\t}\n\n\t/**\n\t * Creates an array containing the numeric code points of each Unicode\n\t * character in the string. While JavaScript uses UCS-2 internally,\n\t * this function will convert a pair of surrogate halves (each of which\n\t * UCS-2 exposes as separate characters) into a single code point,\n\t * matching UTF-16.\n\t * @see `punycode.ucs2.encode`\n\t * @see <https://mathiasbynens.be/notes/javascript-encoding>\n\t * @memberOf punycode.ucs2\n\t * @name decode\n\t * @param {String} string The Unicode input string (UCS-2).\n\t * @returns {Array} The new array of code points.\n\t */\n\tfunction ucs2decode(string) {\n\t\tvar output = [],\n\t\t    counter = 0,\n\t\t    length = string.length,\n\t\t    value,\n\t\t    extra;\n\t\twhile (counter < length) {\n\t\t\tvalue = string.charCodeAt(counter++);\n\t\t\tif (value >= 0xD800 && value <= 0xDBFF && counter < length) {\n\t\t\t\t// high surrogate, and there is a next character\n\t\t\t\textra = string.charCodeAt(counter++);\n\t\t\t\tif ((extra & 0xFC00) == 0xDC00) { // low surrogate\n\t\t\t\t\toutput.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);\n\t\t\t\t} else {\n\t\t\t\t\t// unmatched surrogate; only append this code unit, in case the next\n\t\t\t\t\t// code unit is the high surrogate of a surrogate pair\n\t\t\t\t\toutput.push(value);\n\t\t\t\t\tcounter--;\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\toutput.push(value);\n\t\t\t}\n\t\t}\n\t\treturn output;\n\t}\n\n\t/**\n\t * Creates a string based on an array of numeric code points.\n\t * @see `punycode.ucs2.decode`\n\t * @memberOf punycode.ucs2\n\t * @name encode\n\t * @param {Array} codePoints The array of numeric code points.\n\t * @returns {String} The new Unicode string (UCS-2).\n\t */\n\tfunction ucs2encode(array) {\n\t\treturn map(array, function(value) {\n\t\t\tvar output = '';\n\t\t\tif (value > 0xFFFF) {\n\t\t\t\tvalue -= 0x10000;\n\t\t\t\toutput += stringFromCharCode(value >>> 10 & 0x3FF | 0xD800);\n\t\t\t\tvalue = 0xDC00 | value & 0x3FF;\n\t\t\t}\n\t\t\toutput += stringFromCharCode(value);\n\t\t\treturn output;\n\t\t}).join('');\n\t}\n\n\t/**\n\t * Converts a basic code point into a digit/integer.\n\t * @see `digitToBasic()`\n\t * @private\n\t * @param {Number} codePoint The basic numeric code point value.\n\t * @returns {Number} The numeric value of a basic code point (for use in\n\t * representing integers) in the range `0` to `base - 1`, or `base` if\n\t * the code point does not represent a value.\n\t */\n\tfunction basicToDigit(codePoint) {\n\t\tif (codePoint - 48 < 10) {\n\t\t\treturn codePoint - 22;\n\t\t}\n\t\tif (codePoint - 65 < 26) {\n\t\t\treturn codePoint - 65;\n\t\t}\n\t\tif (codePoint - 97 < 26) {\n\t\t\treturn codePoint - 97;\n\t\t}\n\t\treturn base;\n\t}\n\n\t/**\n\t * Converts a digit/integer into a basic code point.\n\t * @see `basicToDigit()`\n\t * @private\n\t * @param {Number} digit The numeric value of a basic code point.\n\t * @returns {Number} The basic code point whose value (when used for\n\t * representing integers) is `digit`, which needs to be in the range\n\t * `0` to `base - 1`. If `flag` is non-zero, the uppercase form is\n\t * used; else, the lowercase form is used. The behavior is undefined\n\t * if `flag` is non-zero and `digit` has no uppercase form.\n\t */\n\tfunction digitToBasic(digit, flag) {\n\t\t//  0..25 map to ASCII a..z or A..Z\n\t\t// 26..35 map to ASCII 0..9\n\t\treturn digit + 22 + 75 * (digit < 26) - ((flag != 0) << 5);\n\t}\n\n\t/**\n\t * Bias adaptation function as per section 3.4 of RFC 3492.\n\t * https://tools.ietf.org/html/rfc3492#section-3.4\n\t * @private\n\t */\n\tfunction adapt(delta, numPoints, firstTime) {\n\t\tvar k = 0;\n\t\tdelta = firstTime ? floor(delta / damp) : delta >> 1;\n\t\tdelta += floor(delta / numPoints);\n\t\tfor (/* no initialization */; delta > baseMinusTMin * tMax >> 1; k += base) {\n\t\t\tdelta = floor(delta / baseMinusTMin);\n\t\t}\n\t\treturn floor(k + (baseMinusTMin + 1) * delta / (delta + skew));\n\t}\n\n\t/**\n\t * Converts a Punycode string of ASCII-only symbols to a string of Unicode\n\t * symbols.\n\t * @memberOf punycode\n\t * @param {String} input The Punycode string of ASCII-only symbols.\n\t * @returns {String} The resulting string of Unicode symbols.\n\t */\n\tfunction decode(input) {\n\t\t// Don't use UCS-2\n\t\tvar output = [],\n\t\t    inputLength = input.length,\n\t\t    out,\n\t\t    i = 0,\n\t\t    n = initialN,\n\t\t    bias = initialBias,\n\t\t    basic,\n\t\t    j,\n\t\t    index,\n\t\t    oldi,\n\t\t    w,\n\t\t    k,\n\t\t    digit,\n\t\t    t,\n\t\t    /** Cached calculation results */\n\t\t    baseMinusT;\n\n\t\t// Handle the basic code points: let `basic` be the number of input code\n\t\t// points before the last delimiter, or `0` if there is none, then copy\n\t\t// the first basic code points to the output.\n\n\t\tbasic = input.lastIndexOf(delimiter);\n\t\tif (basic < 0) {\n\t\t\tbasic = 0;\n\t\t}\n\n\t\tfor (j = 0; j < basic; ++j) {\n\t\t\t// if it's not a basic code point\n\t\t\tif (input.charCodeAt(j) >= 0x80) {\n\t\t\t\terror('not-basic');\n\t\t\t}\n\t\t\toutput.push(input.charCodeAt(j));\n\t\t}\n\n\t\t// Main decoding loop: start just after the last delimiter if any basic code\n\t\t// points were copied; start at the beginning otherwise.\n\n\t\tfor (index = basic > 0 ? basic + 1 : 0; index < inputLength; /* no final expression */) {\n\n\t\t\t// `index` is the index of the next character to be consumed.\n\t\t\t// Decode a generalized variable-length integer into `delta`,\n\t\t\t// which gets added to `i`. The overflow checking is easier\n\t\t\t// if we increase `i` as we go, then subtract off its starting\n\t\t\t// value at the end to obtain `delta`.\n\t\t\tfor (oldi = i, w = 1, k = base; /* no condition */; k += base) {\n\n\t\t\t\tif (index >= inputLength) {\n\t\t\t\t\terror('invalid-input');\n\t\t\t\t}\n\n\t\t\t\tdigit = basicToDigit(input.charCodeAt(index++));\n\n\t\t\t\tif (digit >= base || digit > floor((maxInt - i) / w)) {\n\t\t\t\t\terror('overflow');\n\t\t\t\t}\n\n\t\t\t\ti += digit * w;\n\t\t\t\tt = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);\n\n\t\t\t\tif (digit < t) {\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\n\t\t\t\tbaseMinusT = base - t;\n\t\t\t\tif (w > floor(maxInt / baseMinusT)) {\n\t\t\t\t\terror('overflow');\n\t\t\t\t}\n\n\t\t\t\tw *= baseMinusT;\n\n\t\t\t}\n\n\t\t\tout = output.length + 1;\n\t\t\tbias = adapt(i - oldi, out, oldi == 0);\n\n\t\t\t// `i` was supposed to wrap around from `out` to `0`,\n\t\t\t// incrementing `n` each time, so we'll fix that now:\n\t\t\tif (floor(i / out) > maxInt - n) {\n\t\t\t\terror('overflow');\n\t\t\t}\n\n\t\t\tn += floor(i / out);\n\t\t\ti %= out;\n\n\t\t\t// Insert `n` at position `i` of the output\n\t\t\toutput.splice(i++, 0, n);\n\n\t\t}\n\n\t\treturn ucs2encode(output);\n\t}\n\n\t/**\n\t * Converts a string of Unicode symbols (e.g. a domain name label) to a\n\t * Punycode string of ASCII-only symbols.\n\t * @memberOf punycode\n\t * @param {String} input The string of Unicode symbols.\n\t * @returns {String} The resulting Punycode string of ASCII-only symbols.\n\t */\n\tfunction encode(input) {\n\t\tvar n,\n\t\t    delta,\n\t\t    handledCPCount,\n\t\t    basicLength,\n\t\t    bias,\n\t\t    j,\n\t\t    m,\n\t\t    q,\n\t\t    k,\n\t\t    t,\n\t\t    currentValue,\n\t\t    output = [],\n\t\t    /** `inputLength` will hold the number of code points in `input`. */\n\t\t    inputLength,\n\t\t    /** Cached calculation results */\n\t\t    handledCPCountPlusOne,\n\t\t    baseMinusT,\n\t\t    qMinusT;\n\n\t\t// Convert the input in UCS-2 to Unicode\n\t\tinput = ucs2decode(input);\n\n\t\t// Cache the length\n\t\tinputLength = input.length;\n\n\t\t// Initialize the state\n\t\tn = initialN;\n\t\tdelta = 0;\n\t\tbias = initialBias;\n\n\t\t// Handle the basic code points\n\t\tfor (j = 0; j < inputLength; ++j) {\n\t\t\tcurrentValue = input[j];\n\t\t\tif (currentValue < 0x80) {\n\t\t\t\toutput.push(stringFromCharCode(currentValue));\n\t\t\t}\n\t\t}\n\n\t\thandledCPCount = basicLength = output.length;\n\n\t\t// `handledCPCount` is the number of code points that have been handled;\n\t\t// `basicLength` is the number of basic code points.\n\n\t\t// Finish the basic string - if it is not empty - with a delimiter\n\t\tif (basicLength) {\n\t\t\toutput.push(delimiter);\n\t\t}\n\n\t\t// Main encoding loop:\n\t\twhile (handledCPCount < inputLength) {\n\n\t\t\t// All non-basic code points < n have been handled already. Find the next\n\t\t\t// larger one:\n\t\t\tfor (m = maxInt, j = 0; j < inputLength; ++j) {\n\t\t\t\tcurrentValue = input[j];\n\t\t\t\tif (currentValue >= n && currentValue < m) {\n\t\t\t\t\tm = currentValue;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Increase `delta` enough to advance the decoder's <n,i> state to <m,0>,\n\t\t\t// but guard against overflow\n\t\t\thandledCPCountPlusOne = handledCPCount + 1;\n\t\t\tif (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) {\n\t\t\t\terror('overflow');\n\t\t\t}\n\n\t\t\tdelta += (m - n) * handledCPCountPlusOne;\n\t\t\tn = m;\n\n\t\t\tfor (j = 0; j < inputLength; ++j) {\n\t\t\t\tcurrentValue = input[j];\n\n\t\t\t\tif (currentValue < n && ++delta > maxInt) {\n\t\t\t\t\terror('overflow');\n\t\t\t\t}\n\n\t\t\t\tif (currentValue == n) {\n\t\t\t\t\t// Represent delta as a generalized variable-length integer\n\t\t\t\t\tfor (q = delta, k = base; /* no condition */; k += base) {\n\t\t\t\t\t\tt = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);\n\t\t\t\t\t\tif (q < t) {\n\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t}\n\t\t\t\t\t\tqMinusT = q - t;\n\t\t\t\t\t\tbaseMinusT = base - t;\n\t\t\t\t\t\toutput.push(\n\t\t\t\t\t\t\tstringFromCharCode(digitToBasic(t + qMinusT % baseMinusT, 0))\n\t\t\t\t\t\t);\n\t\t\t\t\t\tq = floor(qMinusT / baseMinusT);\n\t\t\t\t\t}\n\n\t\t\t\t\toutput.push(stringFromCharCode(digitToBasic(q, 0)));\n\t\t\t\t\tbias = adapt(delta, handledCPCountPlusOne, handledCPCount == basicLength);\n\t\t\t\t\tdelta = 0;\n\t\t\t\t\t++handledCPCount;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t++delta;\n\t\t\t++n;\n\n\t\t}\n\t\treturn output.join('');\n\t}\n\n\t/**\n\t * Converts a Punycode string representing a domain name or an email address\n\t * to Unicode. Only the Punycoded parts of the input will be converted, i.e.\n\t * it doesn't matter if you call it on a string that has already been\n\t * converted to Unicode.\n\t * @memberOf punycode\n\t * @param {String} input The Punycoded domain name or email address to\n\t * convert to Unicode.\n\t * @returns {String} The Unicode representation of the given Punycode\n\t * string.\n\t */\n\tfunction toUnicode(input) {\n\t\treturn mapDomain(input, function(string) {\n\t\t\treturn regexPunycode.test(string)\n\t\t\t\t? decode(string.slice(4).toLowerCase())\n\t\t\t\t: string;\n\t\t});\n\t}\n\n\t/**\n\t * Converts a Unicode string representing a domain name or an email address to\n\t * Punycode. Only the non-ASCII parts of the domain name will be converted,\n\t * i.e. it doesn't matter if you call it with a domain that's already in\n\t * ASCII.\n\t * @memberOf punycode\n\t * @param {String} input The domain name or email address to convert, as a\n\t * Unicode string.\n\t * @returns {String} The Punycode representation of the given domain name or\n\t * email address.\n\t */\n\tfunction toASCII(input) {\n\t\treturn mapDomain(input, function(string) {\n\t\t\treturn regexNonASCII.test(string)\n\t\t\t\t? 'xn--' + encode(string)\n\t\t\t\t: string;\n\t\t});\n\t}\n\n\t/*--------------------------------------------------------------------------*/\n\n\t/** Define the public API */\n\tpunycode = {\n\t\t/**\n\t\t * A string representing the current Punycode.js version number.\n\t\t * @memberOf punycode\n\t\t * @type String\n\t\t */\n\t\t'version': '1.4.1',\n\t\t/**\n\t\t * An object of methods to convert from JavaScript's internal character\n\t\t * representation (UCS-2) to Unicode code points, and back.\n\t\t * @see <https://mathiasbynens.be/notes/javascript-encoding>\n\t\t * @memberOf punycode\n\t\t * @type Object\n\t\t */\n\t\t'ucs2': {\n\t\t\t'decode': ucs2decode,\n\t\t\t'encode': ucs2encode\n\t\t},\n\t\t'decode': decode,\n\t\t'encode': encode,\n\t\t'toASCII': toASCII,\n\t\t'toUnicode': toUnicode\n\t};\n\n\t/** Expose `punycode` */\n\t// Some AMD build optimizers, like r.js, check for specific condition patterns\n\t// like the following:\n\tif (\n\t\ttypeof define == 'function' &&\n\t\ttypeof define.amd == 'object' &&\n\t\tdefine.amd\n\t) {\n\t\tdefine('punycode', function() {\n\t\t\treturn punycode;\n\t\t});\n\t} else if (freeExports && freeModule) {\n\t\tif (module.exports == freeExports) {\n\t\t\t// in Node.js, io.js, or RingoJS v0.8.0+\n\t\t\tfreeModule.exports = punycode;\n\t\t} else {\n\t\t\t// in Narwhal or RingoJS v0.7.0-\n\t\t\tfor (key in punycode) {\n\t\t\t\tpunycode.hasOwnProperty(key) && (freeExports[key] = punycode[key]);\n\t\t\t}\n\t\t}\n\t} else {\n\t\t// in Rhino or a web browser\n\t\troot.punycode = punycode;\n\t}\n\n}(this));\n","'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\nvar base = require('./base.js');\n\nconst base64 = base.rfc4648({\n  prefix: 'm',\n  name: 'base64',\n  alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/',\n  bitsPerChar: 6\n});\nconst base64pad = base.rfc4648({\n  prefix: 'M',\n  name: 'base64pad',\n  alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=',\n  bitsPerChar: 6\n});\nconst base64url = base.rfc4648({\n  prefix: 'u',\n  name: 'base64url',\n  alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_',\n  bitsPerChar: 6\n});\nconst base64urlpad = base.rfc4648({\n  prefix: 'U',\n  name: 'base64urlpad',\n  alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_=',\n  bitsPerChar: 6\n});\n\nexports.base64 = base64;\nexports.base64pad = base64pad;\nexports.base64url = base64url;\nexports.base64urlpad = base64urlpad;\n","'use strict'\nconst varint = require('varint')\n\nmodule.exports = {\n  numberToBuffer,\n  bufferToNumber,\n  varintBufferEncode,\n  varintBufferDecode,\n  varintEncode\n}\n\nfunction bufferToNumber (buf) {\n  return parseInt(buf.toString('hex'), 16)\n}\n\nfunction numberToBuffer (num) {\n  let hexString = num.toString(16)\n  if (hexString.length % 2 === 1) {\n    hexString = '0' + hexString\n  }\n  return Buffer.from(hexString, 'hex')\n}\n\nfunction varintBufferEncode (input) {\n  return Buffer.from(varint.encode(bufferToNumber(input)))\n}\n\nfunction varintBufferDecode (input) {\n  return numberToBuffer(varint.decode(input))\n}\n\nfunction varintEncode (num) {\n  return Buffer.from(varint.encode(num))\n}\n","/*!\n * The buffer module from node.js, for the browser.\n *\n * @author   Feross Aboukhadijeh <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","'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\nvar bytes = require('../bytes.js');\nvar digest$1 = require('./digest.js');\n\nconst code = 0;\nconst name = 'identity';\nconst encode = bytes.coerce;\nconst digest = input => digest$1.create(code, encode(input));\nconst identity = {\n  code,\n  name,\n  encode,\n  digest\n};\n\nexports.identity = identity;\n","'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\nvar bytes = require('../bytes.js');\nvar varint = require('../varint.js');\n\nconst create = (code, digest) => {\n  const size = digest.byteLength;\n  const sizeOffset = varint.encodingLength(code);\n  const digestOffset = sizeOffset + varint.encodingLength(size);\n  const bytes = new Uint8Array(digestOffset + size);\n  varint.encodeTo(code, bytes, 0);\n  varint.encodeTo(size, bytes, sizeOffset);\n  bytes.set(digest, digestOffset);\n  return new Digest(code, size, digest, bytes);\n};\nconst decode = multihash => {\n  const bytes$1 = bytes.coerce(multihash);\n  const [code, sizeOffset] = varint.decode(bytes$1);\n  const [size, digestOffset] = varint.decode(bytes$1.subarray(sizeOffset));\n  const digest = bytes$1.subarray(sizeOffset + digestOffset);\n  if (digest.byteLength !== size) {\n    throw new Error('Incorrect length');\n  }\n  return new Digest(code, size, digest, bytes$1);\n};\nconst equals = (a, b) => {\n  if (a === b) {\n    return true;\n  } else {\n    return a.code === b.code && a.size === b.size && bytes.equals(a.bytes, b.bytes);\n  }\n};\nclass Digest {\n  constructor(code, size, digest, bytes) {\n    this.code = code;\n    this.size = size;\n    this.digest = digest;\n    this.bytes = bytes;\n  }\n}\n\nexports.Digest = Digest;\nexports.create = create;\nexports.decode = decode;\nexports.equals = equals;\n","/**\n * Multihash implementation in JavaScript.\n *\n * @module multihash\n */\n'use strict'\n\nconst { Buffer } = require('buffer')\nconst multibase = require('multibase')\nconst varint = require('varint')\nconst cs = require('./constants')\n\nexports.names = cs.names\nexports.codes = cs.codes\nexports.defaultLengths = cs.defaultLengths\n\n/**\n * Convert the given multihash to a hex encoded string.\n *\n * @param {Buffer} hash\n * @returns {string}\n */\nexports.toHexString = function toHexString (hash) {\n  if (!Buffer.isBuffer(hash)) {\n    throw new Error('must be passed a buffer')\n  }\n\n  return hash.toString('hex')\n}\n\n/**\n * Convert the given hex encoded string to a multihash.\n *\n * @param {string} hash\n * @returns {Buffer}\n */\nexports.fromHexString = function fromHexString (hash) {\n  return Buffer.from(hash, 'hex')\n}\n\n/**\n * Convert the given multihash to a base58 encoded string.\n *\n * @param {Buffer} hash\n * @returns {string}\n */\nexports.toB58String = function toB58String (hash) {\n  if (!Buffer.isBuffer(hash)) {\n    throw new Error('must be passed a buffer')\n  }\n\n  return multibase.encode('base58btc', hash).toString().slice(1)\n}\n\n/**\n * Convert the given base58 encoded string to a multihash.\n *\n * @param {string|Buffer} hash\n * @returns {Buffer}\n */\nexports.fromB58String = function fromB58String (hash) {\n  let encoded = hash\n  if (Buffer.isBuffer(hash)) {\n    encoded = hash.toString()\n  }\n\n  return multibase.decode('z' + encoded)\n}\n\n/**\n * Decode a hash from the given multihash.\n *\n * @param {Buffer} buf\n * @returns {{code: number, name: string, length: number, digest: Buffer}} result\n */\nexports.decode = function decode (buf) {\n  if (!(Buffer.isBuffer(buf))) {\n    throw new Error('multihash must be a Buffer')\n  }\n\n  if (buf.length < 2) {\n    throw new Error('multihash too short. must be > 2 bytes.')\n  }\n\n  const code = varint.decode(buf)\n  if (!exports.isValidCode(code)) {\n    throw new Error(`multihash unknown function code: 0x${code.toString(16)}`)\n  }\n  buf = buf.slice(varint.decode.bytes)\n\n  const len = varint.decode(buf)\n  if (len < 0) {\n    throw new Error(`multihash invalid length: ${len}`)\n  }\n  buf = buf.slice(varint.decode.bytes)\n\n  if (buf.length !== len) {\n    throw new Error(`multihash length inconsistent: 0x${buf.toString('hex')}`)\n  }\n\n  return {\n    code: code,\n    name: cs.codes[code],\n    length: len,\n    digest: buf\n  }\n}\n\n/**\n *  Encode a hash digest along with the specified function code.\n *\n * > **Note:** the length is derived from the length of the digest itself.\n *\n * @param {Buffer} digest\n * @param {string|number} code\n * @param {number} [length]\n * @returns {Buffer}\n */\nexports.encode = function encode (digest, code, length) {\n  if (!digest || code === undefined) {\n    throw new Error('multihash encode requires at least two args: digest, code')\n  }\n\n  // ensure it's a hashfunction code.\n  const hashfn = exports.coerceCode(code)\n\n  if (!(Buffer.isBuffer(digest))) {\n    throw new Error('digest should be a Buffer')\n  }\n\n  if (length == null) {\n    length = digest.length\n  }\n\n  if (length && digest.length !== length) {\n    throw new Error('digest length should be equal to specified length.')\n  }\n\n  return Buffer.concat([\n    Buffer.from(varint.encode(hashfn)),\n    Buffer.from(varint.encode(length)),\n    digest\n  ])\n}\n\n/**\n * Converts a hash function name into the matching code.\n * If passed a number it will return the number if it's a valid code.\n * @param {string|number} name\n * @returns {number}\n */\nexports.coerceCode = function coerceCode (name) {\n  let code = name\n\n  if (typeof name === 'string') {\n    if (cs.names[name] === undefined) {\n      throw new Error(`Unrecognized hash function named: ${name}`)\n    }\n    code = cs.names[name]\n  }\n\n  if (typeof code !== 'number') {\n    throw new Error(`Hash function code should be a number. Got: ${code}`)\n  }\n\n  if (cs.codes[code] === undefined && !exports.isAppCode(code)) {\n    throw new Error(`Unrecognized function code: ${code}`)\n  }\n\n  return code\n}\n\n/**\n * Checks wether a code is part of the app range\n *\n * @param {number} code\n * @returns {boolean}\n */\nexports.isAppCode = function appCode (code) {\n  return code > 0 && code < 0x10\n}\n\n/**\n * Checks whether a multihash code is valid.\n *\n * @param {number} code\n * @returns {boolean}\n */\nexports.isValidCode = function validCode (code) {\n  if (exports.isAppCode(code)) {\n    return true\n  }\n\n  if (cs.codes[code]) {\n    return true\n  }\n\n  return false\n}\n\n/**\n * Check if the given buffer is a valid multihash. Throws an error if it is not valid.\n *\n * @param {Buffer} multihash\n * @returns {undefined}\n * @throws {Error}\n */\nfunction validate (multihash) {\n  exports.decode(multihash) // throws if bad.\n}\nexports.validate = validate\n\n/**\n * Returns a prefix from a valid multihash. Throws an error if it is not valid.\n *\n * @param {Buffer} multihash\n * @returns {undefined}\n * @throws {Error}\n */\nexports.prefix = function prefix (multihash) {\n  validate(multihash)\n\n  return multihash.slice(0, 2)\n}\n","exports.nextTick = function nextTick(fn) {\n    var args = Array.prototype.slice.call(arguments);\n    args.shift();\n    setTimeout(function () {\n        fn.apply(null, args);\n    }, 0);\n};\n\nexports.platform = exports.arch = \nexports.execPath = exports.title = 'browser';\nexports.pid = 1;\nexports.browser = true;\nexports.env = {};\nexports.argv = [];\n\nexports.binding = function (name) {\n\tthrow new Error('No such module. (Possibly not yet loaded)')\n};\n\n(function () {\n    var cwd = '/';\n    var path;\n    exports.cwd = function () { return cwd };\n    exports.chdir = function (dir) {\n        if (!path) path = require('path');\n        cwd = path.resolve(dir, cwd);\n    };\n})();\n\nexports.exit = exports.kill = \nexports.umask = exports.dlopen = \nexports.uptime = exports.memoryUsage = \nexports.uvCounters = function() {};\nexports.features = {};\n","/* eslint quote-props: off */\n/* eslint key-spacing: off */\n'use strict'\n\nexports.names = Object.freeze({\n  'identity':   0x0,\n  'sha1':       0x11,\n  'sha2-256':   0x12,\n  'sha2-512':   0x13,\n  'dbl-sha2-256': 0x56,\n  'sha3-224':   0x17,\n  'sha3-256':   0x16,\n  'sha3-384':   0x15,\n  'sha3-512':   0x14,\n  'shake-128':  0x18,\n  'shake-256':  0x19,\n  'keccak-224': 0x1A,\n  'keccak-256': 0x1B,\n  'keccak-384': 0x1C,\n  'keccak-512': 0x1D,\n  'murmur3-128': 0x22,\n  'murmur3-32':  0x23,\n  'md4':         0xd4,\n  'md5':         0xd5,\n  'blake2b-8':   0xb201,\n  'blake2b-16':  0xb202,\n  'blake2b-24':  0xb203,\n  'blake2b-32':  0xb204,\n  'blake2b-40':  0xb205,\n  'blake2b-48':  0xb206,\n  'blake2b-56':  0xb207,\n  'blake2b-64':  0xb208,\n  'blake2b-72':  0xb209,\n  'blake2b-80':  0xb20a,\n  'blake2b-88':  0xb20b,\n  'blake2b-96':  0xb20c,\n  'blake2b-104': 0xb20d,\n  'blake2b-112': 0xb20e,\n  'blake2b-120': 0xb20f,\n  'blake2b-128': 0xb210,\n  'blake2b-136': 0xb211,\n  'blake2b-144': 0xb212,\n  'blake2b-152': 0xb213,\n  'blake2b-160': 0xb214,\n  'blake2b-168': 0xb215,\n  'blake2b-176': 0xb216,\n  'blake2b-184': 0xb217,\n  'blake2b-192': 0xb218,\n  'blake2b-200': 0xb219,\n  'blake2b-208': 0xb21a,\n  'blake2b-216': 0xb21b,\n  'blake2b-224': 0xb21c,\n  'blake2b-232': 0xb21d,\n  'blake2b-240': 0xb21e,\n  'blake2b-248': 0xb21f,\n  'blake2b-256': 0xb220,\n  'blake2b-264': 0xb221,\n  'blake2b-272': 0xb222,\n  'blake2b-280': 0xb223,\n  'blake2b-288': 0xb224,\n  'blake2b-296': 0xb225,\n  'blake2b-304': 0xb226,\n  'blake2b-312': 0xb227,\n  'blake2b-320': 0xb228,\n  'blake2b-328': 0xb229,\n  'blake2b-336': 0xb22a,\n  'blake2b-344': 0xb22b,\n  'blake2b-352': 0xb22c,\n  'blake2b-360': 0xb22d,\n  'blake2b-368': 0xb22e,\n  'blake2b-376': 0xb22f,\n  'blake2b-384': 0xb230,\n  'blake2b-392': 0xb231,\n  'blake2b-400': 0xb232,\n  'blake2b-408': 0xb233,\n  'blake2b-416': 0xb234,\n  'blake2b-424': 0xb235,\n  'blake2b-432': 0xb236,\n  'blake2b-440': 0xb237,\n  'blake2b-448': 0xb238,\n  'blake2b-456': 0xb239,\n  'blake2b-464': 0xb23a,\n  'blake2b-472': 0xb23b,\n  'blake2b-480': 0xb23c,\n  'blake2b-488': 0xb23d,\n  'blake2b-496': 0xb23e,\n  'blake2b-504': 0xb23f,\n  'blake2b-512': 0xb240,\n  'blake2s-8':   0xb241,\n  'blake2s-16':  0xb242,\n  'blake2s-24':  0xb243,\n  'blake2s-32':  0xb244,\n  'blake2s-40':  0xb245,\n  'blake2s-48':  0xb246,\n  'blake2s-56':  0xb247,\n  'blake2s-64':  0xb248,\n  'blake2s-72':  0xb249,\n  'blake2s-80':  0xb24a,\n  'blake2s-88':  0xb24b,\n  'blake2s-96':  0xb24c,\n  'blake2s-104': 0xb24d,\n  'blake2s-112': 0xb24e,\n  'blake2s-120': 0xb24f,\n  'blake2s-128': 0xb250,\n  'blake2s-136': 0xb251,\n  'blake2s-144': 0xb252,\n  'blake2s-152': 0xb253,\n  'blake2s-160': 0xb254,\n  'blake2s-168': 0xb255,\n  'blake2s-176': 0xb256,\n  'blake2s-184': 0xb257,\n  'blake2s-192': 0xb258,\n  'blake2s-200': 0xb259,\n  'blake2s-208': 0xb25a,\n  'blake2s-216': 0xb25b,\n  'blake2s-224': 0xb25c,\n  'blake2s-232': 0xb25d,\n  'blake2s-240': 0xb25e,\n  'blake2s-248': 0xb25f,\n  'blake2s-256': 0xb260,\n  'Skein256-8': 0xb301,\n  'Skein256-16': 0xb302,\n  'Skein256-24': 0xb303,\n  'Skein256-32': 0xb304,\n  'Skein256-40': 0xb305,\n  'Skein256-48': 0xb306,\n  'Skein256-56': 0xb307,\n  'Skein256-64': 0xb308,\n  'Skein256-72': 0xb309,\n  'Skein256-80': 0xb30a,\n  'Skein256-88': 0xb30b,\n  'Skein256-96': 0xb30c,\n  'Skein256-104': 0xb30d,\n  'Skein256-112': 0xb30e,\n  'Skein256-120': 0xb30f,\n  'Skein256-128': 0xb310,\n  'Skein256-136': 0xb311,\n  'Skein256-144': 0xb312,\n  'Skein256-152': 0xb313,\n  'Skein256-160': 0xb314,\n  'Skein256-168': 0xb315,\n  'Skein256-176': 0xb316,\n  'Skein256-184': 0xb317,\n  'Skein256-192': 0xb318,\n  'Skein256-200': 0xb319,\n  'Skein256-208': 0xb31a,\n  'Skein256-216': 0xb31b,\n  'Skein256-224': 0xb31c,\n  'Skein256-232': 0xb31d,\n  'Skein256-240': 0xb31e,\n  'Skein256-248': 0xb31f,\n  'Skein256-256': 0xb320,\n  'Skein512-8': 0xb321,\n  'Skein512-16': 0xb322,\n  'Skein512-24': 0xb323,\n  'Skein512-32': 0xb324,\n  'Skein512-40': 0xb325,\n  'Skein512-48': 0xb326,\n  'Skein512-56': 0xb327,\n  'Skein512-64': 0xb328,\n  'Skein512-72': 0xb329,\n  'Skein512-80': 0xb32a,\n  'Skein512-88': 0xb32b,\n  'Skein512-96': 0xb32c,\n  'Skein512-104': 0xb32d,\n  'Skein512-112': 0xb32e,\n  'Skein512-120': 0xb32f,\n  'Skein512-128': 0xb330,\n  'Skein512-136': 0xb331,\n  'Skein512-144': 0xb332,\n  'Skein512-152': 0xb333,\n  'Skein512-160': 0xb334,\n  'Skein512-168': 0xb335,\n  'Skein512-176': 0xb336,\n  'Skein512-184': 0xb337,\n  'Skein512-192': 0xb338,\n  'Skein512-200': 0xb339,\n  'Skein512-208': 0xb33a,\n  'Skein512-216': 0xb33b,\n  'Skein512-224': 0xb33c,\n  'Skein512-232': 0xb33d,\n  'Skein512-240': 0xb33e,\n  'Skein512-248': 0xb33f,\n  'Skein512-256': 0xb340,\n  'Skein512-264': 0xb341,\n  'Skein512-272': 0xb342,\n  'Skein512-280': 0xb343,\n  'Skein512-288': 0xb344,\n  'Skein512-296': 0xb345,\n  'Skein512-304': 0xb346,\n  'Skein512-312': 0xb347,\n  'Skein512-320': 0xb348,\n  'Skein512-328': 0xb349,\n  'Skein512-336': 0xb34a,\n  'Skein512-344': 0xb34b,\n  'Skein512-352': 0xb34c,\n  'Skein512-360': 0xb34d,\n  'Skein512-368': 0xb34e,\n  'Skein512-376': 0xb34f,\n  'Skein512-384': 0xb350,\n  'Skein512-392': 0xb351,\n  'Skein512-400': 0xb352,\n  'Skein512-408': 0xb353,\n  'Skein512-416': 0xb354,\n  'Skein512-424': 0xb355,\n  'Skein512-432': 0xb356,\n  'Skein512-440': 0xb357,\n  'Skein512-448': 0xb358,\n  'Skein512-456': 0xb359,\n  'Skein512-464': 0xb35a,\n  'Skein512-472': 0xb35b,\n  'Skein512-480': 0xb35c,\n  'Skein512-488': 0xb35d,\n  'Skein512-496': 0xb35e,\n  'Skein512-504': 0xb35f,\n  'Skein512-512': 0xb360,\n  'Skein1024-8': 0xb361,\n  'Skein1024-16': 0xb362,\n  'Skein1024-24': 0xb363,\n  'Skein1024-32': 0xb364,\n  'Skein1024-40': 0xb365,\n  'Skein1024-48': 0xb366,\n  'Skein1024-56': 0xb367,\n  'Skein1024-64': 0xb368,\n  'Skein1024-72': 0xb369,\n  'Skein1024-80': 0xb36a,\n  'Skein1024-88': 0xb36b,\n  'Skein1024-96': 0xb36c,\n  'Skein1024-104': 0xb36d,\n  'Skein1024-112': 0xb36e,\n  'Skein1024-120': 0xb36f,\n  'Skein1024-128': 0xb370,\n  'Skein1024-136': 0xb371,\n  'Skein1024-144': 0xb372,\n  'Skein1024-152': 0xb373,\n  'Skein1024-160': 0xb374,\n  'Skein1024-168': 0xb375,\n  'Skein1024-176': 0xb376,\n  'Skein1024-184': 0xb377,\n  'Skein1024-192': 0xb378,\n  'Skein1024-200': 0xb379,\n  'Skein1024-208': 0xb37a,\n  'Skein1024-216': 0xb37b,\n  'Skein1024-224': 0xb37c,\n  'Skein1024-232': 0xb37d,\n  'Skein1024-240': 0xb37e,\n  'Skein1024-248': 0xb37f,\n  'Skein1024-256': 0xb380,\n  'Skein1024-264': 0xb381,\n  'Skein1024-272': 0xb382,\n  'Skein1024-280': 0xb383,\n  'Skein1024-288': 0xb384,\n  'Skein1024-296': 0xb385,\n  'Skein1024-304': 0xb386,\n  'Skein1024-312': 0xb387,\n  'Skein1024-320': 0xb388,\n  'Skein1024-328': 0xb389,\n  'Skein1024-336': 0xb38a,\n  'Skein1024-344': 0xb38b,\n  'Skein1024-352': 0xb38c,\n  'Skein1024-360': 0xb38d,\n  'Skein1024-368': 0xb38e,\n  'Skein1024-376': 0xb38f,\n  'Skein1024-384': 0xb390,\n  'Skein1024-392': 0xb391,\n  'Skein1024-400': 0xb392,\n  'Skein1024-408': 0xb393,\n  'Skein1024-416': 0xb394,\n  'Skein1024-424': 0xb395,\n  'Skein1024-432': 0xb396,\n  'Skein1024-440': 0xb397,\n  'Skein1024-448': 0xb398,\n  'Skein1024-456': 0xb399,\n  'Skein1024-464': 0xb39a,\n  'Skein1024-472': 0xb39b,\n  'Skein1024-480': 0xb39c,\n  'Skein1024-488': 0xb39d,\n  'Skein1024-496': 0xb39e,\n  'Skein1024-504': 0xb39f,\n  'Skein1024-512': 0xb3a0,\n  'Skein1024-520': 0xb3a1,\n  'Skein1024-528': 0xb3a2,\n  'Skein1024-536': 0xb3a3,\n  'Skein1024-544': 0xb3a4,\n  'Skein1024-552': 0xb3a5,\n  'Skein1024-560': 0xb3a6,\n  'Skein1024-568': 0xb3a7,\n  'Skein1024-576': 0xb3a8,\n  'Skein1024-584': 0xb3a9,\n  'Skein1024-592': 0xb3aa,\n  'Skein1024-600': 0xb3ab,\n  'Skein1024-608': 0xb3ac,\n  'Skein1024-616': 0xb3ad,\n  'Skein1024-624': 0xb3ae,\n  'Skein1024-632': 0xb3af,\n  'Skein1024-640': 0xb3b0,\n  'Skein1024-648': 0xb3b1,\n  'Skein1024-656': 0xb3b2,\n  'Skein1024-664': 0xb3b3,\n  'Skein1024-672': 0xb3b4,\n  'Skein1024-680': 0xb3b5,\n  'Skein1024-688': 0xb3b6,\n  'Skein1024-696': 0xb3b7,\n  'Skein1024-704': 0xb3b8,\n  'Skein1024-712': 0xb3b9,\n  'Skein1024-720': 0xb3ba,\n  'Skein1024-728': 0xb3bb,\n  'Skein1024-736': 0xb3bc,\n  'Skein1024-744': 0xb3bd,\n  'Skein1024-752': 0xb3be,\n  'Skein1024-760': 0xb3bf,\n  'Skein1024-768': 0xb3c0,\n  'Skein1024-776': 0xb3c1,\n  'Skein1024-784': 0xb3c2,\n  'Skein1024-792': 0xb3c3,\n  'Skein1024-800': 0xb3c4,\n  'Skein1024-808': 0xb3c5,\n  'Skein1024-816': 0xb3c6,\n  'Skein1024-824': 0xb3c7,\n  'Skein1024-832': 0xb3c8,\n  'Skein1024-840': 0xb3c9,\n  'Skein1024-848': 0xb3ca,\n  'Skein1024-856': 0xb3cb,\n  'Skein1024-864': 0xb3cc,\n  'Skein1024-872': 0xb3cd,\n  'Skein1024-880': 0xb3ce,\n  'Skein1024-888': 0xb3cf,\n  'Skein1024-896': 0xb3d0,\n  'Skein1024-904': 0xb3d1,\n  'Skein1024-912': 0xb3d2,\n  'Skein1024-920': 0xb3d3,\n  'Skein1024-928': 0xb3d4,\n  'Skein1024-936': 0xb3d5,\n  'Skein1024-944': 0xb3d6,\n  'Skein1024-952': 0xb3d7,\n  'Skein1024-960': 0xb3d8,\n  'Skein1024-968': 0xb3d9,\n  'Skein1024-976': 0xb3da,\n  'Skein1024-984': 0xb3db,\n  'Skein1024-992': 0xb3dc,\n  'Skein1024-1000': 0xb3dd,\n  'Skein1024-1008': 0xb3de,\n  'Skein1024-1016': 0xb3df,\n  'Skein1024-1024': 0xb3e0\n})\n\nexports.codes = Object.freeze({\n  0x0: 'identity',\n\n  // sha family\n  0x11: 'sha1',\n  0x12: 'sha2-256',\n  0x13: 'sha2-512',\n  0x56: 'dbl-sha2-256',\n  0x17: 'sha3-224',\n  0x16: 'sha3-256',\n  0x15: 'sha3-384',\n  0x14: 'sha3-512',\n  0x18: 'shake-128',\n  0x19: 'shake-256',\n  0x1A: 'keccak-224',\n  0x1B: 'keccak-256',\n  0x1C: 'keccak-384',\n  0x1D: 'keccak-512',\n\n  0x22: 'murmur3-128',\n  0x23: 'murmur3-32',\n\n  0xd4: 'md4',\n  0xd5: 'md5',\n\n  // blake2\n  0xb201: 'blake2b-8',\n  0xb202: 'blake2b-16',\n  0xb203: 'blake2b-24',\n  0xb204: 'blake2b-32',\n  0xb205: 'blake2b-40',\n  0xb206: 'blake2b-48',\n  0xb207: 'blake2b-56',\n  0xb208: 'blake2b-64',\n  0xb209: 'blake2b-72',\n  0xb20a: 'blake2b-80',\n  0xb20b: 'blake2b-88',\n  0xb20c: 'blake2b-96',\n  0xb20d: 'blake2b-104',\n  0xb20e: 'blake2b-112',\n  0xb20f: 'blake2b-120',\n  0xb210: 'blake2b-128',\n  0xb211: 'blake2b-136',\n  0xb212: 'blake2b-144',\n  0xb213: 'blake2b-152',\n  0xb214: 'blake2b-160',\n  0xb215: 'blake2b-168',\n  0xb216: 'blake2b-176',\n  0xb217: 'blake2b-184',\n  0xb218: 'blake2b-192',\n  0xb219: 'blake2b-200',\n  0xb21a: 'blake2b-208',\n  0xb21b: 'blake2b-216',\n  0xb21c: 'blake2b-224',\n  0xb21d: 'blake2b-232',\n  0xb21e: 'blake2b-240',\n  0xb21f: 'blake2b-248',\n  0xb220: 'blake2b-256',\n  0xb221: 'blake2b-264',\n  0xb222: 'blake2b-272',\n  0xb223: 'blake2b-280',\n  0xb224: 'blake2b-288',\n  0xb225: 'blake2b-296',\n  0xb226: 'blake2b-304',\n  0xb227: 'blake2b-312',\n  0xb228: 'blake2b-320',\n  0xb229: 'blake2b-328',\n  0xb22a: 'blake2b-336',\n  0xb22b: 'blake2b-344',\n  0xb22c: 'blake2b-352',\n  0xb22d: 'blake2b-360',\n  0xb22e: 'blake2b-368',\n  0xb22f: 'blake2b-376',\n  0xb230: 'blake2b-384',\n  0xb231: 'blake2b-392',\n  0xb232: 'blake2b-400',\n  0xb233: 'blake2b-408',\n  0xb234: 'blake2b-416',\n  0xb235: 'blake2b-424',\n  0xb236: 'blake2b-432',\n  0xb237: 'blake2b-440',\n  0xb238: 'blake2b-448',\n  0xb239: 'blake2b-456',\n  0xb23a: 'blake2b-464',\n  0xb23b: 'blake2b-472',\n  0xb23c: 'blake2b-480',\n  0xb23d: 'blake2b-488',\n  0xb23e: 'blake2b-496',\n  0xb23f: 'blake2b-504',\n  0xb240: 'blake2b-512',\n  0xb241: 'blake2s-8',\n  0xb242: 'blake2s-16',\n  0xb243: 'blake2s-24',\n  0xb244: 'blake2s-32',\n  0xb245: 'blake2s-40',\n  0xb246: 'blake2s-48',\n  0xb247: 'blake2s-56',\n  0xb248: 'blake2s-64',\n  0xb249: 'blake2s-72',\n  0xb24a: 'blake2s-80',\n  0xb24b: 'blake2s-88',\n  0xb24c: 'blake2s-96',\n  0xb24d: 'blake2s-104',\n  0xb24e: 'blake2s-112',\n  0xb24f: 'blake2s-120',\n  0xb250: 'blake2s-128',\n  0xb251: 'blake2s-136',\n  0xb252: 'blake2s-144',\n  0xb253: 'blake2s-152',\n  0xb254: 'blake2s-160',\n  0xb255: 'blake2s-168',\n  0xb256: 'blake2s-176',\n  0xb257: 'blake2s-184',\n  0xb258: 'blake2s-192',\n  0xb259: 'blake2s-200',\n  0xb25a: 'blake2s-208',\n  0xb25b: 'blake2s-216',\n  0xb25c: 'blake2s-224',\n  0xb25d: 'blake2s-232',\n  0xb25e: 'blake2s-240',\n  0xb25f: 'blake2s-248',\n  0xb260: 'blake2s-256',\n\n  // skein\n  0xb301: 'Skein256-8',\n  0xb302: 'Skein256-16',\n  0xb303: 'Skein256-24',\n  0xb304: 'Skein256-32',\n  0xb305: 'Skein256-40',\n  0xb306: 'Skein256-48',\n  0xb307: 'Skein256-56',\n  0xb308: 'Skein256-64',\n  0xb309: 'Skein256-72',\n  0xb30a: 'Skein256-80',\n  0xb30b: 'Skein256-88',\n  0xb30c: 'Skein256-96',\n  0xb30d: 'Skein256-104',\n  0xb30e: 'Skein256-112',\n  0xb30f: 'Skein256-120',\n  0xb310: 'Skein256-128',\n  0xb311: 'Skein256-136',\n  0xb312: 'Skein256-144',\n  0xb313: 'Skein256-152',\n  0xb314: 'Skein256-160',\n  0xb315: 'Skein256-168',\n  0xb316: 'Skein256-176',\n  0xb317: 'Skein256-184',\n  0xb318: 'Skein256-192',\n  0xb319: 'Skein256-200',\n  0xb31a: 'Skein256-208',\n  0xb31b: 'Skein256-216',\n  0xb31c: 'Skein256-224',\n  0xb31d: 'Skein256-232',\n  0xb31e: 'Skein256-240',\n  0xb31f: 'Skein256-248',\n  0xb320: 'Skein256-256',\n  0xb321: 'Skein512-8',\n  0xb322: 'Skein512-16',\n  0xb323: 'Skein512-24',\n  0xb324: 'Skein512-32',\n  0xb325: 'Skein512-40',\n  0xb326: 'Skein512-48',\n  0xb327: 'Skein512-56',\n  0xb328: 'Skein512-64',\n  0xb329: 'Skein512-72',\n  0xb32a: 'Skein512-80',\n  0xb32b: 'Skein512-88',\n  0xb32c: 'Skein512-96',\n  0xb32d: 'Skein512-104',\n  0xb32e: 'Skein512-112',\n  0xb32f: 'Skein512-120',\n  0xb330: 'Skein512-128',\n  0xb331: 'Skein512-136',\n  0xb332: 'Skein512-144',\n  0xb333: 'Skein512-152',\n  0xb334: 'Skein512-160',\n  0xb335: 'Skein512-168',\n  0xb336: 'Skein512-176',\n  0xb337: 'Skein512-184',\n  0xb338: 'Skein512-192',\n  0xb339: 'Skein512-200',\n  0xb33a: 'Skein512-208',\n  0xb33b: 'Skein512-216',\n  0xb33c: 'Skein512-224',\n  0xb33d: 'Skein512-232',\n  0xb33e: 'Skein512-240',\n  0xb33f: 'Skein512-248',\n  0xb340: 'Skein512-256',\n  0xb341: 'Skein512-264',\n  0xb342: 'Skein512-272',\n  0xb343: 'Skein512-280',\n  0xb344: 'Skein512-288',\n  0xb345: 'Skein512-296',\n  0xb346: 'Skein512-304',\n  0xb347: 'Skein512-312',\n  0xb348: 'Skein512-320',\n  0xb349: 'Skein512-328',\n  0xb34a: 'Skein512-336',\n  0xb34b: 'Skein512-344',\n  0xb34c: 'Skein512-352',\n  0xb34d: 'Skein512-360',\n  0xb34e: 'Skein512-368',\n  0xb34f: 'Skein512-376',\n  0xb350: 'Skein512-384',\n  0xb351: 'Skein512-392',\n  0xb352: 'Skein512-400',\n  0xb353: 'Skein512-408',\n  0xb354: 'Skein512-416',\n  0xb355: 'Skein512-424',\n  0xb356: 'Skein512-432',\n  0xb357: 'Skein512-440',\n  0xb358: 'Skein512-448',\n  0xb359: 'Skein512-456',\n  0xb35a: 'Skein512-464',\n  0xb35b: 'Skein512-472',\n  0xb35c: 'Skein512-480',\n  0xb35d: 'Skein512-488',\n  0xb35e: 'Skein512-496',\n  0xb35f: 'Skein512-504',\n  0xb360: 'Skein512-512',\n  0xb361: 'Skein1024-8',\n  0xb362: 'Skein1024-16',\n  0xb363: 'Skein1024-24',\n  0xb364: 'Skein1024-32',\n  0xb365: 'Skein1024-40',\n  0xb366: 'Skein1024-48',\n  0xb367: 'Skein1024-56',\n  0xb368: 'Skein1024-64',\n  0xb369: 'Skein1024-72',\n  0xb36a: 'Skein1024-80',\n  0xb36b: 'Skein1024-88',\n  0xb36c: 'Skein1024-96',\n  0xb36d: 'Skein1024-104',\n  0xb36e: 'Skein1024-112',\n  0xb36f: 'Skein1024-120',\n  0xb370: 'Skein1024-128',\n  0xb371: 'Skein1024-136',\n  0xb372: 'Skein1024-144',\n  0xb373: 'Skein1024-152',\n  0xb374: 'Skein1024-160',\n  0xb375: 'Skein1024-168',\n  0xb376: 'Skein1024-176',\n  0xb377: 'Skein1024-184',\n  0xb378: 'Skein1024-192',\n  0xb379: 'Skein1024-200',\n  0xb37a: 'Skein1024-208',\n  0xb37b: 'Skein1024-216',\n  0xb37c: 'Skein1024-224',\n  0xb37d: 'Skein1024-232',\n  0xb37e: 'Skein1024-240',\n  0xb37f: 'Skein1024-248',\n  0xb380: 'Skein1024-256',\n  0xb381: 'Skein1024-264',\n  0xb382: 'Skein1024-272',\n  0xb383: 'Skein1024-280',\n  0xb384: 'Skein1024-288',\n  0xb385: 'Skein1024-296',\n  0xb386: 'Skein1024-304',\n  0xb387: 'Skein1024-312',\n  0xb388: 'Skein1024-320',\n  0xb389: 'Skein1024-328',\n  0xb38a: 'Skein1024-336',\n  0xb38b: 'Skein1024-344',\n  0xb38c: 'Skein1024-352',\n  0xb38d: 'Skein1024-360',\n  0xb38e: 'Skein1024-368',\n  0xb38f: 'Skein1024-376',\n  0xb390: 'Skein1024-384',\n  0xb391: 'Skein1024-392',\n  0xb392: 'Skein1024-400',\n  0xb393: 'Skein1024-408',\n  0xb394: 'Skein1024-416',\n  0xb395: 'Skein1024-424',\n  0xb396: 'Skein1024-432',\n  0xb397: 'Skein1024-440',\n  0xb398: 'Skein1024-448',\n  0xb399: 'Skein1024-456',\n  0xb39a: 'Skein1024-464',\n  0xb39b: 'Skein1024-472',\n  0xb39c: 'Skein1024-480',\n  0xb39d: 'Skein1024-488',\n  0xb39e: 'Skein1024-496',\n  0xb39f: 'Skein1024-504',\n  0xb3a0: 'Skein1024-512',\n  0xb3a1: 'Skein1024-520',\n  0xb3a2: 'Skein1024-528',\n  0xb3a3: 'Skein1024-536',\n  0xb3a4: 'Skein1024-544',\n  0xb3a5: 'Skein1024-552',\n  0xb3a6: 'Skein1024-560',\n  0xb3a7: 'Skein1024-568',\n  0xb3a8: 'Skein1024-576',\n  0xb3a9: 'Skein1024-584',\n  0xb3aa: 'Skein1024-592',\n  0xb3ab: 'Skein1024-600',\n  0xb3ac: 'Skein1024-608',\n  0xb3ad: 'Skein1024-616',\n  0xb3ae: 'Skein1024-624',\n  0xb3af: 'Skein1024-632',\n  0xb3b0: 'Skein1024-640',\n  0xb3b1: 'Skein1024-648',\n  0xb3b2: 'Skein1024-656',\n  0xb3b3: 'Skein1024-664',\n  0xb3b4: 'Skein1024-672',\n  0xb3b5: 'Skein1024-680',\n  0xb3b6: 'Skein1024-688',\n  0xb3b7: 'Skein1024-696',\n  0xb3b8: 'Skein1024-704',\n  0xb3b9: 'Skein1024-712',\n  0xb3ba: 'Skein1024-720',\n  0xb3bb: 'Skein1024-728',\n  0xb3bc: 'Skein1024-736',\n  0xb3bd: 'Skein1024-744',\n  0xb3be: 'Skein1024-752',\n  0xb3bf: 'Skein1024-760',\n  0xb3c0: 'Skein1024-768',\n  0xb3c1: 'Skein1024-776',\n  0xb3c2: 'Skein1024-784',\n  0xb3c3: 'Skein1024-792',\n  0xb3c4: 'Skein1024-800',\n  0xb3c5: 'Skein1024-808',\n  0xb3c6: 'Skein1024-816',\n  0xb3c7: 'Skein1024-824',\n  0xb3c8: 'Skein1024-832',\n  0xb3c9: 'Skein1024-840',\n  0xb3ca: 'Skein1024-848',\n  0xb3cb: 'Skein1024-856',\n  0xb3cc: 'Skein1024-864',\n  0xb3cd: 'Skein1024-872',\n  0xb3ce: 'Skein1024-880',\n  0xb3cf: 'Skein1024-888',\n  0xb3d0: 'Skein1024-896',\n  0xb3d1: 'Skein1024-904',\n  0xb3d2: 'Skein1024-912',\n  0xb3d3: 'Skein1024-920',\n  0xb3d4: 'Skein1024-928',\n  0xb3d5: 'Skein1024-936',\n  0xb3d6: 'Skein1024-944',\n  0xb3d7: 'Skein1024-952',\n  0xb3d8: 'Skein1024-960',\n  0xb3d9: 'Skein1024-968',\n  0xb3da: 'Skein1024-976',\n  0xb3db: 'Skein1024-984',\n  0xb3dc: 'Skein1024-992',\n  0xb3dd: 'Skein1024-1000',\n  0xb3de: 'Skein1024-1008',\n  0xb3df: 'Skein1024-1016',\n  0xb3e0: 'Skein1024-1024'\n})\n\nexports.defaultLengths = Object.freeze({\n  0x11: 20,\n  0x12: 32,\n  0x13: 64,\n  0x56: 32,\n  0x17: 28,\n  0x16: 32,\n  0x15: 48,\n  0x14: 64,\n  0x18: 32,\n  0x19: 64,\n  0x1A: 28,\n  0x1B: 32,\n  0x1C: 48,\n  0x1D: 64,\n  0x22: 32,\n\n  0xb201: 0x01,\n  0xb202: 0x02,\n  0xb203: 0x03,\n  0xb204: 0x04,\n  0xb205: 0x05,\n  0xb206: 0x06,\n  0xb207: 0x07,\n  0xb208: 0x08,\n  0xb209: 0x09,\n  0xb20a: 0x0a,\n  0xb20b: 0x0b,\n  0xb20c: 0x0c,\n  0xb20d: 0x0d,\n  0xb20e: 0x0e,\n  0xb20f: 0x0f,\n  0xb210: 0x10,\n  0xb211: 0x11,\n  0xb212: 0x12,\n  0xb213: 0x13,\n  0xb214: 0x14,\n  0xb215: 0x15,\n  0xb216: 0x16,\n  0xb217: 0x17,\n  0xb218: 0x18,\n  0xb219: 0x19,\n  0xb21a: 0x1a,\n  0xb21b: 0x1b,\n  0xb21c: 0x1c,\n  0xb21d: 0x1d,\n  0xb21e: 0x1e,\n  0xb21f: 0x1f,\n  0xb220: 0x20,\n  0xb221: 0x21,\n  0xb222: 0x22,\n  0xb223: 0x23,\n  0xb224: 0x24,\n  0xb225: 0x25,\n  0xb226: 0x26,\n  0xb227: 0x27,\n  0xb228: 0x28,\n  0xb229: 0x29,\n  0xb22a: 0x2a,\n  0xb22b: 0x2b,\n  0xb22c: 0x2c,\n  0xb22d: 0x2d,\n  0xb22e: 0x2e,\n  0xb22f: 0x2f,\n  0xb230: 0x30,\n  0xb231: 0x31,\n  0xb232: 0x32,\n  0xb233: 0x33,\n  0xb234: 0x34,\n  0xb235: 0x35,\n  0xb236: 0x36,\n  0xb237: 0x37,\n  0xb238: 0x38,\n  0xb239: 0x39,\n  0xb23a: 0x3a,\n  0xb23b: 0x3b,\n  0xb23c: 0x3c,\n  0xb23d: 0x3d,\n  0xb23e: 0x3e,\n  0xb23f: 0x3f,\n  0xb240: 0x40,\n  0xb241: 0x01,\n  0xb242: 0x02,\n  0xb243: 0x03,\n  0xb244: 0x04,\n  0xb245: 0x05,\n  0xb246: 0x06,\n  0xb247: 0x07,\n  0xb248: 0x08,\n  0xb249: 0x09,\n  0xb24a: 0x0a,\n  0xb24b: 0x0b,\n  0xb24c: 0x0c,\n  0xb24d: 0x0d,\n  0xb24e: 0x0e,\n  0xb24f: 0x0f,\n  0xb250: 0x10,\n  0xb251: 0x11,\n  0xb252: 0x12,\n  0xb253: 0x13,\n  0xb254: 0x14,\n  0xb255: 0x15,\n  0xb256: 0x16,\n  0xb257: 0x17,\n  0xb258: 0x18,\n  0xb259: 0x19,\n  0xb25a: 0x1a,\n  0xb25b: 0x1b,\n  0xb25c: 0x1c,\n  0xb25d: 0x1d,\n  0xb25e: 0x1e,\n  0xb25f: 0x1f,\n  0xb260: 0x20,\n  0xb301: 0x01,\n  0xb302: 0x02,\n  0xb303: 0x03,\n  0xb304: 0x04,\n  0xb305: 0x05,\n  0xb306: 0x06,\n  0xb307: 0x07,\n  0xb308: 0x08,\n  0xb309: 0x09,\n  0xb30a: 0x0a,\n  0xb30b: 0x0b,\n  0xb30c: 0x0c,\n  0xb30d: 0x0d,\n  0xb30e: 0x0e,\n  0xb30f: 0x0f,\n  0xb310: 0x10,\n  0xb311: 0x11,\n  0xb312: 0x12,\n  0xb313: 0x13,\n  0xb314: 0x14,\n  0xb315: 0x15,\n  0xb316: 0x16,\n  0xb317: 0x17,\n  0xb318: 0x18,\n  0xb319: 0x19,\n  0xb31a: 0x1a,\n  0xb31b: 0x1b,\n  0xb31c: 0x1c,\n  0xb31d: 0x1d,\n  0xb31e: 0x1e,\n  0xb31f: 0x1f,\n  0xb320: 0x20,\n  0xb321: 0x01,\n  0xb322: 0x02,\n  0xb323: 0x03,\n  0xb324: 0x04,\n  0xb325: 0x05,\n  0xb326: 0x06,\n  0xb327: 0x07,\n  0xb328: 0x08,\n  0xb329: 0x09,\n  0xb32a: 0x0a,\n  0xb32b: 0x0b,\n  0xb32c: 0x0c,\n  0xb32d: 0x0d,\n  0xb32e: 0x0e,\n  0xb32f: 0x0f,\n  0xb330: 0x10,\n  0xb331: 0x11,\n  0xb332: 0x12,\n  0xb333: 0x13,\n  0xb334: 0x14,\n  0xb335: 0x15,\n  0xb336: 0x16,\n  0xb337: 0x17,\n  0xb338: 0x18,\n  0xb339: 0x19,\n  0xb33a: 0x1a,\n  0xb33b: 0x1b,\n  0xb33c: 0x1c,\n  0xb33d: 0x1d,\n  0xb33e: 0x1e,\n  0xb33f: 0x1f,\n  0xb340: 0x20,\n  0xb341: 0x21,\n  0xb342: 0x22,\n  0xb343: 0x23,\n  0xb344: 0x24,\n  0xb345: 0x25,\n  0xb346: 0x26,\n  0xb347: 0x27,\n  0xb348: 0x28,\n  0xb349: 0x29,\n  0xb34a: 0x2a,\n  0xb34b: 0x2b,\n  0xb34c: 0x2c,\n  0xb34d: 0x2d,\n  0xb34e: 0x2e,\n  0xb34f: 0x2f,\n  0xb350: 0x30,\n  0xb351: 0x31,\n  0xb352: 0x32,\n  0xb353: 0x33,\n  0xb354: 0x34,\n  0xb355: 0x35,\n  0xb356: 0x36,\n  0xb357: 0x37,\n  0xb358: 0x38,\n  0xb359: 0x39,\n  0xb35a: 0x3a,\n  0xb35b: 0x3b,\n  0xb35c: 0x3c,\n  0xb35d: 0x3d,\n  0xb35e: 0x3e,\n  0xb35f: 0x3f,\n  0xb360: 0x40,\n  0xb361: 0x01,\n  0xb362: 0x02,\n  0xb363: 0x03,\n  0xb364: 0x04,\n  0xb365: 0x05,\n  0xb366: 0x06,\n  0xb367: 0x07,\n  0xb368: 0x08,\n  0xb369: 0x09,\n  0xb36a: 0x0a,\n  0xb36b: 0x0b,\n  0xb36c: 0x0c,\n  0xb36d: 0x0d,\n  0xb36e: 0x0e,\n  0xb36f: 0x0f,\n  0xb370: 0x10,\n  0xb371: 0x11,\n  0xb372: 0x12,\n  0xb373: 0x13,\n  0xb374: 0x14,\n  0xb375: 0x15,\n  0xb376: 0x16,\n  0xb377: 0x17,\n  0xb378: 0x18,\n  0xb379: 0x19,\n  0xb37a: 0x1a,\n  0xb37b: 0x1b,\n  0xb37c: 0x1c,\n  0xb37d: 0x1d,\n  0xb37e: 0x1e,\n  0xb37f: 0x1f,\n  0xb380: 0x20,\n  0xb381: 0x21,\n  0xb382: 0x22,\n  0xb383: 0x23,\n  0xb384: 0x24,\n  0xb385: 0x25,\n  0xb386: 0x26,\n  0xb387: 0x27,\n  0xb388: 0x28,\n  0xb389: 0x29,\n  0xb38a: 0x2a,\n  0xb38b: 0x2b,\n  0xb38c: 0x2c,\n  0xb38d: 0x2d,\n  0xb38e: 0x2e,\n  0xb38f: 0x2f,\n  0xb390: 0x30,\n  0xb391: 0x31,\n  0xb392: 0x32,\n  0xb393: 0x33,\n  0xb394: 0x34,\n  0xb395: 0x35,\n  0xb396: 0x36,\n  0xb397: 0x37,\n  0xb398: 0x38,\n  0xb399: 0x39,\n  0xb39a: 0x3a,\n  0xb39b: 0x3b,\n  0xb39c: 0x3c,\n  0xb39d: 0x3d,\n  0xb39e: 0x3e,\n  0xb39f: 0x3f,\n  0xb3a0: 0x40,\n  0xb3a1: 0x41,\n  0xb3a2: 0x42,\n  0xb3a3: 0x43,\n  0xb3a4: 0x44,\n  0xb3a5: 0x45,\n  0xb3a6: 0x46,\n  0xb3a7: 0x47,\n  0xb3a8: 0x48,\n  0xb3a9: 0x49,\n  0xb3aa: 0x4a,\n  0xb3ab: 0x4b,\n  0xb3ac: 0x4c,\n  0xb3ad: 0x4d,\n  0xb3ae: 0x4e,\n  0xb3af: 0x4f,\n  0xb3b0: 0x50,\n  0xb3b1: 0x51,\n  0xb3b2: 0x52,\n  0xb3b3: 0x53,\n  0xb3b4: 0x54,\n  0xb3b5: 0x55,\n  0xb3b6: 0x56,\n  0xb3b7: 0x57,\n  0xb3b8: 0x58,\n  0xb3b9: 0x59,\n  0xb3ba: 0x5a,\n  0xb3bb: 0x5b,\n  0xb3bc: 0x5c,\n  0xb3bd: 0x5d,\n  0xb3be: 0x5e,\n  0xb3bf: 0x5f,\n  0xb3c0: 0x60,\n  0xb3c1: 0x61,\n  0xb3c2: 0x62,\n  0xb3c3: 0x63,\n  0xb3c4: 0x64,\n  0xb3c5: 0x65,\n  0xb3c6: 0x66,\n  0xb3c7: 0x67,\n  0xb3c8: 0x68,\n  0xb3c9: 0x69,\n  0xb3ca: 0x6a,\n  0xb3cb: 0x6b,\n  0xb3cc: 0x6c,\n  0xb3cd: 0x6d,\n  0xb3ce: 0x6e,\n  0xb3cf: 0x6f,\n  0xb3d0: 0x70,\n  0xb3d1: 0x71,\n  0xb3d2: 0x72,\n  0xb3d3: 0x73,\n  0xb3d4: 0x74,\n  0xb3d5: 0x75,\n  0xb3d6: 0x76,\n  0xb3d7: 0x77,\n  0xb3d8: 0x78,\n  0xb3d9: 0x79,\n  0xb3da: 0x7a,\n  0xb3db: 0x7b,\n  0xb3dc: 0x7c,\n  0xb3dd: 0x7d,\n  0xb3de: 0x7e,\n  0xb3df: 0x7f,\n  0xb3e0: 0x80\n})\n","'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\nvar base = require('./base.js');\n\nconst base36 = base.baseX({\n  prefix: 'k',\n  name: 'base36',\n  alphabet: '0123456789abcdefghijklmnopqrstuvwxyz'\n});\nconst base36upper = base.baseX({\n  prefix: 'K',\n  name: 'base36upper',\n  alphabet: '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ'\n});\n\nexports.base36 = base36;\nexports.base36upper = base36upper;\n","'use strict'\nconst baseTable = require('./base-table.json')\n\n// map for hexString -> codecName\nconst nameTable = new Map()\n\nfor (const encodingName in baseTable) {\n  const code = baseTable[encodingName]\n  nameTable.set(code, encodingName)\n}\n\nmodule.exports = Object.freeze(nameTable)\n","/**\n * Implementation of the multicodec specification.\n *\n * @module multicodec\n * @example\n * const multicodec = require('multicodec')\n *\n * const prefixedProtobuf = multicodec.addPrefix('protobuf', protobufBuffer)\n * // prefixedProtobuf 0x50...\n *\n */\n'use strict'\n\nconst varint = require('varint')\nconst intTable = require('./int-table')\nconst codecNameToCodeVarint = require('./varint-table')\nconst util = require('./util')\n\nexports = module.exports\n\n/**\n * Prefix a buffer with a multicodec-packed.\n *\n * @param {string|number} multicodecStrOrCode\n * @param {Buffer} data\n * @returns {Buffer}\n */\nexports.addPrefix = (multicodecStrOrCode, data) => {\n  let prefix\n\n  if (Buffer.isBuffer(multicodecStrOrCode)) {\n    prefix = util.varintBufferEncode(multicodecStrOrCode)\n  } else {\n    if (codecNameToCodeVarint[multicodecStrOrCode]) {\n      prefix = codecNameToCodeVarint[multicodecStrOrCode]\n    } else {\n      throw new Error('multicodec not recognized')\n    }\n  }\n  return Buffer.concat([prefix, data])\n}\n\n/**\n * Decapsulate the multicodec-packed prefix from the data.\n *\n * @param {Buffer} data\n * @returns {Buffer}\n */\nexports.rmPrefix = (data) => {\n  varint.decode(data)\n  return data.slice(varint.decode.bytes)\n}\n\n/**\n * Get the codec of the prefixed data.\n * @param {Buffer} prefixedData\n * @returns {string}\n */\nexports.getCodec = (prefixedData) => {\n  const code = varint.decode(prefixedData)\n  const codecName = intTable.get(code)\n  if (codecName === undefined) {\n    throw new Error(`Code ${code} not found`)\n  }\n  return codecName\n}\n\n/**\n * Get the name of the codec.\n * @param {number} codec\n * @returns {string}\n */\nexports.getName = (codec) => {\n  return intTable.get(codec)\n}\n\n/**\n * Get the code of the codec\n * @param {string} name\n * @returns {number}\n */\nexports.getNumber = (name) => {\n  const code = codecNameToCodeVarint[name]\n  if (code === undefined) {\n    throw new Error('Codec `' + name + '` not found')\n  }\n  return util.varintBufferDecode(code)[0]\n}\n\n/**\n * Get the code of the prefixed data.\n * @param {Buffer} prefixedData\n * @returns {number}\n */\nexports.getCode = (prefixedData) => {\n  return varint.decode(prefixedData)\n}\n\n/**\n * Get the code as varint of a codec name.\n * @param {string} codecName\n * @returns {Buffer}\n */\nexports.getCodeVarint = (codecName) => {\n  const code = codecNameToCodeVarint[codecName]\n  if (code === undefined) {\n    throw new Error('Codec `' + codecName + '` not found')\n  }\n  return code\n}\n\n/**\n * Get the varint of a code.\n * @param {Number} code\n * @returns {Array.<number>}\n */\nexports.getVarint = (code) => {\n  return varint.encode(code)\n}\n\n// Make the constants top-level constants\nconst constants = require('./constants')\nObject.assign(exports, constants)\n\n// Human friendly names for printing, e.g. in error messages\nexports.print = require('./print')\n","/**\n * Implementation of the [multibase](https://github.com/multiformats/multibase) specification.\n * @module Multibase\n */\n'use strict'\n\nconst { Buffer } = require('buffer')\nconst constants = require('./constants')\n\nexports = module.exports = multibase\nexports.encode = encode\nexports.decode = decode\nexports.isEncoded = isEncoded\nexports.names = Object.freeze(Object.keys(constants.names))\nexports.codes = Object.freeze(Object.keys(constants.codes))\n\n/**\n * Create a new buffer with the multibase varint+code.\n *\n * @param {string|number} nameOrCode - The multibase name or code number.\n * @param {Buffer} buf - The data to be prefixed with multibase.\n * @memberof Multibase\n * @returns {Buffer}\n */\nfunction multibase (nameOrCode, buf) {\n  if (!buf) {\n    throw new Error('requires an encoded buffer')\n  }\n  const base = getBase(nameOrCode)\n  const codeBuf = Buffer.from(base.code)\n\n  const name = base.name\n  validEncode(name, buf)\n  return Buffer.concat([codeBuf, buf])\n}\n\n/**\n * Encode data with the specified base and add the multibase prefix.\n *\n * @param {string|number} nameOrCode - The multibase name or code number.\n * @param {Buffer} buf - The data to be encoded.\n * @returns {Buffer}\n * @memberof Multibase\n */\nfunction encode (nameOrCode, buf) {\n  const base = getBase(nameOrCode)\n  const name = base.name\n\n  return multibase(name, Buffer.from(base.encode(buf)))\n}\n\n/**\n * Takes a buffer or string encoded with multibase header, decodes it and\n * returns the decoded buffer\n *\n * @param {Buffer|string} bufOrString\n * @returns {Buffer}\n * @memberof Multibase\n *\n */\nfunction decode (bufOrString) {\n  if (Buffer.isBuffer(bufOrString)) {\n    bufOrString = bufOrString.toString()\n  }\n\n  const code = bufOrString.substring(0, 1)\n  bufOrString = bufOrString.substring(1, bufOrString.length)\n\n  if (typeof bufOrString === 'string') {\n    bufOrString = Buffer.from(bufOrString)\n  }\n\n  const base = getBase(code)\n  return Buffer.from(base.decode(bufOrString.toString()))\n}\n\n/**\n * Is the given data multibase encoded?\n *\n * @param {Buffer|string} bufOrString\n * @returns {boolean}\n * @memberof Multibase\n */\nfunction isEncoded (bufOrString) {\n  if (Buffer.isBuffer(bufOrString)) {\n    bufOrString = bufOrString.toString()\n  }\n\n  // Ensure bufOrString is a string\n  if (Object.prototype.toString.call(bufOrString) !== '[object String]') {\n    return false\n  }\n\n  const code = bufOrString.substring(0, 1)\n  try {\n    const base = getBase(code)\n    return base.name\n  } catch (err) {\n    return false\n  }\n}\n\n/**\n * @param {string} name\n * @param {Buffer} buf\n * @private\n * @returns {undefined}\n */\nfunction validEncode (name, buf) {\n  const base = getBase(name)\n  base.decode(buf.toString())\n}\n\nfunction getBase (nameOrCode) {\n  let base\n\n  if (constants.names[nameOrCode]) {\n    base = constants.names[nameOrCode]\n  } else if (constants.codes[nameOrCode]) {\n    base = constants.codes[nameOrCode]\n  } else {\n    throw new Error('Unsupported encoding')\n  }\n\n  if (!base.isImplemented()) {\n    throw new Error('Base ' + nameOrCode + ' is not implemented yet')\n  }\n\n  return base\n}\n","'use strict';\n\nvar encode_1 = encode;\nvar MSB = 128, REST = 127, MSBALL = ~REST, INT = Math.pow(2, 31);\nfunction encode(num, out, offset) {\n  out = out || [];\n  offset = offset || 0;\n  var oldOffset = offset;\n  while (num >= INT) {\n    out[offset++] = num & 255 | MSB;\n    num /= 128;\n  }\n  while (num & MSBALL) {\n    out[offset++] = num & 255 | MSB;\n    num >>>= 7;\n  }\n  out[offset] = num | 0;\n  encode.bytes = offset - oldOffset + 1;\n  return out;\n}\nvar decode = read;\nvar MSB$1 = 128, REST$1 = 127;\nfunction read(buf, offset) {\n  var res = 0, offset = offset || 0, shift = 0, counter = offset, b, l = buf.length;\n  do {\n    if (counter >= l) {\n      read.bytes = 0;\n      throw new RangeError('Could not decode varint');\n    }\n    b = buf[counter++];\n    res += shift < 28 ? (b & REST$1) << shift : (b & REST$1) * Math.pow(2, shift);\n    shift += 7;\n  } while (b >= MSB$1);\n  read.bytes = counter - offset;\n  return res;\n}\nvar N1 = Math.pow(2, 7);\nvar N2 = Math.pow(2, 14);\nvar N3 = Math.pow(2, 21);\nvar N4 = Math.pow(2, 28);\nvar N5 = Math.pow(2, 35);\nvar N6 = Math.pow(2, 42);\nvar N7 = Math.pow(2, 49);\nvar N8 = Math.pow(2, 56);\nvar N9 = Math.pow(2, 63);\nvar length = function (value) {\n  return value < N1 ? 1 : value < N2 ? 2 : value < N3 ? 3 : value < N4 ? 4 : value < N5 ? 5 : value < N6 ? 6 : value < N7 ? 7 : value < N8 ? 8 : value < N9 ? 9 : 10;\n};\nvar varint = {\n  encode: encode_1,\n  decode: decode,\n  encodingLength: length\n};\nvar _brrp_varint = varint;\nvar varint$1 = _brrp_varint;\n\nmodule.exports = varint$1;\n","'use strict';\n\nfunction base(ALPHABET, name) {\n  if (ALPHABET.length >= 255) {\n    throw new TypeError('Alphabet too long');\n  }\n  var BASE_MAP = new Uint8Array(256);\n  for (var j = 0; j < BASE_MAP.length; j++) {\n    BASE_MAP[j] = 255;\n  }\n  for (var i = 0; i < ALPHABET.length; i++) {\n    var x = ALPHABET.charAt(i);\n    var xc = x.charCodeAt(0);\n    if (BASE_MAP[xc] !== 255) {\n      throw new TypeError(x + ' is ambiguous');\n    }\n    BASE_MAP[xc] = i;\n  }\n  var BASE = ALPHABET.length;\n  var LEADER = ALPHABET.charAt(0);\n  var FACTOR = Math.log(BASE) / Math.log(256);\n  var iFACTOR = Math.log(256) / Math.log(BASE);\n  function encode(source) {\n    if (source instanceof Uint8Array);\n    else if (ArrayBuffer.isView(source)) {\n      source = new Uint8Array(source.buffer, source.byteOffset, source.byteLength);\n    } else if (Array.isArray(source)) {\n      source = Uint8Array.from(source);\n    }\n    if (!(source instanceof Uint8Array)) {\n      throw new TypeError('Expected Uint8Array');\n    }\n    if (source.length === 0) {\n      return '';\n    }\n    var zeroes = 0;\n    var length = 0;\n    var pbegin = 0;\n    var pend = source.length;\n    while (pbegin !== pend && source[pbegin] === 0) {\n      pbegin++;\n      zeroes++;\n    }\n    var size = (pend - pbegin) * iFACTOR + 1 >>> 0;\n    var b58 = new Uint8Array(size);\n    while (pbegin !== pend) {\n      var carry = source[pbegin];\n      var i = 0;\n      for (var it1 = size - 1; (carry !== 0 || i < length) && it1 !== -1; it1--, i++) {\n        carry += 256 * b58[it1] >>> 0;\n        b58[it1] = carry % BASE >>> 0;\n        carry = carry / BASE >>> 0;\n      }\n      if (carry !== 0) {\n        throw new Error('Non-zero carry');\n      }\n      length = i;\n      pbegin++;\n    }\n    var it2 = size - length;\n    while (it2 !== size && b58[it2] === 0) {\n      it2++;\n    }\n    var str = LEADER.repeat(zeroes);\n    for (; it2 < size; ++it2) {\n      str += ALPHABET.charAt(b58[it2]);\n    }\n    return str;\n  }\n  function decodeUnsafe(source) {\n    if (typeof source !== 'string') {\n      throw new TypeError('Expected String');\n    }\n    if (source.length === 0) {\n      return new Uint8Array();\n    }\n    var psz = 0;\n    if (source[psz] === ' ') {\n      return;\n    }\n    var zeroes = 0;\n    var length = 0;\n    while (source[psz] === LEADER) {\n      zeroes++;\n      psz++;\n    }\n    var size = (source.length - psz) * FACTOR + 1 >>> 0;\n    var b256 = new Uint8Array(size);\n    while (source[psz]) {\n      var carry = BASE_MAP[source.charCodeAt(psz)];\n      if (carry === 255) {\n        return;\n      }\n      var i = 0;\n      for (var it3 = size - 1; (carry !== 0 || i < length) && it3 !== -1; it3--, i++) {\n        carry += BASE * b256[it3] >>> 0;\n        b256[it3] = carry % 256 >>> 0;\n        carry = carry / 256 >>> 0;\n      }\n      if (carry !== 0) {\n        throw new Error('Non-zero carry');\n      }\n      length = i;\n      psz++;\n    }\n    if (source[psz] === ' ') {\n      return;\n    }\n    var it4 = size - length;\n    while (it4 !== size && b256[it4] === 0) {\n      it4++;\n    }\n    var vch = new Uint8Array(zeroes + (size - it4));\n    var j = zeroes;\n    while (it4 !== size) {\n      vch[j++] = b256[it4++];\n    }\n    return vch;\n  }\n  function decode(string) {\n    var buffer = decodeUnsafe(string);\n    if (buffer) {\n      return buffer;\n    }\n    throw new Error(`Non-${ name } character`);\n  }\n  return {\n    encode: encode,\n    decodeUnsafe: decodeUnsafe,\n    decode: decode\n  };\n}\nvar src = base;\nvar _brrp__multiformats_scope_baseX = src;\n\nmodule.exports = _brrp__multiformats_scope_baseX;\n","'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\nvar base = require('./base.js');\n\nconst alphabet = Array.from('\\uD83D\\uDE80\\uD83E\\uDE90\\u2604\\uD83D\\uDEF0\\uD83C\\uDF0C\\uD83C\\uDF11\\uD83C\\uDF12\\uD83C\\uDF13\\uD83C\\uDF14\\uD83C\\uDF15\\uD83C\\uDF16\\uD83C\\uDF17\\uD83C\\uDF18\\uD83C\\uDF0D\\uD83C\\uDF0F\\uD83C\\uDF0E\\uD83D\\uDC09\\u2600\\uD83D\\uDCBB\\uD83D\\uDDA5\\uD83D\\uDCBE\\uD83D\\uDCBF\\uD83D\\uDE02\\u2764\\uD83D\\uDE0D\\uD83E\\uDD23\\uD83D\\uDE0A\\uD83D\\uDE4F\\uD83D\\uDC95\\uD83D\\uDE2D\\uD83D\\uDE18\\uD83D\\uDC4D\\uD83D\\uDE05\\uD83D\\uDC4F\\uD83D\\uDE01\\uD83D\\uDD25\\uD83E\\uDD70\\uD83D\\uDC94\\uD83D\\uDC96\\uD83D\\uDC99\\uD83D\\uDE22\\uD83E\\uDD14\\uD83D\\uDE06\\uD83D\\uDE44\\uD83D\\uDCAA\\uD83D\\uDE09\\u263A\\uD83D\\uDC4C\\uD83E\\uDD17\\uD83D\\uDC9C\\uD83D\\uDE14\\uD83D\\uDE0E\\uD83D\\uDE07\\uD83C\\uDF39\\uD83E\\uDD26\\uD83C\\uDF89\\uD83D\\uDC9E\\u270C\\u2728\\uD83E\\uDD37\\uD83D\\uDE31\\uD83D\\uDE0C\\uD83C\\uDF38\\uD83D\\uDE4C\\uD83D\\uDE0B\\uD83D\\uDC97\\uD83D\\uDC9A\\uD83D\\uDE0F\\uD83D\\uDC9B\\uD83D\\uDE42\\uD83D\\uDC93\\uD83E\\uDD29\\uD83D\\uDE04\\uD83D\\uDE00\\uD83D\\uDDA4\\uD83D\\uDE03\\uD83D\\uDCAF\\uD83D\\uDE48\\uD83D\\uDC47\\uD83C\\uDFB6\\uD83D\\uDE12\\uD83E\\uDD2D\\u2763\\uD83D\\uDE1C\\uD83D\\uDC8B\\uD83D\\uDC40\\uD83D\\uDE2A\\uD83D\\uDE11\\uD83D\\uDCA5\\uD83D\\uDE4B\\uD83D\\uDE1E\\uD83D\\uDE29\\uD83D\\uDE21\\uD83E\\uDD2A\\uD83D\\uDC4A\\uD83E\\uDD73\\uD83D\\uDE25\\uD83E\\uDD24\\uD83D\\uDC49\\uD83D\\uDC83\\uD83D\\uDE33\\u270B\\uD83D\\uDE1A\\uD83D\\uDE1D\\uD83D\\uDE34\\uD83C\\uDF1F\\uD83D\\uDE2C\\uD83D\\uDE43\\uD83C\\uDF40\\uD83C\\uDF37\\uD83D\\uDE3B\\uD83D\\uDE13\\u2B50\\u2705\\uD83E\\uDD7A\\uD83C\\uDF08\\uD83D\\uDE08\\uD83E\\uDD18\\uD83D\\uDCA6\\u2714\\uD83D\\uDE23\\uD83C\\uDFC3\\uD83D\\uDC90\\u2639\\uD83C\\uDF8A\\uD83D\\uDC98\\uD83D\\uDE20\\u261D\\uD83D\\uDE15\\uD83C\\uDF3A\\uD83C\\uDF82\\uD83C\\uDF3B\\uD83D\\uDE10\\uD83D\\uDD95\\uD83D\\uDC9D\\uD83D\\uDE4A\\uD83D\\uDE39\\uD83D\\uDDE3\\uD83D\\uDCAB\\uD83D\\uDC80\\uD83D\\uDC51\\uD83C\\uDFB5\\uD83E\\uDD1E\\uD83D\\uDE1B\\uD83D\\uDD34\\uD83D\\uDE24\\uD83C\\uDF3C\\uD83D\\uDE2B\\u26BD\\uD83E\\uDD19\\u2615\\uD83C\\uDFC6\\uD83E\\uDD2B\\uD83D\\uDC48\\uD83D\\uDE2E\\uD83D\\uDE46\\uD83C\\uDF7B\\uD83C\\uDF43\\uD83D\\uDC36\\uD83D\\uDC81\\uD83D\\uDE32\\uD83C\\uDF3F\\uD83E\\uDDE1\\uD83C\\uDF81\\u26A1\\uD83C\\uDF1E\\uD83C\\uDF88\\u274C\\u270A\\uD83D\\uDC4B\\uD83D\\uDE30\\uD83E\\uDD28\\uD83D\\uDE36\\uD83E\\uDD1D\\uD83D\\uDEB6\\uD83D\\uDCB0\\uD83C\\uDF53\\uD83D\\uDCA2\\uD83E\\uDD1F\\uD83D\\uDE41\\uD83D\\uDEA8\\uD83D\\uDCA8\\uD83E\\uDD2C\\u2708\\uD83C\\uDF80\\uD83C\\uDF7A\\uD83E\\uDD13\\uD83D\\uDE19\\uD83D\\uDC9F\\uD83C\\uDF31\\uD83D\\uDE16\\uD83D\\uDC76\\uD83E\\uDD74\\u25B6\\u27A1\\u2753\\uD83D\\uDC8E\\uD83D\\uDCB8\\u2B07\\uD83D\\uDE28\\uD83C\\uDF1A\\uD83E\\uDD8B\\uD83D\\uDE37\\uD83D\\uDD7A\\u26A0\\uD83D\\uDE45\\uD83D\\uDE1F\\uD83D\\uDE35\\uD83D\\uDC4E\\uD83E\\uDD32\\uD83E\\uDD20\\uD83E\\uDD27\\uD83D\\uDCCC\\uD83D\\uDD35\\uD83D\\uDC85\\uD83E\\uDDD0\\uD83D\\uDC3E\\uD83C\\uDF52\\uD83D\\uDE17\\uD83E\\uDD11\\uD83C\\uDF0A\\uD83E\\uDD2F\\uD83D\\uDC37\\u260E\\uD83D\\uDCA7\\uD83D\\uDE2F\\uD83D\\uDC86\\uD83D\\uDC46\\uD83C\\uDFA4\\uD83D\\uDE47\\uD83C\\uDF51\\u2744\\uD83C\\uDF34\\uD83D\\uDCA3\\uD83D\\uDC38\\uD83D\\uDC8C\\uD83D\\uDCCD\\uD83E\\uDD40\\uD83E\\uDD22\\uD83D\\uDC45\\uD83D\\uDCA1\\uD83D\\uDCA9\\uD83D\\uDC50\\uD83D\\uDCF8\\uD83D\\uDC7B\\uD83E\\uDD10\\uD83E\\uDD2E\\uD83C\\uDFBC\\uD83E\\uDD75\\uD83D\\uDEA9\\uD83C\\uDF4E\\uD83C\\uDF4A\\uD83D\\uDC7C\\uD83D\\uDC8D\\uD83D\\uDCE3\\uD83E\\uDD42');\nconst alphabetBytesToChars = alphabet.reduce((p, c, i) => {\n  p[i] = c;\n  return p;\n}, []);\nconst alphabetCharsToBytes = alphabet.reduce((p, c, i) => {\n  p[c.codePointAt(0)] = i;\n  return p;\n}, []);\nfunction encode(data) {\n  return data.reduce((p, c) => {\n    p += alphabetBytesToChars[c];\n    return p;\n  }, '');\n}\nfunction decode(str) {\n  const byts = [];\n  for (const char of str) {\n    const byt = alphabetCharsToBytes[char.codePointAt(0)];\n    if (byt === undefined) {\n      throw new Error(`Non-base256emoji character: ${ char }`);\n    }\n    byts.push(byt);\n  }\n  return new Uint8Array(byts);\n}\nconst base256emoji = base.from({\n  prefix: '\\uD83D\\uDE80',\n  name: 'base256emoji',\n  encode,\n  decode\n});\n\nexports.base256emoji = base256emoji;\n","'use strict'\n\nconst table = require('./base-table.json')\n\n// map for codecConstant -> code\nconst constants = {}\n\nfor (const [name, code] of Object.entries(table)) {\n  constants[name.toUpperCase().replace(/-/g, '_')] = code\n}\n\nmodule.exports = Object.freeze(constants)\n","'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\nconst textEncoder = new TextEncoder();\nconst textDecoder = new TextDecoder();\nconst name = 'json';\nconst code = 512;\nconst encode = node => textEncoder.encode(JSON.stringify(node));\nconst decode = data => JSON.parse(textDecoder.decode(data));\n\nexports.code = code;\nexports.decode = decode;\nexports.encode = encode;\nexports.name = name;\n","'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\nvar hasher = require('./hasher.js');\n\nconst sha = name => async data => new Uint8Array(await crypto.subtle.digest(name, data));\nconst sha256 = hasher.from({\n  name: 'sha2-256',\n  code: 18,\n  encode: sha('SHA-256')\n});\nconst sha512 = hasher.from({\n  name: 'sha2-512',\n  code: 19,\n  encode: sha('SHA-512')\n});\n\nexports.sha256 = sha256;\nexports.sha512 = sha512;\n","'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\nvar base = require('./base.js');\nvar bytes = require('../bytes.js');\n\nconst identity = base.from({\n  prefix: '\\0',\n  name: 'identity',\n  encode: buf => bytes.toString(buf),\n  decode: str => bytes.fromString(str)\n});\n\nexports.identity = identity;\n","'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\nvar bytes = require('../bytes.js');\n\nconst name = 'raw';\nconst code = 85;\nconst encode = node => bytes.coerce(node);\nconst decode = data => bytes.coerce(data);\n\nexports.code = code;\nexports.decode = decode;\nexports.encode = encode;\nexports.name = name;\n","'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\nvar digest = require('./digest.js');\n\nconst from = ({name, code, encode}) => new Hasher(name, code, encode);\nclass Hasher {\n  constructor(name, code, encode) {\n    this.name = name;\n    this.code = code;\n    this.encode = encode;\n  }\n  digest(input) {\n    if (input instanceof Uint8Array) {\n      const result = this.encode(input);\n      return result instanceof Uint8Array ? digest.create(this.code, result) : result.then(digest$1 => digest.create(this.code, digest$1));\n    } else {\n      throw Error('Unknown type, must be binary type');\n    }\n  }\n}\n\nexports.Hasher = Hasher;\nexports.from = from;\n","'use strict'\n\nclass Base {\n  constructor (name, code, implementation, alphabet) {\n    this.name = name\n    this.code = code\n    this.alphabet = alphabet\n    if (implementation && alphabet) {\n      this.engine = implementation(alphabet)\n    }\n  }\n\n  encode (stringOrBuffer) {\n    return this.engine.encode(stringOrBuffer)\n  }\n\n  decode (stringOrBuffer) {\n    return this.engine.decode(stringOrBuffer)\n  }\n\n  isImplemented () {\n    return this.engine\n  }\n}\n\nmodule.exports = Base\n","var BN = require('bn.js');\nvar stripHexPrefix = require('strip-hex-prefix');\n\n/**\n * Returns a BN object, converts a number value to a BN\n * @param {String|Number|Object} `arg` input a string number, hex string number, number, BigNumber or BN object\n * @return {Object} `output` BN object of the number\n * @throws if the argument is not an array, object that isn't a bignumber, not a string number or number\n */\nmodule.exports = function numberToBN(arg) {\n  if (typeof arg === 'string' || typeof arg === 'number') {\n    var multiplier = new BN(1); // eslint-disable-line\n    var formattedString = String(arg).toLowerCase().trim();\n    var isHexPrefixed = formattedString.substr(0, 2) === '0x' || formattedString.substr(0, 3) === '-0x';\n    var stringArg = stripHexPrefix(formattedString); // eslint-disable-line\n    if (stringArg.substr(0, 1) === '-') {\n      stringArg = stripHexPrefix(stringArg.slice(1));\n      multiplier = new BN(-1, 10);\n    }\n    stringArg = stringArg === '' ? '0' : stringArg;\n\n    if ((!stringArg.match(/^-?[0-9]+$/) && stringArg.match(/^[0-9A-Fa-f]+$/))\n      || stringArg.match(/^[a-fA-F]+$/)\n      || (isHexPrefixed === true && stringArg.match(/^[0-9A-Fa-f]+$/))) {\n      return new BN(stringArg, 16).mul(multiplier);\n    }\n\n    if ((stringArg.match(/^-?[0-9]+$/) || stringArg === '') && isHexPrefixed === false) {\n      return new BN(stringArg, 10).mul(multiplier);\n    }\n  } else if (typeof arg === 'object' && arg.toString && (!arg.pop && !arg.push)) {\n    if (arg.toString(10).match(/^-?[0-9]+$/) && (arg.mul || arg.dividedToIntegerBy)) {\n      return new BN(arg.toString(10), 10);\n    }\n  }\n\n  throw new Error('[number-to-bn] while converting number ' + JSON.stringify(arg) + ' to BN.js instance, error: invalid number value. Value must be an integer, hex string, BN or BigNumber instance. Note, decimals are not supported.');\n}\n","'use strict'\n\nconst Base = require('./base.js')\nconst baseX = require('base-x')\nconst base16 = require('./base16')\nconst base32 = require('./base32')\nconst base64 = require('./base64')\n\n// name, code, implementation, alphabet\nconst constants = [\n  ['base1', '1', '', '1'],\n  ['base2', '0', baseX, '01'],\n  ['base8', '7', baseX, '01234567'],\n  ['base10', '9', baseX, '0123456789'],\n  ['base16', 'f', base16, '0123456789abcdef'],\n  ['base32', 'b', base32, 'abcdefghijklmnopqrstuvwxyz234567'],\n  ['base32pad', 'c', base32, 'abcdefghijklmnopqrstuvwxyz234567='],\n  ['base32hex', 'v', base32, '0123456789abcdefghijklmnopqrstuv'],\n  ['base32hexpad', 't', base32, '0123456789abcdefghijklmnopqrstuv='],\n  ['base32z', 'h', base32, 'ybndrfg8ejkmcpqxot1uwisza345h769'],\n  ['base58flickr', 'Z', baseX, '123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ'],\n  ['base58btc', 'z', baseX, '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'],\n  ['base64', 'm', base64, 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'],\n  ['base64pad', 'M', base64, 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/='],\n  ['base64url', 'u', base64, 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_'],\n  ['base64urlpad', 'U', base64, 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_=']\n]\n\nconst names = constants.reduce((prev, tupple) => {\n  prev[tupple[0]] = new Base(tupple[0], tupple[1], tupple[2], tupple[3])\n  return prev\n}, {})\n\nconst codes = constants.reduce((prev, tupple) => {\n  prev[tupple[1]] = names[tupple[0]]\n  return prev\n}, {})\n\nmodule.exports = {\n  names: names,\n  codes: codes\n}\n","'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\nvar varint$1 = require('../vendor/varint.js');\n\nconst decode = (data, offset = 0) => {\n  const code = varint$1.decode(data, offset);\n  return [\n    code,\n    varint$1.decode.bytes\n  ];\n};\nconst encodeTo = (int, target, offset = 0) => {\n  varint$1.encode(int, target, offset);\n  return target;\n};\nconst encodingLength = int => {\n  return varint$1.encodingLength(int);\n};\n\nexports.decode = decode;\nexports.encodeTo = encodeTo;\nexports.encodingLength = encodingLength;\n","'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\nvar identity = require('./bases/identity.js');\nvar base2 = require('./bases/base2.js');\nvar base8 = require('./bases/base8.js');\nvar base10 = require('./bases/base10.js');\nvar base16 = require('./bases/base16.js');\nvar base32 = require('./bases/base32.js');\nvar base36 = require('./bases/base36.js');\nvar base58 = require('./bases/base58.js');\nvar base64 = require('./bases/base64.js');\nvar base256emoji = require('./bases/base256emoji.js');\nvar sha2 = require('./hashes/sha2.js');\nvar identity$1 = require('./hashes/identity.js');\nvar raw = require('./codecs/raw.js');\nvar json = require('./codecs/json.js');\nrequire('./index.js');\nvar cid = require('./cid.js');\nvar hasher = require('./hashes/hasher.js');\nvar digest = require('./hashes/digest.js');\nvar varint = require('./varint.js');\nvar bytes = require('./bytes.js');\n\nconst bases = {\n  ...identity,\n  ...base2,\n  ...base8,\n  ...base10,\n  ...base16,\n  ...base32,\n  ...base36,\n  ...base58,\n  ...base64,\n  ...base256emoji\n};\nconst hashes = {\n  ...sha2,\n  ...identity$1\n};\nconst codecs = {\n  raw,\n  json\n};\n\nexports.CID = cid.CID;\nexports.hasher = hasher;\nexports.digest = digest;\nexports.varint = varint;\nexports.bytes = bytes;\nexports.bases = bases;\nexports.codecs = codecs;\nexports.hashes = hashes;\n","'use strict'\n\nfunction decode (input, alphabet) {\n  input = input.replace(new RegExp('=', 'g'), '')\n  const length = input.length\n\n  let bits = 0\n  let value = 0\n\n  let index = 0\n  const output = new Uint8Array((length * 5 / 8) | 0)\n\n  for (let i = 0; i < length; i++) {\n    value = (value << 5) | alphabet.indexOf(input[i])\n    bits += 5\n\n    if (bits >= 8) {\n      output[index++] = (value >>> (bits - 8)) & 255\n      bits -= 8\n    }\n  }\n\n  return output.buffer\n}\n\nfunction encode (buffer, alphabet) {\n  const length = buffer.byteLength\n  const view = new Uint8Array(buffer)\n  const padding = alphabet.indexOf('=') === alphabet.length - 1\n\n  if (padding) {\n    alphabet = alphabet.substring(0, alphabet.length - 1)\n  }\n\n  let bits = 0\n  let value = 0\n  let output = ''\n\n  for (let i = 0; i < length; i++) {\n    value = (value << 8) | view[i]\n    bits += 8\n\n    while (bits >= 5) {\n      output += alphabet[(value >>> (bits - 5)) & 31]\n      bits -= 5\n    }\n  }\n\n  if (bits > 0) {\n    output += alphabet[(value << (5 - bits)) & 31]\n  }\n\n  if (padding) {\n    while ((output.length % 8) !== 0) {\n      output += '='\n    }\n  }\n\n  return output\n}\n\nmodule.exports = function base32 (alphabet) {\n  return {\n    encode (input) {\n      if (typeof input === 'string') {\n        return encode(Uint8Array.from(input), alphabet)\n      }\n\n      return encode(input, alphabet)\n    },\n    decode (input) {\n      for (const char of input) {\n        if (alphabet.indexOf(char) < 0) {\n          throw new Error('invalid base32 character')\n        }\n      }\n\n      return decode(input, alphabet)\n    }\n  }\n}\n","'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\nvar base = require('./base.js');\n\nconst base10 = base.baseX({\n  prefix: '9',\n  name: 'base10',\n  alphabet: '0123456789'\n});\n\nexports.base10 = base10;\n","'use strict'\n\nconst baseTable = require('./base-table.json')\nconst varintEncode = require('./util').varintEncode\n\n// map for codecName -> codeVarintBuffer\nconst varintTable = {}\n\nfor (const encodingName in baseTable) {\n  const code = baseTable[encodingName]\n  varintTable[encodingName] = varintEncode(code)\n}\n\nmodule.exports = Object.freeze(varintTable)\n","'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\nvar base = require('./base.js');\n\nconst base2 = base.rfc4648({\n  prefix: '0',\n  name: 'base2',\n  alphabet: '01',\n  bitsPerChar: 1\n});\n\nexports.base2 = base2;\n","'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\nvar cid = require('./cid.js');\nvar varint = require('./varint.js');\nvar bytes = require('./bytes.js');\nvar hasher = require('./hashes/hasher.js');\nvar digest = require('./hashes/digest.js');\n\n\n\nexports.CID = cid.CID;\nexports.varint = varint;\nexports.bytes = bytes;\nexports.hasher = hasher;\nexports.digest = digest;\n","'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\nvar baseX$1 = require('../../vendor/base-x.js');\nvar bytes = require('../bytes.js');\n\nclass Encoder {\n  constructor(name, prefix, baseEncode) {\n    this.name = name;\n    this.prefix = prefix;\n    this.baseEncode = baseEncode;\n  }\n  encode(bytes) {\n    if (bytes instanceof Uint8Array) {\n      return `${ this.prefix }${ this.baseEncode(bytes) }`;\n    } else {\n      throw Error('Unknown type, must be binary type');\n    }\n  }\n}\nclass Decoder {\n  constructor(name, prefix, baseDecode) {\n    this.name = name;\n    this.prefix = prefix;\n    if (prefix.codePointAt(0) === undefined) {\n      throw new Error('Invalid prefix character');\n    }\n    this.prefixCodePoint = prefix.codePointAt(0);\n    this.baseDecode = baseDecode;\n  }\n  decode(text) {\n    if (typeof text === 'string') {\n      if (text.codePointAt(0) !== this.prefixCodePoint) {\n        throw Error(`Unable to decode multibase string ${ JSON.stringify(text) }, ${ this.name } decoder only supports inputs prefixed with ${ this.prefix }`);\n      }\n      return this.baseDecode(text.slice(this.prefix.length));\n    } else {\n      throw Error('Can only multibase decode strings');\n    }\n  }\n  or(decoder) {\n    return or(this, decoder);\n  }\n}\nclass ComposedDecoder {\n  constructor(decoders) {\n    this.decoders = decoders;\n  }\n  or(decoder) {\n    return or(this, decoder);\n  }\n  decode(input) {\n    const prefix = input[0];\n    const decoder = this.decoders[prefix];\n    if (decoder) {\n      return decoder.decode(input);\n    } else {\n      throw RangeError(`Unable to decode multibase string ${ JSON.stringify(input) }, only inputs prefixed with ${ Object.keys(this.decoders) } are supported`);\n    }\n  }\n}\nconst or = (left, right) => new ComposedDecoder({\n  ...left.decoders || { [left.prefix]: left },\n  ...right.decoders || { [right.prefix]: right }\n});\nclass Codec {\n  constructor(name, prefix, baseEncode, baseDecode) {\n    this.name = name;\n    this.prefix = prefix;\n    this.baseEncode = baseEncode;\n    this.baseDecode = baseDecode;\n    this.encoder = new Encoder(name, prefix, baseEncode);\n    this.decoder = new Decoder(name, prefix, baseDecode);\n  }\n  encode(input) {\n    return this.encoder.encode(input);\n  }\n  decode(input) {\n    return this.decoder.decode(input);\n  }\n}\nconst from = ({name, prefix, encode, decode}) => new Codec(name, prefix, encode, decode);\nconst baseX = ({prefix, name, alphabet}) => {\n  const {encode, decode} = baseX$1(alphabet, name);\n  return from({\n    prefix,\n    name,\n    encode,\n    decode: text => bytes.coerce(decode(text))\n  });\n};\nconst decode = (string, alphabet, bitsPerChar, name) => {\n  const codes = {};\n  for (let i = 0; i < alphabet.length; ++i) {\n    codes[alphabet[i]] = i;\n  }\n  let end = string.length;\n  while (string[end - 1] === '=') {\n    --end;\n  }\n  const out = new Uint8Array(end * bitsPerChar / 8 | 0);\n  let bits = 0;\n  let buffer = 0;\n  let written = 0;\n  for (let i = 0; i < end; ++i) {\n    const value = codes[string[i]];\n    if (value === undefined) {\n      throw new SyntaxError(`Non-${ name } character`);\n    }\n    buffer = buffer << bitsPerChar | value;\n    bits += bitsPerChar;\n    if (bits >= 8) {\n      bits -= 8;\n      out[written++] = 255 & buffer >> bits;\n    }\n  }\n  if (bits >= bitsPerChar || 255 & buffer << 8 - bits) {\n    throw new SyntaxError('Unexpected end of data');\n  }\n  return out;\n};\nconst encode = (data, alphabet, bitsPerChar) => {\n  const pad = alphabet[alphabet.length - 1] === '=';\n  const mask = (1 << bitsPerChar) - 1;\n  let out = '';\n  let bits = 0;\n  let buffer = 0;\n  for (let i = 0; i < data.length; ++i) {\n    buffer = buffer << 8 | data[i];\n    bits += 8;\n    while (bits > bitsPerChar) {\n      bits -= bitsPerChar;\n      out += alphabet[mask & buffer >> bits];\n    }\n  }\n  if (bits) {\n    out += alphabet[mask & buffer << bitsPerChar - bits];\n  }\n  if (pad) {\n    while (out.length * bitsPerChar & 7) {\n      out += '=';\n    }\n  }\n  return out;\n};\nconst rfc4648 = ({name, prefix, bitsPerChar, alphabet}) => {\n  return from({\n    prefix,\n    name,\n    encode(input) {\n      return encode(input, alphabet, bitsPerChar);\n    },\n    decode(input) {\n      return decode(input, alphabet, bitsPerChar, name);\n    }\n  });\n};\n\nexports.Codec = Codec;\nexports.baseX = baseX;\nexports.from = from;\nexports.or = or;\nexports.rfc4648 = rfc4648;\n","'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\nconst empty = new Uint8Array(0);\nconst toHex = d => d.reduce((hex, byte) => hex + byte.toString(16).padStart(2, '0'), '');\nconst fromHex = hex => {\n  const hexes = hex.match(/../g);\n  return hexes ? new Uint8Array(hexes.map(b => parseInt(b, 16))) : empty;\n};\nconst equals = (aa, bb) => {\n  if (aa === bb)\n    return true;\n  if (aa.byteLength !== bb.byteLength) {\n    return false;\n  }\n  for (let ii = 0; ii < aa.byteLength; ii++) {\n    if (aa[ii] !== bb[ii]) {\n      return false;\n    }\n  }\n  return true;\n};\nconst coerce = o => {\n  if (o instanceof Uint8Array && o.constructor.name === 'Uint8Array')\n    return o;\n  if (o instanceof ArrayBuffer)\n    return new Uint8Array(o);\n  if (ArrayBuffer.isView(o)) {\n    return new Uint8Array(o.buffer, o.byteOffset, o.byteLength);\n  }\n  throw new Error('Unknown type, must be binary type');\n};\nconst isBinary = o => o instanceof ArrayBuffer || ArrayBuffer.isView(o);\nconst fromString = str => new TextEncoder().encode(str);\nconst toString = b => new TextDecoder().decode(b);\n\nexports.coerce = coerce;\nexports.empty = empty;\nexports.equals = equals;\nexports.fromHex = fromHex;\nexports.fromString = fromString;\nexports.isBinary = isBinary;\nexports.toHex = toHex;\nexports.toString = toString;\n","'use strict'\nconst { Buffer } = require('buffer')\n\nmodule.exports = function base16 (alphabet) {\n  return {\n    encode (input) {\n      if (typeof input === 'string') {\n        return Buffer.from(input).toString('hex')\n      }\n      return input.toString('hex')\n    },\n    decode (input) {\n      for (const char of input) {\n        if (alphabet.indexOf(char) < 0) {\n          throw new Error('invalid base16 character')\n        }\n      }\n      return Buffer.from(input, 'hex')\n    }\n  }\n}\n","'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\nvar base = require('./base.js');\n\nconst base58btc = base.baseX({\n  name: 'base58btc',\n  prefix: 'z',\n  alphabet: '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'\n});\nconst base58flickr = base.baseX({\n  name: 'base58flickr',\n  prefix: 'Z',\n  alphabet: '123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ'\n});\n\nexports.base58btc = base58btc;\nexports.base58flickr = base58flickr;\n","'use strict'\nconst { Buffer } = require('buffer')\n\nmodule.exports = function base64 (alphabet) {\n  // The alphabet is only used to know:\n  //   1. If padding is enabled (must contain '=')\n  //   2. If the output must be url-safe (must contain '-' and '_')\n  //   3. If the input of the output function is valid\n  // The alphabets from RFC 4648 are always used.\n  const padding = alphabet.indexOf('=') > -1\n  const url = alphabet.indexOf('-') > -1 && alphabet.indexOf('_') > -1\n\n  return {\n    encode (input) {\n      let output = ''\n\n      if (typeof input === 'string') {\n        output = Buffer.from(input).toString('base64')\n      } else {\n        output = input.toString('base64')\n      }\n\n      if (url) {\n        output = output.replace(/\\+/g, '-').replace(/\\//g, '_')\n      }\n\n      const pad = output.indexOf('=')\n      if (pad > 0 && !padding) {\n        output = output.substring(0, pad)\n      }\n\n      return output\n    },\n    decode (input) {\n      for (const char of input) {\n        if (alphabet.indexOf(char) < 0) {\n          throw new Error('invalid base64 character')\n        }\n      }\n\n      return Buffer.from(input, 'base64')\n    }\n  }\n}\n","(function (module, exports) {\n  'use strict';\n\n  // Utils\n  function assert (val, msg) {\n    if (!val) throw new Error(msg || 'Assertion failed');\n  }\n\n  // Could use `inherits` module, but don't want to move from single file\n  // architecture yet.\n  function inherits (ctor, superCtor) {\n    ctor.super_ = superCtor;\n    var TempCtor = function () {};\n    TempCtor.prototype = superCtor.prototype;\n    ctor.prototype = new TempCtor();\n    ctor.prototype.constructor = ctor;\n  }\n\n  // BN\n\n  function BN (number, base, endian) {\n    if (BN.isBN(number)) {\n      return number;\n    }\n\n    this.negative = 0;\n    this.words = null;\n    this.length = 0;\n\n    // Reduction context\n    this.red = null;\n\n    if (number !== null) {\n      if (base === 'le' || base === 'be') {\n        endian = base;\n        base = 10;\n      }\n\n      this._init(number || 0, base || 10, endian || 'be');\n    }\n  }\n  if (typeof module === 'object') {\n    module.exports = BN;\n  } else {\n    exports.BN = BN;\n  }\n\n  BN.BN = BN;\n  BN.wordSize = 26;\n\n  var Buffer;\n  try {\n    Buffer = require('buf' + 'fer').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);\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","'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\nvar varint = require('./varint.js');\nvar digest = require('./hashes/digest.js');\nvar base58 = require('./bases/base58.js');\nvar base32 = require('./bases/base32.js');\nvar bytes = require('./bytes.js');\n\nclass CID {\n  constructor(version, code, multihash, bytes) {\n    this.code = code;\n    this.version = version;\n    this.multihash = multihash;\n    this.bytes = bytes;\n    this.byteOffset = bytes.byteOffset;\n    this.byteLength = bytes.byteLength;\n    this.asCID = this;\n    this._baseCache = new Map();\n    Object.defineProperties(this, {\n      byteOffset: hidden,\n      byteLength: hidden,\n      code: readonly,\n      version: readonly,\n      multihash: readonly,\n      bytes: readonly,\n      _baseCache: hidden,\n      asCID: hidden\n    });\n  }\n  toV0() {\n    switch (this.version) {\n    case 0: {\n        return this;\n      }\n    default: {\n        const {code, multihash} = this;\n        if (code !== DAG_PB_CODE) {\n          throw new Error('Cannot convert a non dag-pb CID to CIDv0');\n        }\n        if (multihash.code !== SHA_256_CODE) {\n          throw new Error('Cannot convert non sha2-256 multihash CID to CIDv0');\n        }\n        return CID.createV0(multihash);\n      }\n    }\n  }\n  toV1() {\n    switch (this.version) {\n    case 0: {\n        const {code, digest: digest$1} = this.multihash;\n        const multihash = digest.create(code, digest$1);\n        return CID.createV1(this.code, multihash);\n      }\n    case 1: {\n        return this;\n      }\n    default: {\n        throw Error(`Can not convert CID version ${ this.version } to version 0. This is a bug please report`);\n      }\n    }\n  }\n  equals(other) {\n    return other && this.code === other.code && this.version === other.version && digest.equals(this.multihash, other.multihash);\n  }\n  toString(base) {\n    const {bytes, version, _baseCache} = this;\n    switch (version) {\n    case 0:\n      return toStringV0(bytes, _baseCache, base || base58.base58btc.encoder);\n    default:\n      return toStringV1(bytes, _baseCache, base || base32.base32.encoder);\n    }\n  }\n  toJSON() {\n    return {\n      code: this.code,\n      version: this.version,\n      hash: this.multihash.bytes\n    };\n  }\n  get [Symbol.toStringTag]() {\n    return 'CID';\n  }\n  [Symbol.for('nodejs.util.inspect.custom')]() {\n    return 'CID(' + this.toString() + ')';\n  }\n  static isCID(value) {\n    deprecate(/^0\\.0/, IS_CID_DEPRECATION);\n    return !!(value && (value[cidSymbol] || value.asCID === value));\n  }\n  get toBaseEncodedString() {\n    throw new Error('Deprecated, use .toString()');\n  }\n  get codec() {\n    throw new Error('\"codec\" property is deprecated, use integer \"code\" property instead');\n  }\n  get buffer() {\n    throw new Error('Deprecated .buffer property, use .bytes to get Uint8Array instead');\n  }\n  get multibaseName() {\n    throw new Error('\"multibaseName\" property is deprecated');\n  }\n  get prefix() {\n    throw new Error('\"prefix\" property is deprecated');\n  }\n  static asCID(value) {\n    if (value instanceof CID) {\n      return value;\n    } else if (value != null && value.asCID === value) {\n      const {version, code, multihash, bytes} = value;\n      return new CID(version, code, multihash, bytes || encodeCID(version, code, multihash.bytes));\n    } else if (value != null && value[cidSymbol] === true) {\n      const {version, multihash, code} = value;\n      const digest$1 = digest.decode(multihash);\n      return CID.create(version, code, digest$1);\n    } else {\n      return null;\n    }\n  }\n  static create(version, code, digest) {\n    if (typeof code !== 'number') {\n      throw new Error('String codecs are no longer supported');\n    }\n    switch (version) {\n    case 0: {\n        if (code !== DAG_PB_CODE) {\n          throw new Error(`Version 0 CID must use dag-pb (code: ${ DAG_PB_CODE }) block encoding`);\n        } else {\n          return new CID(version, code, digest, digest.bytes);\n        }\n      }\n    case 1: {\n        const bytes = encodeCID(version, code, digest.bytes);\n        return new CID(version, code, digest, bytes);\n      }\n    default: {\n        throw new Error('Invalid version');\n      }\n    }\n  }\n  static createV0(digest) {\n    return CID.create(0, DAG_PB_CODE, digest);\n  }\n  static createV1(code, digest) {\n    return CID.create(1, code, digest);\n  }\n  static decode(bytes) {\n    const [cid, remainder] = CID.decodeFirst(bytes);\n    if (remainder.length) {\n      throw new Error('Incorrect length');\n    }\n    return cid;\n  }\n  static decodeFirst(bytes$1) {\n    const specs = CID.inspectBytes(bytes$1);\n    const prefixSize = specs.size - specs.multihashSize;\n    const multihashBytes = bytes.coerce(bytes$1.subarray(prefixSize, prefixSize + specs.multihashSize));\n    if (multihashBytes.byteLength !== specs.multihashSize) {\n      throw new Error('Incorrect length');\n    }\n    const digestBytes = multihashBytes.subarray(specs.multihashSize - specs.digestSize);\n    const digest$1 = new digest.Digest(specs.multihashCode, specs.digestSize, digestBytes, multihashBytes);\n    const cid = specs.version === 0 ? CID.createV0(digest$1) : CID.createV1(specs.codec, digest$1);\n    return [\n      cid,\n      bytes$1.subarray(specs.size)\n    ];\n  }\n  static inspectBytes(initialBytes) {\n    let offset = 0;\n    const next = () => {\n      const [i, length] = varint.decode(initialBytes.subarray(offset));\n      offset += length;\n      return i;\n    };\n    let version = next();\n    let codec = DAG_PB_CODE;\n    if (version === 18) {\n      version = 0;\n      offset = 0;\n    } else if (version === 1) {\n      codec = next();\n    }\n    if (version !== 0 && version !== 1) {\n      throw new RangeError(`Invalid CID version ${ version }`);\n    }\n    const prefixSize = offset;\n    const multihashCode = next();\n    const digestSize = next();\n    const size = offset + digestSize;\n    const multihashSize = size - prefixSize;\n    return {\n      version,\n      codec,\n      multihashCode,\n      digestSize,\n      multihashSize,\n      size\n    };\n  }\n  static parse(source, base) {\n    const [prefix, bytes] = parseCIDtoBytes(source, base);\n    const cid = CID.decode(bytes);\n    cid._baseCache.set(prefix, source);\n    return cid;\n  }\n}\nconst parseCIDtoBytes = (source, base) => {\n  switch (source[0]) {\n  case 'Q': {\n      const decoder = base || base58.base58btc;\n      return [\n        base58.base58btc.prefix,\n        decoder.decode(`${ base58.base58btc.prefix }${ source }`)\n      ];\n    }\n  case base58.base58btc.prefix: {\n      const decoder = base || base58.base58btc;\n      return [\n        base58.base58btc.prefix,\n        decoder.decode(source)\n      ];\n    }\n  case base32.base32.prefix: {\n      const decoder = base || base32.base32;\n      return [\n        base32.base32.prefix,\n        decoder.decode(source)\n      ];\n    }\n  default: {\n      if (base == null) {\n        throw Error('To parse non base32 or base58btc encoded CID multibase decoder must be provided');\n      }\n      return [\n        source[0],\n        base.decode(source)\n      ];\n    }\n  }\n};\nconst toStringV0 = (bytes, cache, base) => {\n  const {prefix} = base;\n  if (prefix !== base58.base58btc.prefix) {\n    throw Error(`Cannot string encode V0 in ${ base.name } encoding`);\n  }\n  const cid = cache.get(prefix);\n  if (cid == null) {\n    const cid = base.encode(bytes).slice(1);\n    cache.set(prefix, cid);\n    return cid;\n  } else {\n    return cid;\n  }\n};\nconst toStringV1 = (bytes, cache, base) => {\n  const {prefix} = base;\n  const cid = cache.get(prefix);\n  if (cid == null) {\n    const cid = base.encode(bytes);\n    cache.set(prefix, cid);\n    return cid;\n  } else {\n    return cid;\n  }\n};\nconst DAG_PB_CODE = 112;\nconst SHA_256_CODE = 18;\nconst encodeCID = (version, code, multihash) => {\n  const codeOffset = varint.encodingLength(version);\n  const hashOffset = codeOffset + varint.encodingLength(code);\n  const bytes = new Uint8Array(hashOffset + multihash.byteLength);\n  varint.encodeTo(version, bytes, 0);\n  varint.encodeTo(code, bytes, codeOffset);\n  bytes.set(multihash, hashOffset);\n  return bytes;\n};\nconst cidSymbol = Symbol.for('@ipld/js-cid/CID');\nconst readonly = {\n  writable: false,\n  configurable: false,\n  enumerable: true\n};\nconst hidden = {\n  writable: false,\n  enumerable: false,\n  configurable: false\n};\nconst version = '0.0.0-dev';\nconst deprecate = (range, message) => {\n  if (range.test(version)) {\n    console.warn(message);\n  } else {\n    throw new Error(message);\n  }\n};\nconst IS_CID_DEPRECATION = `CID.isCID(v) is deprecated and will be removed in the next major release.\nFollowing code pattern:\n\nif (CID.isCID(value)) {\n  doSomethingWithCID(value)\n}\n\nIs replaced with:\n\nconst cid = CID.asCID(value)\nif (cid) {\n  // Make sure to use cid instead of value\n  doSomethingWithCID(cid)\n}\n`;\n\nexports.CID = CID;\n"],"sourceRoot":""}